Enunciado
Se quiere crear un programa que tenga como objetivo el manejo de reservas de un avión. Este avión cuenta con un número fijo de 50 sillas. De ellas, 8 son de clase ejecutiva, mientras que el resto son de clase económica. Cada silla puede ser asignada a un pasajero que cuenta con un nombre y una cédula. Este último dato es la entrada principal para poder consultar una reserva o eliminarla del sistema.
Cuando se asigna una silla es necesario conocer las preferencias del usuario. Este puede elegir la posición de la silla, ventana, pasillo o centro, y la clase, ejecutiva o económica. En el caso especial de las sillas ejecutivas, solo es posible elegir las posiciones: ventana o pasillo. Las sillas son asignadas de forma secuencial según su ubicación y su clase. De igual forma, el programa permite buscar la reserva de un pasajero y visualizar los datos de la reserva.
El programa debe permitir al usuario:
1. Asignar una silla a un pasajero
2. Eliminar reserva
3. Buscar pasajero
4. Calcular el porcentaje de ocupación del avión.
/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* Universidad de los Andes (Bogotá - Colombia)
* Departamento de Ingeniería de Sistemas y Computación
* Licenciado bajo el esquema Academic Free License version 2.1
*
* Proyecto Cupi2 (http://cupi2.uniandes.edu.co)
* Ejercicio: n3_avion
* Autor: Equipo Cupi2 2017
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*/
package uniandes.cupi2.avion.interfaz;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.*;
import javax.swing.border.EmptyBorder;
import uniandes.cupi2.avion.mundo.*;
import uniandes.cupi2.avion.mundo.Silla.Clase;
import uniandes.cupi2.avion.mundo.Silla.Ubicacion;
/**
* Formulario para la asignación de sillas.
*/
@SuppressWarnings("serial")
public class DialogoAsignacion extends JDialog implements ActionListener
{
// -----------------------------------------------------------------
// Constantes
// -----------------------------------------------------------------
/**
* Opción Aceptar.
*/
public final static String ACEPTAR = "ACEPTAR";
/**
* Opción Cancelar.
*/
public final static String CANCELAR = "CANCELAR";
/**
* Opción para la clase ejecutiva.
*/
private final static String CLASE_EJECUTIVA = "Clase ejecutiva";
/**
* Opción para la clase económica.
*/
private final static String CLASE_ECONOMICA = "Clase económica";
/**
* Opción para la ubicación en ventana.
*/
private final static String UBICACION_VENTANA = "Ventana";
/**
* Opción para la ubicación en pasillo.
*/
private final static String UBICACION_PASILLO = "Pasillo";
/**
* Opción para la ubicación en el centro.
*/
private final static String UBICACION_CENTRO = "Centro";
// -----------------------------------------------------------------
// Atributos
// -----------------------------------------------------------------
/**
* Avión.
*/
private Avion avion;
// -----------------------------------------------------------------
// Atributos de interfaz
// -----------------------------------------------------------------
/**
* Interfaz principal.
*/
private InterfazAvion principal;
/**
* Panel con los botones.
*/
private JPanel panelBotones;
/**
* Panel con los datos.
*/
private JPanel panelDatos;
/**
* Botón aceptar.
*/
private JButton botonAceptar;
/**
* Botón cancelar.
*/
private JButton botonCancelar;
/**
* Combo de selección de la clase.
*/
private JComboBox cbClase;
/**
* Combo de selección de la ubicación.
*/
private JComboBox cbUbicacion;
/**
* Texto de ingreso de cédula.
*/
private JTextField txtCedula;
/**
* Texto de ingreso de cédula.
*/
private JTextField txtNombre;
// -----------------------------------------------------------------
// Constructores
// -----------------------------------------------------------------
/**
* Crea el formulario de asignación de pasajeros.
* @param pPrincipal Ventana o frame padre del diálogo. pPrincipal != null.
* @param pAvion Avión sobre el que se hará la asignación. pAvion != null.
*/
public DialogoAsignacion( InterfazAvion pPrincipal, Avion pAvion )
{
// Guarda la referencia a la ventana padre
principal = pPrincipal;
// Guarda la referencia al avión
avion = pAvion;
setTitle( "Registro de pasajero" );
setSize( 300, 230 );
setDefaultCloseOperation( JDialog.DISPOSE_ON_CLOSE );
setLayout( new BorderLayout( ) );
JPanel panelAux = new JPanel( );
panelAux.setBorder( new EmptyBorder( 10, 10, 10, 10 ) );
panelAux.setLayout( new BorderLayout( ) );
add( panelAux, BorderLayout.CENTER );
// Crea el panel de datos
inicializarPanelDatos( );
panelAux.add( panelDatos, BorderLayout.CENTER );
// Crea el panel de botones
inicializarPanelBotones( );
panelAux.add( panelBotones, BorderLayout.SOUTH );
setModal( true );
setLocationRelativeTo( principal );
setResizable( false );
}
// -----------------------------------------------------------------
// Métodos
// -----------------------------------------------------------------
/**
* Procesa el registro de un pasajero. Recoge los datos del pasajero y de la clase y ubicación en la que desea su silla y procesa su registro. <br>
* <b>post: </b> Si el pasajero no está registrado y hay silla con las características solicitadas se asigna el pasajero a una silla del avión. <br>
* Si el registro no se puede hacer correctamente, muestra un mensaje.
*/
public void registrar( )
{
Clase clase;
Ubicacion ubicacion;
String nombre;
String cedula;
Pasajero pasajero;
nombre = txtNombre.getText( );
cedula = txtCedula.getText( );
if( cedula == null || cedula.equals( "" ) )
{
JOptionPane.showMessageDialog( this, "La cédula es requerida", "Registro", JOptionPane.ERROR_MESSAGE );
}
else
{
if( nombre == null || nombre.equals( "" ) )
{
JOptionPane.showMessageDialog( this, "El nombre es requerido", "Registro", JOptionPane.ERROR_MESSAGE );
}
else
{
// Crea al pasajero
pasajero = new Pasajero( cedula, nombre );
// Verifica que no este ya el pasajero registrado
Silla silla = avion.buscarPasajero( pasajero );
if( silla != null )
{
JOptionPane.showMessageDialog( this, "El pasajero ya tiene una silla asignada", "Registro", JOptionPane.ERROR_MESSAGE );
}
else
{
// Registra al pasajero
String sClase = ( String )cbClase.getSelectedItem( );
if( sClase.equals( CLASE_EJECUTIVA ) )
{
clase = Clase.EJECUTIVA;
}
else
{
clase = Clase.ECONOMICA;
}
String sUbicacion = ( String )cbUbicacion.getSelectedItem( );
if( sUbicacion.equals( UBICACION_VENTANA ) )
{
ubicacion = Ubicacion.VENTANA;
}
else if( sUbicacion.equals( UBICACION_PASILLO ) )
{
ubicacion = Ubicacion.PASILLO;
}
else
{
ubicacion = Ubicacion.CENTRAL;
}
silla = avion.asignarSilla( clase, ubicacion, pasajero );
if( silla == null )
{
JOptionPane.showMessageDialog( this, "No hay sillas disponibles con dichas características", "Registro", JOptionPane.ERROR_MESSAGE );
}
else
{
principal.actualizar( );
dispose( );
}
}
}
}
}
/**
* Inicializa el panel con los datos del pasajero.
*/
public void inicializarPanelDatos( )
{
panelDatos = new JPanel( );
panelDatos.setLayout( new GridLayout( 4, 1, 1, 6 ) );
panelDatos.setBorder( BorderFactory.createTitledBorder( "Datos del pasajero" ) );
// Cédula
JPanel panelCedula = new JPanel( );
panelCedula.setLayout( new FlowLayout( FlowLayout.RIGHT, 5, 0 ) );
JLabel etiquetaCedula = new JLabel( "Cédula " );
txtCedula = new JTextField( );
txtCedula.setColumns( 15 );
panelCedula.add( etiquetaCedula );
panelCedula.add( txtCedula );
panelDatos.add( panelCedula );
// Nombre
JPanel panelNombre = new JPanel( );
panelNombre.setLayout( new FlowLayout( FlowLayout.RIGHT, 5, 0 ) );
JLabel etiquetaNombre = new JLabel( "Nombre " );
txtNombre = new JTextField( );
txtNombre.setColumns( 15 );
panelNombre.add( etiquetaNombre );
panelNombre.add( txtNombre );
panelDatos.add( panelNombre );
// Ubicación en el avión
JPanel pUbicacion = new JPanel( new FlowLayout( FlowLayout.RIGHT ) );
pUbicacion.setPreferredSize( new Dimension( 250, 30 ) );
JLabel lUbicacion = new JLabel( "Ubicación " );
cbUbicacion = new JComboBox( );
cbUbicacion.setAlignmentX( Component.LEFT_ALIGNMENT );
cbUbicacion.setPreferredSize( txtCedula.getPreferredSize( ) );
cbUbicacion.addActionListener( this );
pUbicacion.add( lUbicacion );
pUbicacion.add( cbUbicacion );
// Clase de silla
JPanel pClase = new JPanel( new FlowLayout( FlowLayout.RIGHT ) );
pClase.setPreferredSize( new Dimension( 250, 30 ) );
JLabel lClase = new JLabel( "Clase " );
cbClase = new JComboBox( );
cbClase.setAlignmentX( Component.LEFT_ALIGNMENT );
cbClase.addActionListener( this );
cbClase.addItem( CLASE_ECONOMICA );
cbClase.addItem( CLASE_EJECUTIVA );
cbClase.setPreferredSize( txtCedula.getPreferredSize( ) );
pClase.add( lClase );
pClase.add( cbClase );
panelDatos.add( pClase );
panelDatos.add( pUbicacion );
}
/**
* Inicializa el panel con los botones.
*/
public void inicializarPanelBotones( )
{
panelBotones = new JPanel( );
panelBotones.setLayout( new GridLayout( 1, 2, 8, 1 ) );
// Aceptar
botonAceptar = new JButton( );
botonAceptar.setText( "Aceptar" );
botonAceptar.setActionCommand( ACEPTAR );
botonAceptar.addActionListener( this );
panelBotones.add( botonAceptar );
// Cancelar
botonCancelar = new JButton( );
botonCancelar.setText( "Cancelar" );
botonCancelar.setActionCommand( CANCELAR );
botonCancelar.addActionListener( this );
panelBotones.add( botonCancelar );
}
/**
* Acciones de respuesta a los eventos de la interfaz.
* @param pEvento Evento generado por un elemento de la interfaz.
*/
public void actionPerformed( ActionEvent pEvento )
{
String comando = pEvento.getActionCommand( );
if( comando.equals( ACEPTAR ) )
{
registrar( );
}
else if( comando.equals( CANCELAR ) )
{
principal.actualizar( );
dispose( );
}
else
{
if( pEvento.getSource( ) == cbClase )
{
String sClase = ( String )cbClase.getSelectedItem( );
if( sClase.equals( CLASE_ECONOMICA ) )
{
cbUbicacion.removeAllItems( );
cbUbicacion.addItem( UBICACION_VENTANA );
cbUbicacion.addItem( UBICACION_CENTRO );
cbUbicacion.addItem( UBICACION_PASILLO );
}
else
{
cbUbicacion.removeAllItems( );
cbUbicacion.addItem( UBICACION_VENTANA );
cbUbicacion.addItem( UBICACION_PASILLO );
}
cbUbicacion.validate( );
}
}
}
}
|
/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* Universidad de los Andes (Bogotá - Colombia)
* Departamento de Ingeniería de Sistemas y Computación
* Licenciado bajo el esquema Academic Free License version 2.1
*
* Proyecto Cupi2 (http://cupi2.uniandes.edu.co)
* Ejercicio: n3_avion
* Autor: Equipo Cupi2 2017
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*/
package uniandes.cupi2.avion.interfaz;
import java.awt.*;
import javax.swing.*;
import javax.swing.border.CompoundBorder;
import javax.swing.border.EmptyBorder;
import javax.swing.border.TitledBorder;
import uniandes.cupi2.avion.mundo.*;
import uniandes.cupi2.avion.mundo.Silla.Clase;
import uniandes.cupi2.avion.mundo.Silla.Ubicacion;
/**
* Formulario para presentar los datos y el registro del pasajero.
*/
@SuppressWarnings("serial")
public class DialogoDatosPasajero extends JDialog
{
// -----------------------------------------------------------------
// Constantes
// -----------------------------------------------------------------
/**
* Opción Aceptar.
*/
public final static String ACEPTAR = "ACEPTAR";
// -----------------------------------------------------------------
// Atributos de Interfaz
// -----------------------------------------------------------------
/**
* Interfaz principal.
*/
private InterfazAvion principal;
/**
* Texto que contiene la cédula.
*/
private JTextField txtCedula;
/**
* Texto que contiene el nombre.
*/
private JTextField txtNombre;
/**
* Texto que contiene la clase.
*/
private JTextField txtClase;
/**
* Texto que contiene la ubicación.
*/
private JTextField txtUbicacion;
/**
* Texto que contiene la silla.
*/
private JTextField txtSilla;
// -----------------------------------------------------------------
// Constructores
// -----------------------------------------------------------------
/**
* Crea la ventana con los datos del pasajero.
* @param pPrincipal Ventana o frame padre del diálogo. pPrincipal != null.
* @param pSilla Silla en la que el pasajero está ubicado.
*/
public DialogoDatosPasajero( InterfazAvion pPrincipal, Silla pSilla )
{
principal = pPrincipal;
setTitle( "Datos del pasajero" );
setSize( 270, 200 );
setDefaultCloseOperation( DISPOSE_ON_CLOSE );
Pasajero pasajero = pSilla.darPasajero( );
setLayout( new BorderLayout( ) );
// Crea el panel de datos del pasajero
JPanel panelDatosPasajero = new JPanel( );
panelDatosPasajero.setBorder( new CompoundBorder( new TitledBorder( "Datos del pasajero" ), new EmptyBorder( 3, 3, 3, 3 ) ) );
panelDatosPasajero.setLayout( new GridLayout( 5, 2, 1, 1 ) );
// Cédula
JLabel etiquetaCedula = new JLabel( "Cédula: " );
panelDatosPasajero.add( etiquetaCedula );
txtCedula = new JTextField( pasajero.darCedula( ) + "" );
txtCedula.setEditable( false );
panelDatosPasajero.add( txtCedula );
// Nombre
JLabel etiquetaNombre = new JLabel( "Nombre: " );
panelDatosPasajero.add( etiquetaNombre );
txtNombre = new JTextField( pasajero.darNombre( ) );
txtNombre.setColumns( 15 );
txtNombre.setEditable( false );
panelDatosPasajero.add( txtNombre );
// Silla
JLabel etiquetaSilla = new JLabel( "Silla: " );
panelDatosPasajero.add( etiquetaSilla );
txtSilla = new JTextField( pSilla.darNumero( ) + "" );
txtSilla.setEditable( false );
panelDatosPasajero.add( txtSilla );
// Clase
JLabel etiquetaClase = new JLabel( "Clase: " );
panelDatosPasajero.add( etiquetaClase );
String sClase;
if( pSilla.darClase( ) == Clase.ECONOMICA )
{
sClase = "Económica";
}
else
{
sClase = "Ejecutiva";
}
txtClase = new JTextField( sClase );
txtClase.setEditable( false );
panelDatosPasajero.add( txtClase );
// Ubicación
JLabel etiquetaUbicacion = new JLabel( "Ubicación: " );
panelDatosPasajero.add( etiquetaUbicacion );
String sUbicacion;
if( pSilla.darUbicacion( ) == Ubicacion.CENTRAL )
{
sUbicacion = "Centro";
}
else if( pSilla.darUbicacion( ) == Ubicacion.PASILLO )
{
sUbicacion = "Pasillo";
}
else
{
sUbicacion = "Ventana";
}
txtUbicacion = new JTextField( sUbicacion );
txtUbicacion.setEditable( false );
panelDatosPasajero.add( txtUbicacion );
add( panelDatosPasajero, BorderLayout.CENTER );
setModal( true );
setLocationRelativeTo( principal );
setResizable( false );
}
// -----------------------------------------------------------------
// Métodos
// -----------------------------------------------------------------
}
|
/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* Universidad de los Andes (Bogotá - Colombia)
* Departamento de Ingeniería de Sistemas y Computación
* Licenciado bajo el esquema Academic Free License version 2.1
*
* Proyecto Cupi2 (http://cupi2.uniandes.edu.co)
* Ejercicio: n3_avion
* Autor: Equipo Cupi2 2017
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*/
package uniandes.cupi2.avion.interfaz;
import java.awt.*;
import java.text.*;
import javax.swing.*;
import uniandes.cupi2.avion.mundo.*;
/**
* Ventana principal del avión.
*/
@SuppressWarnings("serial")
public class InterfazAvion extends JFrame
{
// -----------------------------------------------------------------
// Atributos
// -----------------------------------------------------------------
/**
* Avión.
*/
private Avion avion;
// -----------------------------------------------------------------
// Atributos de interfaz
// -----------------------------------------------------------------
/**
* Panel que contiene el banner de la aplicación.
*/
private PanelImagen panelImagen;
/**
* Panel que contiene el avión.
*/
private PanelAvion panelAvion;
/**
* Panel de botones.
*/
private PanelBotonesAvion panelBotones;
/**
* Diálogo de nuevo pasajero.
*/
private DialogoAsignacion dAsignacion;
// -----------------------------------------------------------------
// Constructores
// -----------------------------------------------------------------
/**
* Crea la interfaz del avión. <br>
* <b>post: </b> Se crea el avión y se presenta en una gráfica su estado inicial.
*/
public InterfazAvion( )
{
setTitle( "El Avión" );
setSize( 580, 700 );
setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
// Crea al avión
avion = new Avion( );
// Configura la interfaz
setLayout( new BorderLayout( ) );
// Panel del banner
panelImagen = new PanelImagen( );
add( panelImagen, BorderLayout.NORTH );
// Panel del avión
panelAvion = new PanelAvion( avion );
add( panelAvion, BorderLayout.CENTER );
// Panel de botones
panelBotones = new PanelBotonesAvion( this );
add( panelBotones, BorderLayout.SOUTH );
setResizable( false );
setLocationRelativeTo( null );
}
// -----------------------------------------------------------------
// Métodos
// -----------------------------------------------------------------
/**
* Procesa el registro un pasajero.
*/
public void registrarPasajero( )
{
dAsignacion = new DialogoAsignacion( this, avion );
dAsignacion.setVisible( true );
actualizar( );
}
/**
* Procesa la anulación del registro de un pasajero.
*/
public void eliminarPasajero( )
{
// Pregunta el número de cédula
String cedula = JOptionPane.showInputDialog( this, "Ingrese el número de cédula", "Eliminar pasajero", JOptionPane.QUESTION_MESSAGE );
if( cedula != null && !cedula.isEmpty( ) )
{
Pasajero pasajero = new Pasajero( cedula, "no importa" );
if( !avion.desasignarSilla( pasajero ) )
{
JOptionPane.showMessageDialog( this, "El pasajero no tenía silla asignada", "Eliminar pasajero", JOptionPane.ERROR_MESSAGE );
}
JOptionPane.showMessageDialog( this, "Error en el número de cédula.", "Eliminar pasajero", JOptionPane.ERROR_MESSAGE );
}
actualizar( );
}
/**
* Muestra el porcentaje de ocupación que tiene el avión.
*/
public void mostrarPorcentajeOcupacion( )
{
double porcentaje;
porcentaje = avion.calcularPorcentajeOcupacion( );
DecimalFormat df = ( DecimalFormat )NumberFormat.getInstance( );
df.applyPattern( "###.##" );
JOptionPane.showMessageDialog( this, "El porcentaje de ocupación es " + df.format( porcentaje ) + "%", "Ocupación del avión", JOptionPane.INFORMATION_MESSAGE );
}
/**
* Procesa la búsqueda de un pasajero.
*/
public void buscarPasajero( )
{
// Pregunta el número de cédula
String cedula = JOptionPane.showInputDialog( this, "Ingrese el número de cédula", "Buscar pasajero", JOptionPane.QUESTION_MESSAGE );
if( cedula != null && !cedula.isEmpty( ) )
{
Pasajero pasajero = new Pasajero( cedula, "no importa" );
Silla silla = avion.buscarPasajero( pasajero );
if( silla != null )
{
DialogoDatosPasajero vDatos = new DialogoDatosPasajero( this, silla );
vDatos.setVisible( true );
}
else
{
JOptionPane.showMessageDialog( this, "El pasajero no se encuentra registrado", "Buscar pasajero", JOptionPane.INFORMATION_MESSAGE );
}
}
}
/**
* Repinta la gráfica del avión.
*/
public void actualizar( )
{
remove( panelAvion );
// Panel del avión
panelAvion = new PanelAvion( avion );
add( panelAvion, BorderLayout.CENTER );
validate( );
}
/**
* Método 1 de extensión para el ejemplo.
*/
public void reqFuncOpcion1( )
{
String respuesta = avion.metodo1( );
actualizar( );
JOptionPane.showMessageDialog( this, respuesta, "Respuesta", JOptionPane.INFORMATION_MESSAGE );
}
/**
* Método 2 de extensión para el ejemplo.
*/
public void reqFuncOpcion2( )
{
String respuesta = avion.metodo2( );
actualizar( );
JOptionPane.showMessageDialog( this, respuesta, "Respuesta", JOptionPane.INFORMATION_MESSAGE );
}
// -----------------------------------------------------------------
// Main
// -----------------------------------------------------------------
/**
* Ejecuta la aplicación.
* @param pArgs Parámetros de la ejecución. No son necesarios.
*/
public static void main( String[] pArgs )
{
try
{
// Unifica la interfaz para Mac y para Windows.
UIManager.setLookAndFeel( UIManager.getCrossPlatformLookAndFeelClassName( ) );
InterfazAvion interfaz = new InterfazAvion( );
interfaz.setVisible( true );
}
catch( Exception e )
{
e.printStackTrace( );
}
}
}
|
/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* Universidad de los Andes (Bogotá - Colombia)
* Departamento de Ingeniería de Sistemas y Computación
* Licenciado bajo el esquema Academic Free License version 2.1
*
* Proyecto Cupi2 (http://cupi2.uniandes.edu.co)
* Ejercicio: n3_avion
* Autor: Equipo Cupi2 2017
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*/
package uniandes.cupi2.avion.interfaz;
import java.awt.*;
import javax.swing.*;
import javax.swing.border.*;
import uniandes.cupi2.avion.mundo.*;
/**
* Panel para el dibujo del avión.
*/
@SuppressWarnings("serial")
public class PanelAvion extends JPanel
{
// -----------------------------------------------------------------
// Atributos
// -----------------------------------------------------------------
/**
* Avión del modelo del mundo.
*/
private Avion avion;
// -----------------------------------------------------------------
// Atributos de interfaz
// -----------------------------------------------------------------
/**
* Imagen del avión.
*/
private ImageIcon imagen;
// -----------------------------------------------------------------
// Constructores
// -----------------------------------------------------------------
/**
* Crea el panel del avión. <br>
* <b>post: <b> Se dibujan el avión y todas las sillas.
* @param pAvion Avión que se va a dibujar. pAvion != null.
*/
public PanelAvion( Avion pAvion )
{
super( new BorderLayout( ) );
avion = pAvion;
imagen = new ImageIcon( "data/imagenes/avion.png" );
setPreferredSize( new Dimension( imagen.getIconWidth( ), imagen.getIconHeight( ) ) );
setOpaque( false );
// Adiciona las imágenes de las sillas ejecutivas
JPanel panelEjecutivas = new JPanel( );
dibujarSillasEjecutivas( panelEjecutivas );
add( panelEjecutivas, BorderLayout.NORTH );
// Adiciona las imágenes de las sillas económicas
JPanel panelEconomicas = new JPanel( );
dibujarSillasEconomicas( panelEconomicas );
add( panelEconomicas, BorderLayout.CENTER );
}
// -----------------------------------------------------------------
// Métodos
// -----------------------------------------------------------------
/**
* Dibuja la gráfica del avión.
* @param pGrafica Gráficos del avión. pGrafica != null
*/
public void paint( Graphics pGrafica )
{
pGrafica.drawImage( imagen.getImage( ), 0, 0, null, null );
super.paint( pGrafica );
}
/**
* Crea las gráficas de las sillas ejecutivas del avión. <br>
* <b>pre: </b> avion != null. <br>
* <b>post: </b> Se dibujan las sillas ejecutivas del avión.
* @param pPanel Panel donde se pintan las sillas.
*/
private void dibujarSillasEjecutivas( JPanel pPanel )
{
pPanel.setLayout( new GridLayout( Avion.SILLAS_EJECUTIVAS / 4, 5, 8, 5 ) );
pPanel.setBorder( new EmptyBorder( 90, 210, 20, 210 ) );
Silla[] ejecutivas = avion.obtenerSillasEjecutivas( );
Silla silla;
for( int i = 0; i < ejecutivas.length; i++ )
{
silla = ejecutivas[ i ];
SillaGrafica sillaG = new SillaGrafica( silla );
pPanel.add( sillaG );
if( i % 4 == 1 )
{
pPanel.add( new JLabel( " " ) );
}
}
pPanel.setOpaque( false );
}
/**
* Crea las gráficas de las sillas económicas del avión. <br>
* <b>pre: </b> avion != null. <br>
* <b>post: </b> Se dibujan las sillas económicas del avión.
* @param pPanel Panel donde se pintan las sillas.
*/
private void dibujarSillasEconomicas( JPanel pPanel )
{
pPanel.setLayout( new GridLayout( Avion.SILLAS_ECONOMICAS / 6, 7, 5, 4 ) );
pPanel.setBorder( new EmptyBorder( 0, 200, 100, 200 ) );
Silla[] economicas = avion.obtenerSillasEconomicas( );
Silla silla;
for( int i = 0; i < economicas.length; i++ )
{
silla = economicas[ i ];
SillaGrafica sillaG = new SillaGrafica( silla );
pPanel.add( sillaG );
if( i % 6 == 2 )
{
pPanel.add( new JLabel( " " ) );
}
}
pPanel.setOpaque( false );
}
}
|
/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* Universidad de los Andes (Bogotá - Colombia)
* Departamento de Ingeniería de Sistemas y Computación
* Licenciado bajo el esquema Academic Free License version 2.1
*
* Proyecto Cupi2 (http://cupi2.uniandes.edu.co)
* Ejercicio: n3_avion
* Autor: Equipo Cupi2 2017
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*/
package uniandes.cupi2.avion.interfaz;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.border.*;
/**
* Panel de botones de interacción con el programa del avión.
*/
@SuppressWarnings("serial")
public class PanelBotonesAvion extends JPanel implements ActionListener
{
// -----------------------------------------------------------------
// Constantes
// -----------------------------------------------------------------
/**
* Opción registrar.
*/
public final static String REGISTRAR = "REGISTRAR_PASAJERO";
/**
* Opción anular.
*/
public final static String ANULAR = "ANULAR_PASAJERO";
/**
* Opción buscar.
*/
public final static String BUSCAR = "BUSCAR_PASAJERO";
/**
* Opción porcentaje de ocupación.
*/
public final static String PORCENTAJE = "PORCENTAJE_OCUPACION";
/**
* Opción extensión 1.
*/
private final static String OPCION_1 = "OPCION_1";
/**
* Opción extensión 2.
*/
private final static String OPCION_2 = "OPCION_2";
// -----------------------------------------------------------------
// Atributos de interfaz
// -----------------------------------------------------------------
/**
* Botón Registro de nuevo pasajero.
*/
private JButton bRegistro;
/**
* Botón Anular.
*/
private JButton bAnular;
/**
* Botón de búsqueda.
*/
private JButton bBuscarPasajero;
/**
* Botón porcentaje de ocupación.
*/
private JButton bPorcOcupacion;
/**
* Botón de extensión 1.
*/
private JButton botonOpcion1;
/**
* Botón de extensión 2.
*/
private JButton botonOpcion2;
/**
* Interfaz principal.
*/
private InterfazAvion ventana;
// -----------------------------------------------------------------
// Constructores
// -----------------------------------------------------------------
/**
* Crea el panel de botones. <br>
* <b>post: </b> Se crean y alistan los botones de la interfaz.
* @param pVentana Ventana o frame padre. pVentana != null.
*/
public PanelBotonesAvion( InterfazAvion pVentana )
{
// Guarda la referencia a la ventana padre
ventana = pVentana;
// Configura propiedades visuales
setLayout( new GridLayout( 2, 3, 8, 2 ) );
setBorder( new EmptyBorder( 5, 5, 5, 5 ) );
// Botón registrar
bRegistro = new JButton( "Registrar Pasajero" );
bRegistro.setActionCommand( REGISTRAR );
bRegistro.addActionListener( this );
bRegistro.setPreferredSize( new Dimension( 40, 10 ) );
add( bRegistro );
// Botón anular registro
bAnular = new JButton( "Eliminar Pasajero" );
bAnular.setActionCommand( ANULAR );
bAnular.addActionListener( this );
add( bAnular );
// Botón buscar pasajero
bBuscarPasajero = new JButton( "Buscar Pasajero" );
bBuscarPasajero.setActionCommand( BUSCAR );
bBuscarPasajero.addActionListener( this );
add( bBuscarPasajero );
// Botón porcentaje de ocupación
bPorcOcupacion = new JButton( "Porcentaje Ocupación" );
bPorcOcupacion.setActionCommand( PORCENTAJE );
bPorcOcupacion.addActionListener( this );
add( bPorcOcupacion );
// Botones de opciones adicionales
botonOpcion1 = new JButton( "Opción 1" );
botonOpcion1.setActionCommand( OPCION_1 );
botonOpcion1.addActionListener( this );
add( botonOpcion1 );
botonOpcion2 = new JButton( "Opción 2" );
botonOpcion2.setActionCommand( OPCION_2 );
botonOpcion2.addActionListener( this );
add( botonOpcion2 );
}
// -----------------------------------------------------------------
// Métodos
// -----------------------------------------------------------------
/**
* Acciones de respuesta a los eventos de la interfaz.
* @param pEvento Evento generado por un elemento de la interfaz.
*/
public void actionPerformed( ActionEvent pEvento )
{
String comando = pEvento.getActionCommand( );
if( comando.equals( REGISTRAR ) )
{
ventana.registrarPasajero( );
}
else if( comando.equals( ANULAR ) )
{
ventana.eliminarPasajero( );
}
else if( comando.equals( BUSCAR ) )
{
ventana.buscarPasajero( );
}
else if( comando.equals( PORCENTAJE ) )
{
ventana.mostrarPorcentajeOcupacion( );
}
else if( comando.equals( OPCION_1 ) )
{
ventana.reqFuncOpcion1( );
}
else if( comando.equals( OPCION_2 ) )
{
ventana.reqFuncOpcion2( );
}
}
}
|
/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* Universidad de los Andes (Bogotá - Colombia)
* Departamento de Ingeniería de Sistemas y Computación
* Licenciado bajo el esquema Academic Free License version 2.1
*
* Proyecto Cupi2 (http://cupi2.uniandes.edu.co)
* Ejercicio: n3_avion
* Autor: Equipo Cupi2 2017
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*/
package uniandes.cupi2.avion.interfaz;
import javax.swing.ImageIcon;
import javax.swing.JLabel;
import javax.swing.JPanel;
/**
* Panel que contiene el banner con la imagen.
*/
@SuppressWarnings("serial")
public class PanelImagen extends JPanel
{
// -----------------------------------------------------------------
// Constantes
// -----------------------------------------------------------------
/**
* Ruta de la imagen del banner.
*/
public final static String RUTA_IMAGEN = "./data/imagenes/banner.jpg";
// -----------------------------------------------------------------
// Atributos de la interfaz
// -----------------------------------------------------------------
/**
* Etiqueta de la imagen.
*/
private JLabel labImagen;
// -----------------------------------------------------------------
// Constructores
// -----------------------------------------------------------------
/**
* Construye el panel con el banner.
*/
public PanelImagen( )
{
labImagen = new JLabel( );
labImagen.setIcon( new ImageIcon( RUTA_IMAGEN ) );
add( labImagen );
}
}
|
/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* Universidad de los Andes (Bogotá - Colombia)
* Departamento de Ingeniería de Sistemas y Computación
* Licenciado bajo el esquema Academic Free License version 2.1
*
* Proyecto Cupi2 (http://cupi2.uniandes.edu.co)
* Ejercicio: n3_avion
* Autor: Equipo Cupi2 2017
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*/
package uniandes.cupi2.avion.interfaz;
import java.awt.*;
import javax.swing.*;
import uniandes.cupi2.avion.mundo.*;
import uniandes.cupi2.avion.mundo.Silla.Clase;
/**
* Representación gráfica de una silla del avión.
*/
@SuppressWarnings("serial")
public class SillaGrafica extends JPanel
{
// -----------------------------------------------------------------
// Atributos de Interfaz
// -----------------------------------------------------------------
/**
* Imagen de la silla.
*/
private ImageIcon imagen;
// -----------------------------------------------------------------
// Constructores
// -----------------------------------------------------------------
/**
* Crea la representación gráfica de la silla. <br>
* <b>post: </b> La imagen de la silla distingue si está libre u ocupada.
* @param pSilla Silla a representar. pSilla != null.
*/
public SillaGrafica( Silla pSilla )
{
super( new BorderLayout( ) );
JLabel lSilla = new JLabel( );
if( pSilla.darClase( ) == Clase.EJECUTIVA && pSilla.sillaAsignada( ) )
{
imagen = new ImageIcon( "data/imagenes/silla-ejec-asig.png" );
}
else if( pSilla.darClase( ) == Clase.EJECUTIVA && !pSilla.sillaAsignada( ) )
{
imagen = new ImageIcon( "data/imagenes/silla-ejec-libre.png" );
}
else if( pSilla.darClase( ) == Clase.ECONOMICA && pSilla.sillaAsignada( ) )
{
imagen = new ImageIcon( "data/imagenes/silla-econ-asig.png" );
}
else if( pSilla.darClase( ) == Clase.ECONOMICA && !pSilla.sillaAsignada( ) )
{
imagen = new ImageIcon( "data/imagenes/silla-econ-libre.png" );
lSilla.setForeground( Color.white );
}
setPreferredSize( new Dimension( imagen.getIconWidth( ), imagen.getIconHeight( ) ) );
setOpaque( false );
lSilla.setPreferredSize( new Dimension( imagen.getIconWidth( ), imagen.getIconHeight( ) ) );
lSilla.setText( "" + pSilla.darNumero( ) );
lSilla.setHorizontalAlignment( SwingConstants.CENTER );
lSilla.setVerticalAlignment( SwingConstants.CENTER );
add( lSilla );
}
// -----------------------------------------------------------------
// Métodos
// -----------------------------------------------------------------
/**
* Dibuja la imagen de la silla.
* @param pGrafica Gráfica de la silla.
*/
public void paint( Graphics pGrafica )
{
pGrafica.drawImage( imagen.getImage( ), 0, 0, null, null );
super.paint( pGrafica );
}
}
|
/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* Universidad de los Andes (Bogotá - Colombia)
* Departamento de Ingeniería de Sistemas y Computación
* Licenciado bajo el esquema Academic Free License version 2.1
*
* Proyecto Cupi2 (http://cupi2.uniandes.edu.co)
* Ejercicio: n3_avion
* Autor: Equipo Cupi2 2017
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*/
package uniandes.cupi2.avion.mundo;
import uniandes.cupi2.avion.mundo.Silla.Clase;
import uniandes.cupi2.avion.mundo.Silla.Ubicacion;
/**
* Avión de pasajeros.
*/
public class Avion
{
// -----------------------------------------------------------------
// Constantes
// -----------------------------------------------------------------
/**
* Número de sillas ejecutivas.
*/
public final static int SILLAS_EJECUTIVAS = 8;
/**
* Número de sillas económicas.
*/
public final static int SILLAS_ECONOMICAS = 42;
// -----------------------------------------------------------------
// Atributos
// -----------------------------------------------------------------
/**
* Sillas de la clase ejecutiva del avión.
*/
private Silla[] sillasEjecutivas;
/**
* Sillas de la clase económica del avión.
*/
private Silla[] sillasEconomicas;
// -----------------------------------------------------------------
// Constructores
// -----------------------------------------------------------------
/**
* Construye el avión. <br>
* <b>post: </b> Se inicializan las listas de sillas ejecutivas y económicas.
*/
public Avion( )
{
Ubicacion ubicacion;
// Crea las sillas ejecutivas
sillasEjecutivas = new Silla[SILLAS_EJECUTIVAS];
// Crea las sillas económicas
sillasEconomicas = new Silla[SILLAS_ECONOMICAS];
sillasEjecutivas[ 0 ] = new Silla( 1, Clase.EJECUTIVA, Ubicacion.VENTANA );
sillasEjecutivas[ 1 ] = new Silla( 2, Clase.EJECUTIVA, Ubicacion.PASILLO );
sillasEjecutivas[ 2 ] = new Silla( 3, Clase.EJECUTIVA, Ubicacion.PASILLO );
sillasEjecutivas[ 3 ] = new Silla( 4, Clase.EJECUTIVA, Ubicacion.VENTANA );
sillasEjecutivas[ 4 ] = new Silla( 5, Clase.EJECUTIVA, Ubicacion.VENTANA );
sillasEjecutivas[ 5 ] = new Silla( 6, Clase.EJECUTIVA, Ubicacion.PASILLO );
sillasEjecutivas[ 6 ] = new Silla( 7, Clase.EJECUTIVA, Ubicacion.PASILLO );
sillasEjecutivas[ 7 ] = new Silla( 8, Clase.EJECUTIVA, Ubicacion.VENTANA );
for( int numSilla = 1 + SILLAS_EJECUTIVAS, j = 1; j <= SILLAS_ECONOMICAS; numSilla++, j++ )
{
// Sillas ventana
if( j % 6 == 1 || j % 6 == 0 )
ubicacion = Ubicacion.VENTANA;
// Sillas centrales
else if( j % 6 == 2 || j % 6 == 5 )
ubicacion = Ubicacion.CENTRAL;
// Sillas pasillo
else
ubicacion = Ubicacion.PASILLO;
sillasEconomicas[ j - 1 ] = new Silla( numSilla, Clase.ECONOMICA, ubicacion );
}
}
// -----------------------------------------------------------------
// Métodos
// -----------------------------------------------------------------
/**
* Asigna la silla al pasajero en la clase y ubicación especificados. <br>
* <b>post: </b> Si existe una silla con la clase y la ubicación dada, el pasajero queda asignado en la primera de ellas según el orden numérico.
* @param pClase Clase elegida por el pasajero. Clase pertenece {Clase.EJECUTIVA, Clase.ECONOMICA}.
* @param pUbicacion Ubicación elegida por el pasajero. Si clase = Clase.ECONOMICA entonces ubicación pertenece {VENTANA, CENTRAL, PASILLO}, <br>
* o si clase = Clase.EJECUTIVA entonces ubicación pertenece {VENTANA, PASILLO}.
* @param pPasajero Pasajero a asignar. pPasajero != null y no tiene silla en el avión.
* @return Silla asignada al pasajero o null si no se pudo asignar una silla al pasajero en la ubicación y clase especificados.
*/
public Silla asignarSilla( Clase pClase, Ubicacion pUbicacion, Pasajero pPasajero )
{
// busca una silla libre
Silla silla = null;
if( pClase == Clase.EJECUTIVA )
{
silla = buscarSillaEjecutivaLibre( pUbicacion );
}
else if( pClase == Clase.ECONOMICA )
{
silla = buscarSillaEconomicaLibre( pUbicacion );
}
if( silla != null )
{
silla.asignarAPasajero( pPasajero );
}
return silla;
}
/**
* Busca la siguiente silla ejecutiva que este libre y tenga la ubicación indicada. <br>
* <b>pre: </b> La lista de sillas ejecutivas está inicializada.
* @param pUbicacion Ubicación en donde buscar la silla. pUbicación pertenece {VENTANA, PASILLO}.
* @return La silla libre encontrada. Si no encuentra una silla retorna null.
*/
public Silla buscarSillaEjecutivaLibre( Ubicacion pUbicacion )
{
boolean encontrado = false;
Silla silla = null;
for( int i = 0; i < SILLAS_EJECUTIVAS && !encontrado; i++ )
{
silla = sillasEjecutivas[ i ];
if( ! ( silla.sillaAsignada( ) ) && silla.darUbicacion( ) == pUbicacion )
{
encontrado = true;
}
}
if( !encontrado )
{
silla = null;
}
return silla;
}
/**
* Busca la siguiente silla económica que este libre y tenga la ubicación indicada. <br>
* <b>pre: </b> La lista de sillas económicas está inicializada.
* @param pUbicacion Ubicación en donde buscar la silla. pUbicación pertenece {VENTANA, CENTRAL, PASILLO}.
* @return Silla libre encontrada. Si no encuentra una silla retorna null.
*/
public Silla buscarSillaEconomicaLibre( Ubicacion pUbicacion )
{
boolean encontrado = false;
Silla silla = null;
for( int i = 0; i < SILLAS_ECONOMICAS && !encontrado; i++ )
{
silla = sillasEconomicas[ i ];
if( ! ( silla.sillaAsignada( ) ) && silla.darUbicacion( ) == pUbicacion )
{
encontrado = true;
}
}
if( !encontrado )
{
silla = null;
}
return silla;
}
/**
* Busca un pasajero en el avión.
* @param pPasajero Pasajero a buscar. pPasajero != null.
* @return Silla en la que se encontró el pasajero. Si no lo encuentra retorna null.
*/
public Silla buscarPasajero( Pasajero pPasajero )
{
// Busca el pasajero en ejecutiva
Silla silla = buscarPasajeroEjecutivo( pPasajero );
// Si no estaba en ejecutiva
if( null == silla )
{
// Busca en económica
silla = buscarPasajeroEconomico( pPasajero );
}
return silla;
}
/**
* Busca un pasajero en las sillas ejecutivas. <br>
* <b>pre: </b> La lista de sillas ejecutivas está inicializada.
* @param pPasajero Pasajero a buscar. pPasajero != null.
* @return Silla en la que se encontró el pasajero. Si no lo encuentra retorna null.
*/
public Silla buscarPasajeroEjecutivo( Pasajero pPasajero )
{
boolean encontrado = false;
Silla silla = null;
for( int i = 0; i < SILLAS_EJECUTIVAS && !encontrado; i++ )
{
silla = sillasEjecutivas[ i ];
if( silla.sillaAsignada( ) && silla.darPasajero( ).igualA( pPasajero ) )
{
encontrado = true;
}
}
if( !encontrado )
{
silla = null;
}
return silla;
}
/**
* Busca un pasajero en las sillas económicas. <br>
* <b>pre: </b> La lista de sillas económicas está inicializada.
* @param pPasajero Pasajero a buscar. pPasajero != null.
* @return Silla en la que se encontró el pasajero. Si no lo encuentra retorna null.
*/
public Silla buscarPasajeroEconomico( Pasajero pPasajero )
{
boolean encontrado = false;
Silla silla = null;
for( int i = 0; i < SILLAS_ECONOMICAS && !encontrado; i++ )
{
silla = sillasEconomicas[ i ];
if( silla.sillaAsignada( ) && silla.darPasajero( ).igualA( pPasajero ) )
{
encontrado = true;
}
}
if( !encontrado )
{
silla = null;
}
return silla;
}
/**
* Desasigna la silla de un pasajero. <br>
* <b>post: </b> Si se encuentra una silla con el pasajero, la silla quedara con su pasajero igual a null.
* @param pPasajero Pasajero a retirar. pPasajero != null.
* @return Retorna true si encontró el pasajero y des asignó la silla, false en caso contrario.
*/
public boolean desasignarSilla( Pasajero pPasajero )
{
// Busca el pasajero en el avión
Silla silla = buscarPasajero( pPasajero );
boolean resultado = false;
// Si lo encuentra desasigna
if( silla != null )
{
silla.desasignarSilla( );
resultado = true;
}
return resultado;
}
/**
* Retorna el número de sillas ejecutivas ocupadas. <br>
* <b>pre: </b> La lista de sillas ejecutivas está inicializada.
* @return Número de silla ejecutivas ocupadas.
*/
public int contarSillasEjecutivasOcupadas( )
{
int contador = 0;
for( Silla sillaEjecutiva : sillasEjecutivas )
{
if( sillaEjecutiva.sillaAsignada( ) )
{
contador++;
}
}
return contador;
}
/**
* Retorna el número de sillas económicas ocupadas. <br>
* <b>pre: </b> La lista de sillas económicas está inicializada.
* @return Número de sillas económicas ocupadas.
*/
public int contarSillasEconomicasOcupadas( )
{
int contador = 0;
for( Silla sillaEconomica : sillasEconomicas )
{
if( sillaEconomica.sillaAsignada( ) )
{
contador++;
}
}
return contador;
}
/**
* Calcula el porcentaje de ocupación del avión.
* @return Porcentaje total de ocupación.
*/
public double calcularPorcentajeOcupacion( )
{
double porcentaje;
int totalSillas = SILLAS_ECONOMICAS + SILLAS_EJECUTIVAS;
int sillasOcupadas = contarSillasEconomicasOcupadas( ) + contarSillasEjecutivasOcupadas( );
porcentaje = ( double )sillasOcupadas / totalSillas * 100;
return porcentaje;
}
/**
* Retorna las sillas ejecutivas del avión.
* @return Sillas ejecutivas del avión.
*/
public Silla[] obtenerSillasEjecutivas( )
{
return sillasEjecutivas;
}
/**
* Retorna las sillas económicas del avión.
* @return Sillas económicas del avión.
*/
public Silla[] obtenerSillasEconomicas( )
{
return sillasEconomicas;
}
/**
* Método para la extensión 1.
* @return Respuesta 1.
*/
public String metodo1( )
{
return "Respuesta 1";
}
/**
* Método para la extensión 2.
* @return Respuesta 2.
*/
public String metodo2( )
{
return "Respuesta 2";
}
}
|
/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* Universidad de los Andes (Bogotá - Colombia)
* Departamento de Ingeniería de Sistemas y Computación
* Licenciado bajo el esquema Academic Free License version 2.1
*
* Proyecto Cupi2 (http://cupi2.uniandes.edu.co)
* Ejercicio: n3_avion
* Autor: Equipo Cupi2 2017
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*/
package uniandes.cupi2.avion.mundo;
/**
* Pasajero del avión.
*/
public class Pasajero
{
// -----------------------------------------------------------------
// Atributos
// -----------------------------------------------------------------
/**
* Cédula del pasajero.
*/
private String cedula;
/**
* Nombre del pasajero.
*/
private String nombre;
// -----------------------------------------------------------------
// Constructores
// -----------------------------------------------------------------
/**
* Crea un pasajero con su cédula y nombre. <br>
* <b>post: </b> El pasajero tiene sus datos básicos cédula y nombre asignados.
* @param pCedula Cédula del pasajero. pCedula > 0.
* @param pNombre Nombre del pasajero. pNombre != null && pNombre != "".
*/
public Pasajero( String pCedula, String pNombre )
{
cedula = pCedula;
nombre = pNombre;
}
// -----------------------------------------------------------------
// Métodos
// -----------------------------------------------------------------
/**
* Retorna la cédula del pasajero.
* @return La cédula del pasajero.
*/
public String darCedula( )
{
return cedula;
}
/**
* Retorna el nombre del pasajero.
* @return El nombre del pasajero.
*/
public String darNombre( )
{
return nombre;
}
/**
* Indica si el pasajero es igual a otro.
* @param pOtroPasajero Pasajero a comparar. pOtroPasajero != null.
* @return Retorna true si es el mismo pasajero, false en caso contrario.
*/
public boolean igualA( Pasajero pOtroPasajero )
{
boolean esIgual = false;
if( cedula.equals( pOtroPasajero.darCedula( ) ) )
{
esIgual = true;
}
return esIgual;
}
}
|
/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* Universidad de los Andes (Bogotá - Colombia)
* Departamento de Ingeniería de Sistemas y Computación
* Licenciado bajo el esquema Academic Free License version 2.1
*
* Proyecto Cupi2 (http://cupi2.uniandes.edu.co)
* Ejercicio: n3_avion
* Autor: Equipo Cupi2 2017
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*/
package uniandes.cupi2.avion.mundo;
/**
* Silla del avión.
*/
public class Silla
{
// -----------------------------------------------------------------
// Enumeraciones
// -----------------------------------------------------------------
/**
* Enumeradores para las clases a las que pertenece una silla.
*/
public enum Clase {
/**
* Representa la clase ejecutiva.
*/
EJECUTIVA,
/**
* Representa la clase económica.
*/
ECONOMICA
}
/**
* Enumeradores para las ubicaciones de las sillas.
*/
public enum Ubicacion {
/**
* Representa la ubicación ventana.
*/
VENTANA,
/**
* Representa la ubicación centro.
*/
CENTRAL,
/**
* Representa la ubicación pasillo.
*/
PASILLO
}
// -----------------------------------------------------------------
// Atributos
// -----------------------------------------------------------------
/**
* Número de la silla.
*/
private int numero;
/**
* Clase de la silla.
*/
private Clase clase;
/**
* Ubicación de la silla.
*/
private Ubicacion ubicacion;
/**
* Pasajero asignado a la silla.
*/
private Pasajero pasajero;
// -----------------------------------------------------------------
// Constructores
// -----------------------------------------------------------------
/**
* Crea la silla con su número identificador. <br>
* <b>post: </b> El objeto silla tiene sus datos básicos número, clase y ubicación asignados. El pasajero no está asignado y tiene valor null.
* @param pNumero Número de silla. pNumero > 0.
* @param pClase Clase de silla. pClase pertenece {EJECUTIVA,ECONOMICA}.
* @param pUbicacion Ubicación de la silla. pUbicacion pertenece {VENTANA, CENTRAL, PASILLO}.
*/
public Silla( int pNumero, Clase pClase, Ubicacion pUbicacion )
{
numero = pNumero;
clase = pClase;
ubicacion = pUbicacion;
// Inicialmente no hay ningún pasajero en la silla
pasajero = null;
}
// -----------------------------------------------------------------
// Métodos
// -----------------------------------------------------------------
/**
* Asigna la silla al pasajero recibido como parámetro. <br>
* <b>post: </b> La silla queda asignada al pasajero recibido como parámetro.
* @param pPasajero Pasajero a asignar en la silla. pPasajero !=null.
*/
public void asignarAPasajero( Pasajero pPasajero )
{
pasajero = pPasajero;
}
/**
* Desasigna la silla al pasajero. La silla queda nuevamente libre. <br>
* <b>post: </b> La silla queda sin pasajero asignado.
*/
public void desasignarSilla( )
{
pasajero = null;
}
/**
* Indica si la silla está asignada.
* @return Retorna true si la silla esta asignada, false en caso contrario.
*/
public boolean sillaAsignada( )
{
boolean asignada = true;
if( null == pasajero )
{
asignada = false;
}
return asignada;
}
/**
* Indica si la silla está asignada al pasajero recibido como parámetro.
* @param pPasajero Pasajero a comparar con el de la silla.
* @return Retorna true si el pasajero ocupa la silla, false si la silla está vacía o no coincide con el pasajero recibido como parámetro.
*/
public boolean sillaAsignadaPasajero( Pasajero pPasajero )
{
boolean asignadaPasajero = true;
if( null == pasajero )
{
asignadaPasajero = false;
}
else if( pasajero.igualA( pPasajero ) )
{
asignadaPasajero = true;
}
return asignadaPasajero;
}
/**
* Retorna el número de la silla.
* @return Número de la silla.
*/
public int darNumero( )
{
return numero;
}
/**
* Retorna la clase de la silla.
* @return Clase de la silla.
*/
public Clase darClase( )
{
return clase;
}
/**
* Retorna la ubicación de la silla.
* @return Ubicación de la silla.
*/
public Ubicacion darUbicacion( )
{
return ubicacion;
}
/**
* Retorna el pasajero asignado a la silla.
* @return Pasajero asignado a la silla. Si no hay pasajero retorna null.
*/
public Pasajero darPasajero( )
{
return pasajero;
}
}
|
Interfaz
DialogoAsignacion