Java - ayuda con sistema de compra de pasajes de avion

 
Vista:

ayuda con sistema de compra de pasajes de avion

Publicado por Blow (1 intervención) el 10/09/2023 01:02:28
La aerolínea CaleucheAir se encuentra modernizando sus procesos, por lo cual ha decidido contratar sus servicios para que desarrolle un sistema que permita vender los pasajes.
Si bien es una aerolínea pequeña, realiza el mismo vuelo una vez a la semana, desde la isla de Chiloé a Valdivia.
Por lo que se necesita un sistema que una vez por semana permita vender pasajes, crear nuevos pasajeros que compran pasajes y llenar toda la información que el vuelo requiere.
Los atributos de los pasajeros son:
- Rut.
- Nombre.
- Apellido.
- Edad.
Los atributos de los pasajes son:
- Numero de asiento.
- Destino.
- Valor.
- Pasajero.
- Trae equipaje o no.
Utilizando las siguientes reglas de negocio establecidas por la aerolínea:
- Por seguridad, ningún dato del pasajero puede estar vacío.
- El valor de los 8 primeros asientos es de 35.990 y el resto 25.990.
- Si el pasajero trae equipaje el costo del pasaje debe aumentar en 10%.
- Al ser un viaje corto, el avión que realiza el tramo tiene capacidad máxima para 20 pasajeros.
El main debe realizar lo siguiente
- Crear pasajero
- Crear un pasaje asociándole el pasajero creado
o Al finalizar la creación del pasaje, mostrar todos los datos del pasaje
- Mostrar información de los pasajes vendidos:
o Nombre del pasajero
o Valor final del pasaje
o Numero de asiento
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder
Imágen de perfil de Kabuto
Val: 3.428
Oro
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

ayuda con sistema de compra de pasajes de avion

Publicado por Kabuto (1383 intervenciones) el 10/09/2023 14:19:40
Hola.
Primero necesitas la clase Pasajero, con los atributos que indica el enunciado.
Entre sus métodos puede interesar incluirle el método toString para tener una forma rápida de mostrar los datos relevantes en pantalla.
Y opcionalmente, también el método equals() y sobre escribirlo para hacer que dos Pasajeros se consideren "iguales" si tienen el mismo RUT.
Esto sirve por ejemplo para prevenir que por error se registren dos pasajeros con el mismo RUT.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
public class Pasajero {
 
	private String rut;
	private String nombre;
	private String apellido;
	private int edad;
 
	public Pasajero(String rut, String nombre, String apellido, int edad) {
		this.rut = rut;
		this.nombre = nombre;
		this.apellido = apellido;
		this.edad = edad;
	}
 
	public String getRut() {
		return rut;
	}
 
	public void setRut(String rut) {
		this.rut = rut;
	}
 
	public String getNombre() {
		return nombre;
	}
 
	public void setNombre(String nombre) {
		this.nombre = nombre;
	}
 
	public String getApellido() {
		return apellido;
	}
 
	public void setApellido(String apellido) {
		this.apellido = apellido;
	}
 
	public int getEdad() {
		return edad;
	}
 
	public void setEdad(int edad) {
		this.edad = edad;
	}
 
	@Override
	public String toString() {
		return String.format("RUT: %s -- %s %s", rut, nombre, apellido);
	}
 
	@Override
	/**
	 * Determina si dos pasajeros son iguales.
	 * Dos pasajeros se consideran iguales si tienen
	 * el mismo RUT
	 */
	public boolean equals(Object objeto) {
		if (objeto instanceof Pasajero) {
			Pasajero otroPasajero = (Pasajero) objeto;
			return this.rut.equals(otroPasajero.rut);
		}
		return false;
	}
}

La siguiente entidad a escribir sería la clase Pasaje.
Aquí hay que recordar que el valor del pasaje se puede incrementar un 10% si viaja con equipaje. Esto lo tendremos en cuenta en el método getValor().
También podemos darle un toString() para mostrar los datos que nos interesen en pantalla.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
public class Pasaje {
 
	private int numAsiento;
	private String destino;
	private int valor;
	private Pasajero pasajero;
	private boolean equipaje;
 
	public Pasaje(int numAsiento, String destino, int valor, Pasajero pasajero, boolean equipaje) {
		this.numAsiento = numAsiento;
		this.destino = destino;
		this.valor = valor;
		this.pasajero = pasajero;
		this.equipaje = equipaje;
	}
 
	public int getNumAsiento() {
		return numAsiento;
	}
 
	public void setNumAsiento(int numAsiento) {
		this.numAsiento = numAsiento;
	}
 
	public String getDestino() {
		return destino;
	}
 
	public void setDestino(String destino) {
		this.destino = destino;
	}
 
	public int getValor() {
		if (equipaje)
			return valor + valor / 10;//Incrementa 10% por equipaje
		else
			return valor;
	}
 
	public void setValor(int valor) {
		this.valor = valor;
	}
 
	public Pasajero getPasajero() {
		return pasajero;
	}
 
	public void setPasajero(Pasajero pasajero) {
		this.pasajero = pasajero;
	}
 
	public boolean conEquipaje() {
		return equipaje;
	}
 
	public void setEquipaje(boolean equipaje) {
		this.equipaje = equipaje;
	}
 
	@Override
	public String toString() {
		return String.format("\tNombre: %s %s\n\tAsiento: %02d\tValor: %d",
				pasajero.getNombre(), pasajero.getApellido(), numAsiento, getValor());
	}
 
}

Tenemos ya las dos entidades principales, ahora hay que desarrollar el main.

Nos dicen que hay que crear Pasajeros, por tanto, nos interesará tener un ArrayList para almacenar Pasajeros.
También otro ArrayList para guardar los Pasajes que se vayan vendiendo. Sabemos que como máximo serán 20, así que podemos pedirle al ArrayList que reserve 20 espacios en memoria.

Al vender pasajes, hay que elegir un número de asiento. Si queremos controlar que no se pueda elegir un número que ya ha sido vendido en otro pasaje, tenemos que pensar algún método de control.
Una forma sería consultar los pasajes vendidos y comprobar si el asiento elegido por el usuario, ha sido usado ya anteriormente.
Pero quizás sea más cómodo crear otro ArrayList con los números disponibles (1 al 20 por ejemplo). Y cada vez que se elige un asiento, lo eliminamos de ese ArrayList. Así en todo momento tendremos a mano una lista de los asientos que van quedando disponibles.
Además, esta lista nos puede servir también pasa saber rápidamente cuándo se han agotado todos los pasajes disponibles.

El main lo podemos estructurar en un menú de 4 opciones:
-Crear Pasajero
-Vender Pasaje
-Listar Pasajes vendidos
-Cerrar programa

Así que mostraremos un menú con esas opciones, pediremos que elijan una y con un switch podemos evaluar cuál ha elegido el usuario.
Según esa elección, llamaremos a un método u otro para que realice la tarea correspondiente.

Para crear un Pasajero, interesa tener en cuenta que no se dupliquen pasajeros con el mismo RUT.
Si en su clase le hemos puesto el método equals(), esto será fácil de comprobar.

Para vender un Pasaje, el usuario tendrá que elegir uno ya creado. Si no hay ninguno registrado, podemos darle la posibilidad de crearlo en ese momento sin tener que regresar al menú principal.

No podemos aceptar datos en blanco, así que podemos hacer un método que repita la petición de un dato si el usuario no le está dando un valor aceptable. Así podremos llamar a ese método cada vez que queramos un dato.

El numero de asiento, como hemos dicho, tendremos una lista con los números disponibles que se irá actualizando tras cada pasaje vendido.
Este proceso también lo haremos con un método específico.

En fin, para cada cosa que requiera cierta computación, la haremos en un método separado para que todo quede mejor estructurado.

Pongo el código a continuación, cada método va documentado para explicar su propósito. En cualquier caso, si tienes dudas, algo no se entiende, algo consideras que debiera ser distinto,... publícalo aquí y lo comentamos.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
import java.util.ArrayList;
import java.util.Scanner;
 
public class CaleucheAir {
 
	private static ArrayList<Pasajero> pasajeros = new ArrayList<Pasajero>();
	private static ArrayList<Pasaje> pasajes = new ArrayList<Pasaje>(20);
	private static ArrayList<Integer> asientosDisponibles;
	private static Scanner teclado = new Scanner(System.in);
 
	public static void main(String[] args) {
 
		inicializarAsientos();
		int opcion = 0;
 
		while (opcion != 4) {
			mostrarMenu();
			opcion = Integer.parseInt(teclado.nextLine());
			switch(opcion) {
			case 1:
				crearPasajero();
				break;
			case 2:
				venderPasaje();
				break;
			case 3:
				listarPasajes();
				break;
			case 4:
				System.out.println("\n\t\tFIN DE PROGRAMA");
				break;
			default:
				System.out.println("Opcion invalida");
			}
		}
 
	}
 
	/**
	 * Muestra en pantalla el menú de opciones de la aerolínea
	 */
	private static void mostrarMenu() {
		System.out.println("\n\t\tAEROLINEA CALEUCHEAIR");
		System.out.println("\t\t--------- -----------");
		System.out.println("[1] -- Crear Pasajero");
		System.out.println("[2] -- Vender Pasaje");
		System.out.println("[3] -- Listar Pasajes vendidos");
		System.out.println("[4] -- Terminar programa");
		System.out.print("Elija opcion: ");
	}
 
	/**
	 * Solicita los datos necesarios para crear un Pasajero
	 * y lo registra, excepto si ya existe el mismo RUT en el registro.
	 * @return Pasajero que se ha creado
	 */
	private static Pasajero crearPasajero() {
		System.out.println("\n\tDATOS PASAJERO");
		System.out.print("RUT: ");
		String rut = pedirDato();
		System.out.print("Nombre: ");
		String nombre = pedirDato();
		System.out.print("Apellido: ");
		String apellido = pedirDato();
		System.out.print("Edad: ");
		int edad = Integer.parseInt(pedirDato());
		Pasajero creado = new Pasajero(rut, nombre, apellido, edad);
 
		if (pasajeros.contains(creado)) {
			System.out.println("Ya existe un Pasajero con este RUT.\nImposible registrar otro.");
			return null;
		}
		else {
			pasajeros.add(creado);
			System.out.println("Pasajero registrado.");
			return creado;
		}
	}
 
	/**
	 * Permite elegir un pasajero de entre los que hay registrados.
	 * @return Pasajero escogido.
	 */
	private static Pasajero elegirPasajero() {
		Pasajero buscar = null;
 
		System.out.println("Pasajeros registrados:");
		for (Pasajero pas: pasajeros)
			System.out.print("\n-> " + pas);
 
		System.out.println("\nSeleccione pasajero indicando su RUT");
		while (buscar == null) {
			System.out.print("RUT: ");
			String rut = pedirDato();
			for (Pasajero pas: pasajeros)
				if (pas.getRut().equals(rut))
					buscar = pas;
 
			if (buscar == null)
				System.out.println("No se ha encontrado pasajero con ese RUT\n");
		}
 
		return buscar;
	}
 
	/**
	 * Solicita los datos necesarios para crea un Pasaje
	 * y lo retorna.
	 * @return El pasaje creado
	 */
	private static void venderPasaje() {
 
		System.out.println("\n\n\t\tVENDER PASAJE");
		System.out.println("\t\t------ ------");
 
 
		if (asientosDisponibles.isEmpty())
			System.out.println("No quedan pasajes disponibles.\nEl avion esta lleno.");
		else {
			Pasajero pasajero = null;
 
			if (pasajeros.isEmpty()) {
				System.out.println("No hay registros de Pasajeros\nProceda a registrar uno");
				pasajero = crearPasajero();
			}
			else
				pasajero = elegirPasajero();
 
			int asiento = pedirAsiento();
			System.out.print("Destino: ");
			String destino = pedirDato();
			boolean equipaje = preguntarEquipaje();
			//Valor depende de si se han vendido ya los 8 primeros asientos.
			int valor;
			if (pasajes.size() < 8)
				valor = 35990;
			else
				valor = 25990;
 
			//Tenemos los datos para crear un Pasaje
			Pasaje pasajeVendido = new Pasaje(asiento, destino, valor, pasajero, equipaje);
			System.out.println("\nDatos del pasaje vendido:");
			System.out.println("Pasajero: " + pasajeVendido.getPasajero().getNombre() + " "
					+ pasajeVendido.getPasajero().getApellido());
			System.out.println("Asiento: " + pasajeVendido.getNumAsiento());
			System.out.println("Destino: " + pasajeVendido.getDestino());
			System.out.println("Equipaje: " + (pasajeVendido.conEquipaje()?"Si":"No"));
			System.out.println("Valor: " + pasajeVendido.getValor());
 
			pasajes.add(pasajeVendido);
 
		}
	}
 
	private static void listarPasajes() {
		System.out.println("\n\n\t\tPASAJES VENDIDOS");
		System.out.println("\t\t------- --------");
		if (pasajes.isEmpty())
			System.out.println("No hay ventas registradas");
		else {
			for (Pasaje pas: pasajes) {
				System.out.println("\n\t***************************");
				System.out.println(pas);
				System.out.println("\t***************************");
			}
		}
	}
 
	/**
	 * Repite la solicitud de un dato hasta comprobar que
	 * el usuario ha proporcionado algo que no sea un campo vacío
	 * o espacios en blanco
	 * @return El dato introducido
	 */
	private static String pedirDato() {
		String dato = "";
 
		while (dato.isBlank()) {
			dato = teclado.nextLine();
		}
 
		return dato;
	}
 
	/**
	 * Solicita un nº de asiento y se asegura de que la
	 * elección sea un asiento realmente disponible
	 * @return El nº de asiento escogido
	 */
	private static int pedirAsiento() {
		int asiento = 0;
 
		System.out.println("\nAsientos disponibles:");
		for (int num: asientosDisponibles)
			System.out.print(num + " ");
 
		while (asiento == 0) {
			System.out.print("\nElija asiento: ");
			Integer elegido = Integer.parseInt(pedirDato());
			if (asientosDisponibles.contains(elegido)) {
				asientosDisponibles.remove(elegido); //Asiento deja de estar disponible
				asiento = elegido;
			}
			else
				System.out.println("Numero de asiento no disponible\n");
		}
 
		return asiento;
	}
 
	/**
	 * Pregunta si el pasajero viajará con equipaje
	 * y se asegura que se da una respuesta válida
	 * @return Verdadero o Falso que viaja con equipaje.
	 */
	private static boolean preguntarEquipaje() {
		char equipaje = ' ';
 
		while (equipaje == ' ') {
			System.out.print("Viaja con equipaje(S/N): ");
			String respuesta = pedirDato();
			char letra = respuesta.toUpperCase().charAt(0);
			if (letra != 'S' && letra != 'N')
				System.out.println("Solo responda SI o NO");
			else
				equipaje = letra;
		}
 
		if (equipaje == 'S')
			return true;
		else
			return false;
	}
 
	/**
	 * Inicializa el ArrayList de asientos disponibles
	 * numerándolos del 1 al 20
	 */
	private static void inicializarAsientos() {
		asientosDisponibles = new ArrayList<Integer>(20);
		for (int i = 1; i <= 20; i++)
			asientosDisponibles.add(i);
	}
 
}
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar