Enunciado
En un campeonato de Fórmula 1participan varios equipos, cada uno de los cuales tiene dos pilotos. Cada equipo tiene un nombre y un auto emblema. De cada piloto se conoce el nombre, el número del carro y el país de origen. Los pilotos tienen como emblema su casco.
En un campeonato se tiene una serie de carreras que se corren en diferentes pistas. De cada carrera se conoce el nombre de la carrera (por ejemplo “Gran Premio de San Marino”), el nombre de la pista (por ejemplo “Imola”), la longitud en metros de la pista, el número de vueltas que conforman la carrera y el record de vuelta actual. Adicionalmente se tiene una imagen que muestra el recorrido.
En cada carrera los resultados importantes son los de los 8 primeros lugares, que son los que dan puntos para el campeonato así:
| Posición |
Puntos |
| 1 |
10 |
| 2 |
8 |
| 3 |
6 |
| 4 |
5 |
| 5 |
4 |
| 6 |
3 |
| 7 |
2 |
| 8 |
1 |
Se requiere crear una aplicación para
1. Definir y generar un reporte con los resultados de las carreras de un campeonato de fórmula 1, que se definen por la posición de llegada de los primeros 8 pilotos.
2. Conocer cuál es el piloto que va ganando el campeonato.
La información del campeonato debe ser persistente y el proceso debe ser completamente transparente para el usuario. Esto quiere decir que el programa debe ser capaz de guardar la información en un archivo cada vez que el usuario termina la ejecución del mismo y de utilizar dicha información cuando el usuario vuelve a ejecutarlo para reconstruir el estado del modelo del mundo. El programa no debe preguntarle al usuario el nombre del archivo, sino que lo tiene que manejar todo internamente.
Interfaz
Ventana Principal
Diálogo para modificar los resultados de una carrera
/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* $Id: DialogoResultadoCarreras.java,v 1.1 2006/12/04 13:49:16 da-romer Exp $
* Universidad de los Andes (Bogota - Colombia)
* Departamento de Ingeniería de Sistemas y Computacion
* Licenciado bajo el esquema Academic Free License versión 2.1
*
* Proyecto Cupi2 (http://cupi2.uniandes.edu.co)
* Ejercicio: n8_formula1
* Autor: Mario Sánchez - 11/08/2005
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*/
package uniandes.cupi2.formula1.interfaz;
import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.Toolkit;
import java.util.ArrayList;
import javax.swing.JDialog;
import javax.swing.JOptionPane;
import uniandes.cupi2.formula1.mundo.Carrera;
/**
* Es el diálogo donde se muestran y modifican los resultados de una carrera
*/
public class DialogoResultadoCarreras extends JDialog
{
// -----------------------------------------------------------------
// Atributos
// -----------------------------------------------------------------
/**
* Es una referencia a la clase principal de la interfaz
*/
private InterfazFormula1 principal;
/**
* Es una referencia a la carrera de la cual se están modificando los resultados
*/
private Carrera carrera;
// -----------------------------------------------------------------
// Atributos de la Interfaz
// -----------------------------------------------------------------
/**
* Es el panel donde se muestran y modifican los resultados de la carrera
*/
private PanelModificacionDatosResultado panelDatos;
/**
* Es el panel con los botones para guardar los resultados
*/
private PanelBotonesResultado panelBotones;
// -----------------------------------------------------------------
// Constructores
// -----------------------------------------------------------------
/**
* Construye el dialogo
*
* @param if1 Es una referencia a la clase principal de la interfaz
* @param c Es una referencia a la carrera de la cual se van a modificar los resultados
* @param pilotos Es una lista con los pilotos del campeonato
* @param resultados Es un arreglo con los nombres de los pilotos que están registrados en los 8 primeros lugares de la carrera
*/
public DialogoResultadoCarreras( InterfazFormula1 if1, Carrera c, ArrayList pilotos, String[] resultados )
{
super( if1, true );
principal = if1;
carrera = c;
panelDatos = new PanelModificacionDatosResultado( pilotos, resultados );
panelBotones = new PanelBotonesResultado( this );
getContentPane( ).add( panelDatos, BorderLayout.CENTER );
getContentPane( ).add( panelBotones, BorderLayout.SOUTH );
setTitle( "Resultados" );
pack( );
centrarDialogo( );
}
// -----------------------------------------------------------------
// Métodos
// -----------------------------------------------------------------
/**
* Centra el diálogo en la pantalla
*/
private void centrarDialogo( )
{
Dimension dPantalla = Toolkit.getDefaultToolkit( ).getScreenSize( );
Dimension dVentana = getSize( );
int xEsquina = ( dPantalla.width / 2 ) - ( dVentana.width / 2 );
int yEsquina = ( dPantalla.height / 2 ) - ( dVentana.height / 2 );
setLocation( xEsquina, yEsquina );
}
/**
* Verifica los resultados de la carrera y los guarda si están correctos
*/
public void guardarResultados( )
{
String[] resultados = new String[8];
String[][] datos = panelDatos.darResultados( );
try
{
// Buscar la información de cada posición
for( int i = 1; i <= 8; i++ )
{
String pilotoPosicion = null;
// Buscar dentro de los datos que se tienen
for( int j = 0; j < datos.length; j++ )
{
if( datos[ j ][ 1 ].length( ) > 0 )
{
int posicion = Integer.parseInt( datos[ j ][ 1 ] );
// Se encontró un dato para la posición buscada
if( posicion == i )
{
if( pilotoPosicion != null )
throw new Exception( "La posición " + i + " se encuentra repetida" );
else
{
pilotoPosicion = datos[ j ][ 0 ];
}
}
}
}
// Revisar si se encontró al piloto de la posición buscada y pasarlo al arreglo
if( pilotoPosicion != null )
{
resultados[ i - 1 ] = pilotoPosicion;
}
}
principal.modificarResultados( carrera.darNombre( ), resultados );
dispose( );
}
catch( NumberFormatException nfe )
{
JOptionPane.showMessageDialog( this, "Solamente debe ingresar números", "Error", JOptionPane.ERROR_MESSAGE );
}
catch( Exception e )
{
JOptionPane.showMessageDialog( this, e.getMessage( ), "Error", JOptionPane.ERROR_MESSAGE );
}
}
}
|
/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* $Id: PanelBoton.java,v 1.1 2006/12/04 13:49:16 da-romer Exp $
* Universidad de los Andes (Bogota - Colombia)
* Departamento de Ingeniería de Sistemas y Computacion
* Licenciado bajo el esquema Academic Free License versión 2.1
*
* Proyecto Cupi2 (http://cupi2.uniandes.edu.co)
* Ejercicio: n8_formula1
* Autor: Mario Sánchez - 11/08/2005
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*/
package uniandes.cupi2.formula1.interfaz;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JPanel;
/**
* Es el panel donde se encuentra el botón para mostrar el diálogo de modificación de resultados de una carrera
*/
public class PanelBoton extends JPanel implements ActionListener
{
// -----------------------------------------------------------------
// Constantes
// -----------------------------------------------------------------
private static final String MODIFICAR = "Modificar";
// -----------------------------------------------------------------
// Atributos
// -----------------------------------------------------------------
/**
* Es una referencia a la clase principal de la interfaz
*/
private InterfazFormula1 principal;
// -----------------------------------------------------------------
// Atributos de la Interfaz
// -----------------------------------------------------------------
/**
* Es el botón que se usa para abrir el diálogo donde se modifican los resultados
*/
private JButton botonModificar;
// -----------------------------------------------------------------
// Constructores
// -----------------------------------------------------------------
/**
* Construye el panel con el botón para modificar los resultados
* @param if1 Es una referencia a la clase principal de la interfaz
*/
public PanelBoton( InterfazFormula1 if1 )
{
principal = if1;
botonModificar = new JButton( "Definir Resultados" );
botonModificar.setActionCommand( MODIFICAR );
botonModificar.addActionListener( this );
add( botonModificar );
}
// -----------------------------------------------------------------
// Métodos
// -----------------------------------------------------------------
/**
* Ejecuta las acciones asociadas a los eventos
* @param evento Es el evento del click sobre un botón - evento!=null
*/
public void actionPerformed( ActionEvent evento )
{
String comando = evento.getActionCommand( );
if( MODIFICAR.equals( comando ) )
{
principal.mostrarDialogoResultados( );
}
}
}
|
/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* $Id: PanelBotonesPrincipales.java,v 1.1 2006/12/04 13:49:16 da-romer Exp $
* Universidad de los Andes (Bogota - Colombia)
* Departamento de Ingeniería de Sistemas y Computacion
* Licenciado bajo el esquema Academic Free License versión 2.1
*
* Proyecto Cupi2 (http://cupi2.uniandes.edu.co)
* Ejercicio: n8_formula1
* Autor: Mario Sánchez - 11/08/2005
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*/
package uniandes.cupi2.formula1.interfaz;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JPanel;
/**
* Es el panel donde se encuentran los botones principales para controlar la aplicación
*/
public class PanelBotonesPrincipales extends JPanel implements ActionListener
{
// -----------------------------------------------------------------
// Constantes
// -----------------------------------------------------------------
private static final String GENERAR_REPORTE_RESULTADOS = "GenerarReporteResultados";
private static final String PRIMERO_CLASIFICACION = "PrimeroClasificacion";
private static final String OPCION_1 = "Opcion1";
private static final String OPCION_2 = "Opcion2";
// -----------------------------------------------------------------
// Atributos
// -----------------------------------------------------------------
/**
* Es una referencia a la clase principal de la interfaz
*/
private InterfazFormula1 principal;
// -----------------------------------------------------------------
// Atributos de la Interfaz
// -----------------------------------------------------------------
/**
* Es el botón para iniciar la operación de salvar los resultados
*/
private JButton botonSalvarResultados;
/**
* Es el botón para mostrar el primero de la clasificación
*/
private JButton botonPrimeroClasificacion;
/**
* Es el botón para ejecutar la extensión 1
*/
public JButton botonOpcion1;
/**
* Es el botón para ejecutar la extensión 1
*/
public JButton botonOpcion2;
// -----------------------------------------------------------------
// Constructores
// -----------------------------------------------------------------
/**
* Construye el panel
* @param if1 Es una referencia a la clase principal de la interfaz - if1!=null
*/
public PanelBotonesPrincipales( InterfazFormula1 if1 )
{
principal = if1;
botonSalvarResultados = new JButton( "Generar Reporte Resultados" );
botonSalvarResultados.setActionCommand( GENERAR_REPORTE_RESULTADOS );
botonSalvarResultados.addActionListener( this );
add( botonSalvarResultados );
botonPrimeroClasificacion = new JButton( "Mostrar primero del campeonato" );
botonPrimeroClasificacion.setActionCommand( PRIMERO_CLASIFICACION );
botonPrimeroClasificacion.addActionListener( this );
add( botonPrimeroClasificacion );
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
// -----------------------------------------------------------------
/**
* Ejecuta las acciones asociadas a los eventos
* @param evento Es el evento del click sobre un botón - evento!=null
*/
public void actionPerformed( ActionEvent evento )
{
String comando = evento.getActionCommand( );
if( GENERAR_REPORTE_RESULTADOS.equals( comando ) )
{
principal.generarReporteResultados( );
}
else if( PRIMERO_CLASIFICACION.equals( comando ) )
{
principal.mostrarPrimeroClasificacion( );
}
else if( OPCION_1.equals( comando ) )
{
principal.reqFuncOpcion1( );
}
else if( OPCION_2.equals( comando ) )
{
principal.reqFuncOpcion2( );
}
}
}
|
/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* $Id: PanelBotonesResultado.java,v 1.1 2006/12/04 13:49:16 da-romer Exp $
* Universidad de los Andes (Bogota - Colombia)
* Departamento de Ingeniería de Sistemas y Computacion
* Licenciado bajo el esquema Academic Free License versión 2.1
*
* Proyecto Cupi2 (http://cupi2.uniandes.edu.co)
* Ejercicio: n8_formula1
* Autor: Mario Sánchez - 11/08/2005
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*/
package uniandes.cupi2.formula1.interfaz;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JPanel;
/**
* Es el panel donde se muestran los botones para modificar los resultados de una carrera
*/
public class PanelBotonesResultado extends JPanel implements ActionListener
{
// -----------------------------------------------------------------
// Constantes
// -----------------------------------------------------------------
private static final String MODIFICAR = "Modificar";
private static final String CANCELAR = "Cancelar";
// -----------------------------------------------------------------
// Atributos
// -----------------------------------------------------------------
/**
* Es una referencia al dialogo que contiene a este panel
*/
private DialogoResultadoCarreras dialogo;
// -----------------------------------------------------------------
// Atributos de la Interfaz
// -----------------------------------------------------------------
/**
* Es el botón que sirve para guardar las modificaciones que se hicieron
*/
private JButton botonModificar;
/**
* Es el botón que sirve para cerrar el diálogo sin guardar los cambios
*/
private JButton botonCancelar;
// -----------------------------------------------------------------
// Constructores
// -----------------------------------------------------------------
/**
* Construye el panel e inicializa sus componentes
* @param drc Es una referencia al dialogo que contiene a este panel - drc!=null
*/
public PanelBotonesResultado( DialogoResultadoCarreras drc )
{
dialogo = drc;
botonModificar = new JButton( "Modificar" );
botonModificar.setActionCommand( MODIFICAR );
botonModificar.addActionListener( this );
add( botonModificar );
botonCancelar = new JButton( "Cancelar" );
botonCancelar.setActionCommand( CANCELAR );
botonCancelar.addActionListener( this );
add( botonCancelar );
}
// -----------------------------------------------------------------
// Métodos
// -----------------------------------------------------------------
/**
* Ejecuta las acciones asociadas a los eventos
* @param evento Es el evento del click sobre un botón - evento!=null
*/
public void actionPerformed( ActionEvent evento )
{
String comando = evento.getActionCommand( );
if( MODIFICAR.equals( comando ) )
{
dialogo.guardarResultados( );
}
else if( CANCELAR.equals( comando ) )
{
dialogo.dispose( );
}
}
}
|
/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* $Id: PanelCarreras.java,v 1.1 2006/12/04 13:49:16 da-romer Exp $
* Universidad de los Andes (Bogota - Colombia)
* Departamento de Ingeniería de Sistemas y Computacion
* Licenciado bajo el esquema Academic Free License versión 2.1
*
* Proyecto Cupi2 (http://cupi2.uniandes.edu.co)
* Ejercicio: n8_formula1
* Autor: Mario Sánchez - 11/08/2005
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*/
package uniandes.cupi2.formula1.interfaz;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import javax.swing.JComboBox;
import javax.swing.JPanel;
import javax.swing.border.CompoundBorder;
import javax.swing.border.EmptyBorder;
import javax.swing.border.TitledBorder;
/**
* Es el panel donde se selecciona una carrera de la cual se quiere conocer los datos
*/
public class PanelCarreras extends JPanel implements ActionListener
{
// -----------------------------------------------------------------
// Constantes
// -----------------------------------------------------------------
private static final String CAMBIAR_CARRERA = "CambiarCarrera";
// -----------------------------------------------------------------
// Atributos
// -----------------------------------------------------------------
/**
* Es una referencia a la clase principal de la interfaz
*/
private InterfazFormula1 principal;
// -----------------------------------------------------------------
// Atributos de la Interfaz
// -----------------------------------------------------------------
private JComboBox comboCarreras;
// -----------------------------------------------------------------
// Constructores
// -----------------------------------------------------------------
/**
* Construye el panel con las carreras del campeonato
* @param if1 Es una referencia a la clase principal de la interfaz
* @param carreras Una lista con las carreras que se tienen en el campeonato
*/
public PanelCarreras( InterfazFormula1 if1, ArrayList carreras )
{
principal = if1;
comboCarreras = new JComboBox( carreras.toArray( ) );
comboCarreras.setEditable( false );
comboCarreras.addActionListener( this );
comboCarreras.setActionCommand( CAMBIAR_CARRERA );
add( comboCarreras );
setBorder( new CompoundBorder( new EmptyBorder( 5, 5, 5, 5 ), new TitledBorder( "Carreras" ) ) );
}
// -----------------------------------------------------------------
// Métodos
// -----------------------------------------------------------------
/**
* Este es el método que se ejecuta cuando se cambia la carrera seleccionada en el combobox
* @param evento El evento de la selección de una carrera diferente - evento!=null
*/
public void actionPerformed( ActionEvent evento )
{
String comando = evento.getActionCommand( );
if( CAMBIAR_CARRERA.equals( comando ) )
{
String nombreCarrera = ( String )comboCarreras.getSelectedItem( );
principal.cambiarCarreraSeleccionada( nombreCarrera );
}
}
}
|
/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* $Id: PanelDatosCarreras.java,v 1.1 2006/12/04 13:49:16 da-romer Exp $
* Universidad de los Andes (Bogota - Colombia)
* Departamento de Ingeniería de Sistemas y Computacion
* Licenciado bajo el esquema Academic Free License versión 2.1
*
* Proyecto Cupi2 (http://cupi2.uniandes.edu.co)
* Ejercicio: n8_formula1
* Autor: Mario Sánchez - 11/08/2005
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*/
package uniandes.cupi2.formula1.interfaz;
import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.GridLayout;
import java.text.DecimalFormat;
import javax.swing.ImageIcon;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.border.CompoundBorder;
import javax.swing.border.EmptyBorder;
import javax.swing.border.TitledBorder;
import uniandes.cupi2.formula1.mundo.Carrera;
/**
* Es el panel donde se muestra la información de una carrera
*/
public class PanelDatosCarreras extends JPanel
{
// -----------------------------------------------------------------
// Atributos de la Interfaz
// -----------------------------------------------------------------
/**
* Es la etiqueta "Gran Premio de XXXX"
*/
private JLabel etiquetaPremio;
/**
* Es la etiqueta con el nombre de la pista
*/
private JLabel etiquetaPista;
/**
* Es la etiqueta con la longitud de la pista
*/
private JLabel etiquetaLongitud;
/**
* Es la etiqueta con el número de vueltas de la pista
*/
private JLabel etiquetaVueltas;
/**
* Es la etiqueta con el record de la pista
*/
private JLabel etiquetaRecord;
/**
* Es la etiqueta con la imagen de la pista
*/
private JLabel etiquetaImagen;
/**
* Es la etiqueta "Pista"
*/
private JLabel etiquetaTituloPista;
/**
* Es la etiqueta "Longitud"
*/
private JLabel etiquetaLongitudPista;
/**
* Es la etiqueta "Nº Vueltas"
*/
private JLabel etiquetaVueltasPista;
/**
* Es la etiqueta "Record"
*/
private JLabel etiquetaRecordPista;
// -----------------------------------------------------------------
// Constructores
// -----------------------------------------------------------------
/**
* Construye el panel sin mostrar ningún dato
*/
public PanelDatosCarreras( )
{
setLayout( new BorderLayout( ) );
etiquetaPremio = new JLabel( "Gran Premio" );
etiquetaPremio.setHorizontalAlignment( JLabel.CENTER );
Font fuente = new Font( "Tahoma", Font.BOLD, 18 );
etiquetaPremio.setFont( fuente );
add( etiquetaPremio, BorderLayout.NORTH );
etiquetaImagen = new JLabel( "" );
etiquetaImagen.setPreferredSize( new Dimension( 380, 260 ) );
add( etiquetaImagen, BorderLayout.EAST );
JPanel panelValores = new JPanel( new GridLayout( 8, 1 ) );
panelValores.setPreferredSize( new Dimension( 130, 0 ) );
etiquetaTituloPista = new JLabel( "Pista: " );
etiquetaPista = new JLabel( "" );
etiquetaPista.setFont( etiquetaPista.getFont( ).deriveFont( Font.PLAIN ) );
panelValores.add( etiquetaTituloPista );
panelValores.add( etiquetaPista );
etiquetaLongitudPista = new JLabel( "Longitud: " );
etiquetaLongitud = new JLabel( "" );
etiquetaLongitud.setFont( etiquetaLongitud.getFont( ).deriveFont( Font.PLAIN ) );
panelValores.add( etiquetaLongitudPista );
panelValores.add( etiquetaLongitud );
etiquetaVueltasPista = new JLabel( "Vueltas: " );
etiquetaVueltas = new JLabel( "" );
etiquetaVueltas.setFont( etiquetaVueltas.getFont( ).deriveFont( Font.PLAIN ) );
panelValores.add( etiquetaVueltasPista );
panelValores.add( etiquetaVueltas );
etiquetaRecordPista = new JLabel( "Record: " );
etiquetaRecord = new JLabel( "" );
etiquetaRecord.setFont( etiquetaRecord.getFont( ).deriveFont( Font.PLAIN ) );
panelValores.add( etiquetaRecordPista );
panelValores.add( etiquetaRecord );
add( panelValores, BorderLayout.CENTER );
setBorder( new CompoundBorder( new EmptyBorder( 5, 5, 5, 5 ), new TitledBorder( "-" ) ) );
}
// -----------------------------------------------------------------
// Métodos
// -----------------------------------------------------------------
/**
* Muestra en el panel la información de la carretera especificada
* @param c Es la carrera de la que se quieren mostrar los datos - c!=null
*/
public void mostrarDatosCarrera( Carrera c )
{
setBorder( new CompoundBorder( new EmptyBorder( 5, 5, 5, 5 ), new TitledBorder( c.darNombre( ) ) ) );
etiquetaImagen.setIcon( new ImageIcon( c.darImagen( ) ) );
etiquetaPista.setText( c.darNombre( ) );
etiquetaPremio.setText( c.darGranPremio( ) );
etiquetaLongitud.setText( c.darLongitud( ) );
etiquetaVueltas.setText( c.darVueltas( ) );
double record = c.darRecord( );
int segundos = ( int )record;
int minutos = segundos / 60;
DecimalFormat df = new DecimalFormat( "0.000" );
String segundos2 = df.format( record - ( 60 * minutos ) );
etiquetaRecord.setText( "" + minutos + "'" + segundos2 );
}
}
|
/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* $Id: PanelDatosEquipos.java,v 1.1 2006/12/04 13:49:16 da-romer Exp $
* Universidad de los Andes (Bogota - Colombia)
* Departamento de Ingeniería de Sistemas y Computacion
* Licenciado bajo el esquema Academic Free License versión 2.1
*
* Proyecto Cupi2 (http://cupi2.uniandes.edu.co)
* Ejercicio: n8_formula1
* Autor: Mario Sánchez - 11/08/2005
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*/
package uniandes.cupi2.formula1.interfaz;
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import javax.swing.DefaultListModel;
import javax.swing.ImageIcon;
import javax.swing.JLabel;
import javax.swing.JList;
import javax.swing.JPanel;
import javax.swing.ListSelectionModel;
import javax.swing.border.CompoundBorder;
import javax.swing.border.EmptyBorder;
import javax.swing.border.LineBorder;
import javax.swing.border.TitledBorder;
import javax.swing.event.ListSelectionEvent;
import javax.swing.event.ListSelectionListener;
import uniandes.cupi2.formula1.mundo.Equipo;
import uniandes.cupi2.formula1.mundo.Piloto;
/**
* Es el panel donde se muestran los datos del equipo y se seleccionan los pilotos
*/
public class PanelDatosEquipos extends JPanel implements ListSelectionListener
{
// -----------------------------------------------------------------
// Atributos
// -----------------------------------------------------------------
/**
* Es una referencia a la clase principal de la interfaz
*/
private InterfazFormula1 principal;
// -----------------------------------------------------------------
// Atributos de la Interfaz
// -----------------------------------------------------------------
/**
* Es la etiqueta que muestra la imagen del equipo
*/
private JLabel etiquetaImagen;
/**
* Es la lista donde se muestran los pilotos del equipo
*/
private JList listaPilotos;
// -----------------------------------------------------------------
// Constructores
// -----------------------------------------------------------------
/**
* Construye el panel donde se muestran los datos de un equipo, pero no muestra ninguna información
* @param if1 Es una referencia a la clase principal de la interfaz - itf1!=null
*/
public PanelDatosEquipos( InterfazFormula1 if1 )
{
principal = if1;
setLayout( new BorderLayout( ) );
etiquetaImagen = new JLabel( "" );
etiquetaImagen.setPreferredSize( new Dimension( 150, 100 ) );
add( etiquetaImagen, BorderLayout.WEST );
JPanel panelListaPilotos = new JPanel( new BorderLayout( ) );
panelListaPilotos.setBorder( new CompoundBorder( new EmptyBorder( 5, 5, 5, 5 ), new TitledBorder( "Pilotos" ) ) );
panelListaPilotos.setPreferredSize( new Dimension( 250, 0 ) );
listaPilotos = new JList( new Object[]{ "", "" } );
listaPilotos.setSelectionMode( ListSelectionModel.SINGLE_SELECTION );
listaPilotos.addListSelectionListener( this );
listaPilotos.setBorder( new LineBorder( Color.BLACK ) );
panelListaPilotos.add( listaPilotos );
add( panelListaPilotos, BorderLayout.CENTER );
setBorder( new CompoundBorder( new EmptyBorder( 5, 5, 5, 5 ), new TitledBorder( "-" ) ) );
}
// -----------------------------------------------------------------
// Métodos
// -----------------------------------------------------------------
/**
* Muestra la información del equipo especificado
* @param equipo Es el equipo del que se quieren mostrar los datos - equipo!=null
*/
public void mostrarInformacionEquipo( Equipo equipo )
{
setBorder( new CompoundBorder( new EmptyBorder( 5, 5, 5, 5 ), new TitledBorder( equipo.darNombre( ) ) ) );
etiquetaImagen.setIcon( new ImageIcon( equipo.darRutaImagen( ) ) );
DefaultListModel modelo = new DefaultListModel( );
modelo.addElement( equipo.darPiloto1( ) );
modelo.addElement( equipo.darPiloto2( ) );
listaPilotos.setModel( modelo );
validate( );
}
/**
* Este es el método que se llama cuando se cambia el piloto seleccionado
* @param evento El evento del cambio en el piloto seleccionado - evento!=null
*/
public void valueChanged( ListSelectionEvent evento )
{
Piloto piloto = ( Piloto )listaPilotos.getSelectedValue( );
if( piloto != null )
principal.cambiarPilotoSeleccionado( piloto.darNombre( ) );
}
}
|
/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* $Id: PanelDatosPilotos.java,v 1.1 2006/12/04 13:49:16 da-romer Exp $
* Universidad de los Andes (Bogota - Colombia)
* Departamento de Ingeniería de Sistemas y Computacion
* Licenciado bajo el esquema Academic Free License versión 2.1
*
* Proyecto Cupi2 (http://cupi2.uniandes.edu.co)
* Ejercicio: n8_formula1
* Autor: Mario Sánchez - 11/08/2005
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*/
package uniandes.cupi2.formula1.interfaz;
import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.GridLayout;
import javax.swing.ImageIcon;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.border.CompoundBorder;
import javax.swing.border.EmptyBorder;
import javax.swing.border.TitledBorder;
import uniandes.cupi2.formula1.mundo.Piloto;
/**
* Es el panel donde se muestra la información de un piloto
*/
public class PanelDatosPilotos extends JPanel
{
// -----------------------------------------------------------------
// Atributos de la Interfaz
// -----------------------------------------------------------------
/**
* Es la etiqueta que muestra el nombre del piloto
*/
private JLabel etiquetaNombre;
/**
* Es la etiqueta que muestra el número del piloto
*/
private JLabel etiquetaNumero;
/**
* Es la etiqueta que muestra el pais del piloto
*/
private JLabel etiquetaPais;
/**
* Es la etiqueta que muestra la imagen del caso del piloto
*/
private JLabel etiquetaImagen;
// -----------------------------------------------------------------
// Constructores
// -----------------------------------------------------------------
/**
* Construye el panel donde se muestran los datos de un pilot, pero no muestra ninguna información
*/
public PanelDatosPilotos( )
{
setLayout( new BorderLayout( ) );
setBorder( new CompoundBorder( new EmptyBorder( 5, 5, 5, 5 ), new TitledBorder( "Datos del piloto" ) ) );
etiquetaNombre = new JLabel( "Nombre:" );
etiquetaNumero = new JLabel( "Número:" );
etiquetaPais = new JLabel( "País:" );
JPanel panelDatos = new JPanel( new GridLayout( 3, 1 ) );
panelDatos.add( etiquetaNombre );
panelDatos.add( etiquetaNumero );
panelDatos.add( etiquetaPais );
add( panelDatos, BorderLayout.CENTER );
etiquetaImagen = new JLabel( "" );
etiquetaImagen.setPreferredSize( new Dimension( 170, 90 ) );
etiquetaImagen.setBorder( new EmptyBorder( 2, 2, 2, 2 ) );
add( etiquetaImagen, BorderLayout.EAST );
}
// -----------------------------------------------------------------
// Métodos
// -----------------------------------------------------------------
/**
* Muestra los datos del piloto especificado. <br>
* Si el piloto es null entonces no se muestra nada.
* @param piloto Es el piloto del que se quieren mostrar los datos
*/
public void mostrarDatosPiloto( Piloto piloto )
{
if( piloto != null )
{
etiquetaNombre.setText( "Nombre: " + piloto.darNombre( ) );
etiquetaNumero.setText( "Número: " + piloto.darNumero( ) );
etiquetaPais.setText( "País: " + piloto.darPais( ) );
etiquetaImagen.setIcon( new ImageIcon( piloto.darRutaCasco( ) ) );
etiquetaImagen.setText( "" );
}
else
{
etiquetaNombre.setText( "Nombre:" );
etiquetaNumero.setText( "Número:" );
etiquetaPais.setText( "País: " );
etiquetaImagen.setIcon( null );
etiquetaImagen.setText( " " );
}
validate( );
}
}
|
/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* $Id: PanelDatosResultado.java,v 1.1 2006/12/04 13:49:16 da-romer Exp $
* Universidad de los Andes (Bogota - Colombia)
* Departamento de Ingeniería de Sistemas y Computacion
* Licenciado bajo el esquema Academic Free License versión 2.1
*
* Proyecto Cupi2 (http://cupi2.uniandes.edu.co)
* Ejercicio: n8_formula1
* Autor: Mario Sánchez - 11/08/2005
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*/
package uniandes.cupi2.formula1.interfaz;
import java.awt.GridLayout;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.border.CompoundBorder;
import javax.swing.border.EmptyBorder;
import javax.swing.border.TitledBorder;
import uniandes.cupi2.formula1.mundo.Carrera;
/**
* Es el panel donde se muestran los resultados de una carrera
*/
public class PanelDatosResultado extends JPanel
{
// -----------------------------------------------------------------
// Atributos
// -----------------------------------------------------------------
/**
* Es una referencia a la carrera de la cual se deben mostrar los resultados
*/
private Carrera carrera;
// -----------------------------------------------------------------
// Atributos de la Interfaz
// -----------------------------------------------------------------
/**
* Son las etiquetas con los nombres de los pilotos
*/
private JLabel[] etiquetasPilotos;
// -----------------------------------------------------------------
// Constructores
// -----------------------------------------------------------------
/**
* Construye el panel sin mostrar ningún dato
*/
public PanelDatosResultado( )
{
etiquetasPilotos = new JLabel[8];
setLayout( new GridLayout( 4, 2 ) );
for( int i = 1; i <= 8; i++ )
{
etiquetasPilotos[ i - 1 ] = new JLabel( "" + i + "." );
add( etiquetasPilotos[ i - 1 ] );
}
setBorder( new CompoundBorder( new EmptyBorder( 5, 5, 5, 5 ), new TitledBorder( "Resultados" ) ) );
}
// -----------------------------------------------------------------
// Métodos
// -----------------------------------------------------------------
/**
* Actualiza los resultados mostrados
*/
public void actualizarResultados( )
{
String[] resultados = carrera.darResultado( );
for( int i = 0; i < 8; i++ )
{
if( resultados[ i ] != null )
{
etiquetasPilotos[ i ].setText( "" + ( i + 1 ) + ". " + resultados[ i ] );
}
else
{
etiquetasPilotos[ i ].setText( "" + ( i + 1 ) + ". " );
}
}
validate( );
}
/**
* Cambia la carrera que se muestra en el panel y actualiza los resultados mostrados
* @param c Es la carrera de la que se quieren mostrar los resultados - c!=null
*/
public void cambiarCarrera( Carrera c )
{
carrera = c;
actualizarResultados( );
}
}
|
/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* $Id: PanelEquipos.java,v 1.1 2006/12/04 13:49:16 da-romer Exp $
* Universidad de los Andes (Bogota - Colombia)
* Departamento de Ingeniería de Sistemas y Computacion
* Licenciado bajo el esquema Academic Free License versión 2.1
*
* Proyecto Cupi2 (http://cupi2.uniandes.edu.co)
* Ejercicio: n8_formula1
* Autor: Mario Sánchez - 11/08/2005
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*/
package uniandes.cupi2.formula1.interfaz;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import javax.swing.JComboBox;
import javax.swing.JPanel;
import javax.swing.border.CompoundBorder;
import javax.swing.border.EmptyBorder;
import javax.swing.border.TitledBorder;
/**
* Este es el panel donde se muestran un combo con los equipos y se seleccionan los que se quieren mostrar
*/
public class PanelEquipos extends JPanel implements ActionListener
{
// -----------------------------------------------------------------
// Constantes
// -----------------------------------------------------------------
private static final String CAMBIAR_EQUIPO = "CambiarEquipo";
// -----------------------------------------------------------------
// Atributos
// -----------------------------------------------------------------
/**
* Es una referencia a la clase principal de la interfaz
*/
private InterfazFormula1 principal;
// -----------------------------------------------------------------
// Atributos de la Interfaz
// -----------------------------------------------------------------
/**
* Es el combo donde se muestran los equipos
*/
private JComboBox comboEquipos;
// -----------------------------------------------------------------
// Constructores
// -----------------------------------------------------------------
/**
* Construye el panel y muestra la información suministrada
* @param if1 Es una referencia a la clase principal de la interfaz - if1=null
* @param equipos Es una lista con los equipos que hacen parte del campeonato - equipos!=null
*/
public PanelEquipos( InterfazFormula1 if1, ArrayList equipos )
{
principal = if1;
comboEquipos = new JComboBox( equipos.toArray( ) );
comboEquipos.setEditable( false );
comboEquipos.addActionListener( this );
comboEquipos.setActionCommand( CAMBIAR_EQUIPO );
add( comboEquipos );
setBorder( new CompoundBorder( new EmptyBorder( 5, 5, 5, 5 ), new TitledBorder( "Equipos" ) ) );
}
// -----------------------------------------------------------------
// Métodos
// -----------------------------------------------------------------
/**
* Este es el método que se ejecuta cuando se cambia el equipo seleccionado en el combobox
* @param evento El evento de la selección de un equipo diferente - evento!=null
*/
public void actionPerformed( ActionEvent evento )
{
String comando = evento.getActionCommand( );
if( CAMBIAR_EQUIPO.equals( comando ) )
{
String nombreEquipo = ( String )comboEquipos.getSelectedItem( );
principal.cambiarEquipoSeleccionado( nombreEquipo );
}
}
}
|
/**
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* $Id: PanelImagen.java,v 1.1 2006/12/04 13:49:16 da-romer Exp $
* Universidad de los Andes (Bogotá - Colombia)
* Departamento de Ingeniería de Sistemas y Computación
* Todos los derechos reservados 2005
*
* Proyecto Cupi2 (http://cupi2.uniandes.edu.co)
* Ejercicio: n8_formula1
* Autor: Daniel Romero - 17-Nov-2006
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*/
package uniandes.cupi2.formula1.interfaz;
import java.awt.Color;
import java.awt.FlowLayout;
import javax.swing.ImageIcon;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.border.LineBorder;
/**
* Es el panel donde se muestra una imagen decorativa
*/
public class PanelImagen extends JPanel
{
// -----------------------------------------------------------------
// Atributos de Interfaz
// -----------------------------------------------------------------
/**
* Imagen del titulo
*/
private JLabel imagen;
// -----------------------------------------------------------------
// Constructores
// -----------------------------------------------------------------
/**
* Constructor del panel
*/
public PanelImagen( )
{
FlowLayout layout = new FlowLayout( );
layout.setHgap( 0 );
layout.setVgap( 0 );
setLayout( layout );
//
// Carga la imagen
ImageIcon icono = new ImageIcon( "data/titulo.png" );
// La agrega a la etiqueta
imagen = new JLabel( "" );
imagen.setIcon( icono );
add( imagen );
//
// Color de fondo blanco
setBackground( Color.WHITE );
setBorder( new LineBorder( Color.GRAY ) );
}
}
|
/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* $Id: PanelModificacionDatosResultado.java,v 1.1 2006/12/04 13:49:16 da-romer Exp $
* Universidad de los Andes (Bogota - Colombia)
* Departamento de Ingeniería de Sistemas y Computacion
* Licenciado bajo el esquema Academic Free License versión 2.1
*
* Proyecto Cupi2 (http://cupi2.uniandes.edu.co)
* Ejercicio: n8_formula1
* Autor: Mario Sánchez - 11/08/2005
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*/
package uniandes.cupi2.formula1.interfaz;
import java.awt.Font;
import java.awt.GridLayout;
import java.util.ArrayList;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextField;
import uniandes.cupi2.formula1.mundo.Piloto;
/**
* Es el panel donde se muestran y se pueden modificar los resultados de una carrera
*/
public class PanelModificacionDatosResultado extends JPanel
{
// -----------------------------------------------------------------
// Atributos de la Interfaz
// -----------------------------------------------------------------
/**
* Es la etiqueta "Pilotos"
*/
private JLabel etiquetaColumnaPilotos;
/**
* Es la etiqueta "Ubicación"
*/
private JLabel etiquetaColumnaUbicacion;
/**
* Son las etiquetas con los nombres de los pilotos
*/
private JLabel[] etiquetasPilotos;
/**
* Son los campos de texto para registrar la posición de llegada de los pilotos
*/
private JTextField[] txtUbicaciones;
// -----------------------------------------------------------------
// Constructores
// -----------------------------------------------------------------
/**
* Construye el panel creando una etiqueta y un campo de texto para cada piloto. <br>
* Si un piloto ya estaba registrado dentro de los resultados, entonces en el campo de texto correspondiente aparece la posición registrada.
* @param pilotos Es una lista con los pilotos del campeonato - pilotos!=null
* @param resultados Es un arreglo con los nombres de los pilotos que están registrados en los 8 primeros lugares de la carrera - resultados!=null
*/
public PanelModificacionDatosResultado( ArrayList pilotos, String[] resultados )
{
setLayout( new GridLayout( pilotos.size( ) + 1, 2, 5, 2 ) );
etiquetaColumnaPilotos = new JLabel( "Pilotos" );
etiquetaColumnaUbicacion = new JLabel( "Ubicación" );
add( etiquetaColumnaPilotos );
add( etiquetaColumnaUbicacion );
etiquetasPilotos = new JLabel[pilotos.size( )];
txtUbicaciones = new JTextField[pilotos.size( )];
for( int i = 0; i < pilotos.size( ); i++ )
{
Piloto p = ( Piloto )pilotos.get( i );
int posicionPiloto = buscarPiloto( p.darNombre( ), resultados );
etiquetasPilotos[ i ] = new JLabel( p.darNombre( ) );
etiquetasPilotos[ i ].setFont( etiquetasPilotos[ i ].getFont( ).deriveFont( Font.PLAIN ) );
txtUbicaciones[ i ] = new JTextField( 2 );
if( posicionPiloto != -1 )
{
txtUbicaciones[ i ].setText( "" + posicionPiloto );
}
add( etiquetasPilotos[ i ] );
add( txtUbicaciones[ i ] );
}
validate( );
}
// -----------------------------------------------------------------
// Métodos
// -----------------------------------------------------------------
/**
* Sirve para buscar un piloto dentro de los resultados dado su nombre
* @param piloto El nombre del piloto buscado - piloto!=null
* @param resultados El arreglo con los resultados de una carrera - resultados!=null
* @return Retorna la posición en la que llegó el piloto. Si no se encuentra dentro del arreglo de resultados retorna -1.
*/
private int buscarPiloto( String piloto, String[] resultados )
{
int posicionPiloto = -1;
for( int i = 0; i < resultados.length && posicionPiloto == -1; i++ )
{
if( resultados[ i ] != null && resultados[ i ].equals( piloto ) )
{
posicionPiloto = i + 1;
}
}
return posicionPiloto;
}
/**
* Retorna una matriz con los resultados <br>
* La matriz es de Nx2, donde N es el número de pilotos. <br>
* En cada pareja se encuentra el nombre del piloto y el texto que fue digitado por el usuario.
* @return Los resultados de la carrera ingresados por el usuario
*/
public String[][] darResultados( )
{
int numeroPilotos = etiquetasPilotos.length;
String[][] resultados = new String[numeroPilotos][2];
for( int i = 0; i < numeroPilotos; i++ )
{
resultados[ i ][ 0 ] = etiquetasPilotos[ i ].getText( );
resultados[ i ][ 1 ] = txtUbicaciones[ i ].getText( );
}
return resultados;
}
}
|
/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* $Id: Campeonato.java,v 1.2 2007/04/12 04:53:48 carl-veg Exp $
* Universidad de los Andes (Bogota - Colombia)
* Departamento de Ingeniería de Sistemas y Computacion
* Licenciado bajo el esquema Academic Free License versión 2.1
*
* Proyecto Cupi2 (http://cupi2.uniandes.edu.co)
* Ejercicio: n8_formula1
* Autor: Mario Sánchez - 11/08/2005
* Autor: Daniel Romero - 12/03/2006
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*/
package uniandes.cupi2.formula1.mundo;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Date;
/**
* Es la clase que representa a un campeonato de fórmula 1 <br>
* <b>inv: </b>Hay una lista de equipos y carreras. <br>
* No hay dos equipos que se llamen igual. <br>
* No hay dos carreras que se llamen igual. <br>
* No hay dos pilotos que se llamen igual. <br>
* No hay dos pilotos con el mismo número. <br>
* Los pilotos que aparecen en los resultados de las carreras son parte de algún equipo del campeonato.
*/
public class Campeonato
{
// -----------------------------------------------------------------
// Constantes
// -----------------------------------------------------------------
/**
* Nombre del archivo de registro de errores del programa
*/
private static final String LOG_FILE = "./data/error.log";
// -----------------------------------------------------------------
// Atributos
// -----------------------------------------------------------------
/**
* Es la lista con los equipos que participan en el campeonato
*/
private ArrayList equipos;
/**
* Es la lista con las carreras que hacen parte del campeonato
*/
private ArrayList carreras;
/**
* Es el archivo de donde se cargan y salvan los equipos y carreras
*/
private String archivoCampeonato;
// -----------------------------------------------------------------
// Constructores
// -----------------------------------------------------------------
/**
* Construye un nuevo campeonato
* @param nombreArchivoCampeonato Es el nombre del archivo que contiene los datos del campeonato
* @throws IOException Se lanza esta excepción si se encuentran problemas cargando los datos del archivo
* @throws PersistenciaException
*/
public Campeonato( String nombreArchivoCampeonato ) throws IOException, PersistenciaException
{
archivoCampeonato = nombreArchivoCampeonato;
File archivo = new File( archivoCampeonato );
if( archivo.exists( ) )
{
// El archivo existe: se debe recuperar de allí el estado del modelo del mundo
try
{
ObjectInputStream ois = new ObjectInputStream( new FileInputStream( archivo ) );
equipos = ( ArrayList )ois.readObject( );
carreras = ( ArrayList )ois.readObject( );
ois.close( );
}
catch( Exception e )
{
// Se atrapan en este bloque todos los tipos de excepción
registrarError( e );
throw new PersistenciaException( "Error fatal: imposible restaurar el estado del programa (" + e.getMessage( ) + ")" );
}
}
else
{
// El archivo no existe: es la primera vez que se ejecuta el programa
equipos = new ArrayList( );
carreras = new ArrayList( );
}
verificarInvariante( );
}
// -----------------------------------------------------------------
// Métodos
// -----------------------------------------------------------------
/**
* Salva los resultados de todas las carreras en un archivo de texto
* @param archivo Archivo donde se van a salvar los resultados
* @throws IOException Se lanza esta excepción si hay problemas guardando los archivos
*/
public void generarReporteResultadosCarreras( File archivo ) throws IOException
{
PrintWriter out = new PrintWriter( new FileWriter( archivo ) );
out.println( "#Resultado" );
out.println( "#carrera;p1;p2;p3;p4;p5;p6;p7;p8;" );
out.println( "#Si no se tiene el dato para una posición debe aparecer \"-\"" );
for( int i = 0; i < carreras.size( ); i++ )
{
Carrera c = ( Carrera )carreras.get( i );
out.print( c.darNombre( ) + ";" );
c.guardarResultados( out );
out.println( "" );
}
out.close( );
}
/**
* Retorna una lista con los nombres de los equipos del campeonato
* @return Se retornó la lista con la lista de equipos
*/
public ArrayList darNombresEquipos( )
{
ArrayList nombresEquipos = new ArrayList( );
for( int i = 0; i < equipos.size( ); i++ )
{
Equipo e = ( Equipo )equipos.get( i );
nombresEquipos.add( e.darNombre( ) );
}
return nombresEquipos;
}
/**
* Retorna una lista con los nombres de las carreras que conforman el campeonato
* @return Se retornó una lista con los nombres de las carreras
*/
public ArrayList darNombresCarreras( )
{
ArrayList nombresCarreras = new ArrayList( );
for( int i = 0; i < carreras.size( ); i++ )
{
Carrera c = ( Carrera )carreras.get( i );
nombresCarreras.add( c.darNombre( ) );
}
return nombresCarreras;
}
/**
* Retorna una lista con los pilotos que participan en el campeonato
* @return Se retornó la lista con los nombres de los pilotos
*/
public ArrayList darNombresPilotos( )
{
ArrayList pilotos = new ArrayList( );
for( int i = 0; i < equipos.size( ); i++ )
{
Equipo e = ( Equipo )equipos.get( i );
pilotos.add( e.darPiloto1( ) );
pilotos.add( e.darPiloto2( ) );
}
return pilotos;
}
/**
* Retorna un piloto dado su nombre
* @param nombrePiloto Es el nombre del piloto que se está buscando - nombrePiloto != null
* @return Se retornó el piloto cuyo nombre es igual al nombre dado. Si no se encontró retorna null.
*/
public Piloto darPiloto( String nombrePiloto )
{
boolean encontre = false;
Piloto pilotoBuscado = null;
for( int i = 0; i < equipos.size( ) && !encontre; i++ )
{
Equipo e = ( Equipo )equipos.get( i );
Piloto piloto1 = e.darPiloto1( );
Piloto piloto2 = e.darPiloto2( );
if( piloto1.darNombre( ).equals( nombrePiloto ) )
{
encontre = true;
pilotoBuscado = piloto1;
}
else if( piloto2.darNombre( ).equals( nombrePiloto ) )
{
encontre = true;
pilotoBuscado = piloto2;
}
}
return pilotoBuscado;
}
/**
* Retorna una carrera en particular dado su nombre
* @param nombreCarrera Es el nombre de la carrera que se está buscando -nombreCarrera != null
* @return Se retornó la carrera cuyo nombre es igual al nombre dado. Si no se encontró la carrera retorna null.
*/
public Carrera darCarrera( String nombreCarrera )
{
boolean encontre = false;
Carrera carreraBuscada = null;
for( int i = 0; i < carreras.size( ) && !encontre; i++ )
{
Carrera c = ( Carrera )carreras.get( i );
if( c.darNombre( ).equals( nombreCarrera ) )
{
carreraBuscada = c;
encontre = true;
}
}
return carreraBuscada;
}
/**
* Retorna un equipo en particular dado su nombre
* @param nombreEquipo Es el nombre del equipo que se está buscando -nombreEqupi != null
* @return Se retornó el equipo cuyo nombre es igual al nombre dado. Si no se encontró el equipo retorna null.
*/
public Equipo darEquipo( String nombreEquipo )
{
boolean encontre = false;
Equipo equipoBuscado = null;
for( int i = 0; i < equipos.size( ) && !encontre; i++ )
{
Equipo e = ( Equipo )equipos.get( i );
if( e.darNombre( ).equals( nombreEquipo ) )
{
equipoBuscado = e;
encontre = true;
}
}
return equipoBuscado;
}
/**
* Modifica los resultados de una carrera <br>
* <b>post: </b>Se modificaron los resultados de la carrera
* @param nombreCarrera Es el nombre de la carrera a la cual se le van a modificar los resultados - nombreCarrera!=null
* @param resultadosCarrera Es una arreglo con 8 nombres que identifican a los pilotos que ocuparon los 8 primeros lugares en la carrera. <br>
* Si una posición es null significa que en esa posición no se clasificó nadie. - resultadosCarrera!=null
* @throws ElementoNoExisteException Se lanza esta excepción si no es posible encontrar una carrera con el nombre dado
*/
public void modificarResultadosCarrera( String nombreCarrera, String[] resultadosCarrera ) throws ElementoNoExisteException
{
Carrera c = darCarrera( nombreCarrera );
if( c == null )
{
throw new ElementoNoExisteException( nombreCarrera );
}
else
{
c.modificarResultados( resultadosCarrera );
}
verificarInvariante( );
}
/**
* Este método sirve para saber cuál es el piloto que está de primero en la clasificación
* @return Se retornó el nombre del primer piloto en la clasificación y el número de puntos: <piloto> con <puntos> puntos
*/
public String darPrimeroClasificacion( )
{
String nombrePrimero = "-";
int puntosPrimero = 0;
ArrayList pilotos = darNombresPilotos( );
for( int i = 0; i < pilotos.size( ); i++ )
{
Piloto piloto = ( Piloto )pilotos.get( i );
int puntosPiloto = darPuntos( piloto.darNombre( ) );
if( puntosPiloto > puntosPrimero )
{
nombrePrimero = piloto.darNombre( );
puntosPrimero = puntosPiloto;
}
}
return nombrePrimero + " con " + puntosPrimero + " puntos";
}
/**
* Este método sirve para saber la cantidad de puntos que ha tenido un piloto a lo largo del campeonato
* @param nombrePiloto El nombre del piloto del cual se quiere saber el número de puntos - nombrePiloto != null
* @return Se retornó el número de puntos acumulados por el piloto
*/
private int darPuntos( String nombrePiloto )
{
int numeroPuntos = 0;
for( int i = 0; i < carreras.size( ); i++ )
{
Carrera c = ( Carrera )carreras.get( i );
numeroPuntos += c.darPuntos( nombrePiloto );
}
return numeroPuntos;
}
// -----------------------------------------------------------------
// Persistencia
// -----------------------------------------------------------------
/**
* Salva el campeonato en un archivo binario
* @throws PersistenciaException Se lanza esta excepción si hay problemas guardando la información del campeonato en el archivo
*/
public void salvarCampeonato( ) throws PersistenciaException
{
try
{
ObjectOutputStream oos = new ObjectOutputStream( new FileOutputStream( archivoCampeonato ) );
oos.writeObject( equipos );
oos.writeObject( carreras );
oos.close( );
}
catch( IOException e )
{
registrarError( e );
throw new PersistenciaException( "Error al salvar: " + e.getMessage( ) );
}
}
/**
* Registra en el archivo de log del programa toda la información referente a una excepción, ocurrida durante el proceso de persistencia
* @param excepcion Es la excepción que contiene la información del error
*/
public void registrarError( Exception excepcion )
{
try
{
FileWriter out = new FileWriter( LOG_FILE, true );
PrintWriter log = new PrintWriter( out );
log.println( "---------------------------------------" );
log.println( "Campeonato.java :" + new Date( ).toString( ) );
log.println( "---------------------------------------" );
excepcion.printStackTrace( log );
log.close( );
out.close( );
}
catch( IOException e )
{
excepcion.printStackTrace( );
e.printStackTrace( );
}
}
// -----------------------------------------------------------------
// Invariante
// -----------------------------------------------------------------
/**
* Verifica el invariante de la clase <br>
* Hay una lista de equipos y carreras. <br>
* No hay dos equipos que se llamen igual. <br>
* No hay dos carreras que se llamen igual. <br>
* No hay dos pilotos que se llamen igual. <br>
* No hay dos pilotos con el mismo número. <br>
* Los pilotos que aparecen en los resultados de las carreras son parte de algún equipo del campeonato.
*/
private void verificarInvariante( )
{
assert carreras != null : "La lista de carreras es null";
assert equipos != null : "La lista de equipos es null";
assert !buscarEquiposConElMismoNombre( ) : "Hay dos equipos con el mismo nombre";
assert !buscarCarrerasConElMismoNombre( ) : "Hay dos carreras con el mismo nombre";
assert !buscarPilotosConElMismoNombreONumero( ) : "Hay dos pilotos con el mismo nombre o número";
assert !verificarPilotosResultadosFueraEquipos( ) : "Hay una carrera con un resultado registrado para un piloto que no existe en el campeonato";
}
/**
* Verifica que no haya equipos con el mismo nombre.
* @return Se retornó true si encontró dos equipos con el mismo nombre. Se retornó false en caso contrario.
*/
private boolean buscarEquiposConElMismoNombre( )
{
for( int i = 0; i < equipos.size( ); i++ )
{
Equipo e1 = ( Equipo )equipos.get( i );
for( int j = 0; j < equipos.size( ); j++ )
{
if( i != j )
{
Equipo e2 = ( Equipo )equipos.get( j );
if( e1.darNombre( ).equals( e2.darNombre( ) ) )
{
return true;
}
}
}
}
return false;
}
/**
* Verifica que no haya carreras con el mismo nombre.
* @return Se retornó true si encontró dos carreras con el mismo nombre. Se retornó false en caso contrario.
*/
private boolean buscarCarrerasConElMismoNombre( )
{
for( int i = 0; i < carreras.size( ); i++ )
{
Carrera c1 = ( Carrera )carreras.get( i );
for( int j = 0; j < carreras.size( ); j++ )
{
if( i != j )
{
Carrera c2 = ( Carrera )carreras.get( j );
if( c1.darNombre( ).equals( c2.darNombre( ) ) )
{
return true;
}
}
}
}
return false;
}
/**
* Verifica que no haya pilotos con el mismo nombre o con el mismo número.
* @return Se retornó true si encontró dos pilotos con el mismo nombre o número. Se retornó false en caso contrario.
*/
private boolean buscarPilotosConElMismoNombreONumero( )
{
ArrayList pilotos = darNombresPilotos( );
for( int i = 0; i < pilotos.size( ); i++ )
{
Piloto p1 = ( Piloto )pilotos.get( i );
for( int j = 0; j < pilotos.size( ); j++ )
{
if( i != j )
{
Piloto p2 = ( Piloto )pilotos.get( j );
if( p1.darNombre( ).equals( p2.darNombre( ) ) || p1.darNumero( ) == p2.darNumero( ) )
{
return true;
}
}
}
}
return false;
}
/**
* Verifica que todos los pilotos que aparecen en los resultados de las carreras sean parte de alguno de los equipos.
* @return Se retornó true si se encuentra que algún piloto que aparece en el resultado de alguna de las carreras no hace parte de ninguno de los equipos. <br>
* Se retornó false en caso contrario.
*/
private boolean verificarPilotosResultadosFueraEquipos( )
{
ArrayList pilotos = darNombresPilotos( );
// Revisar todas las carreras
for( int i = 0; i < carreras.size( ); i++ )
{
Carrera c1 = ( Carrera )carreras.get( i );
String[] resultados = c1.darResultado( );
// Para cada carrera se revisa cada uno de los resultados (que no sea null)
for( int j = 0; j < resultados.length; j++ )
{
if( resultados[ j ] != null )
{
String nombrePiloto = resultados[ j ];
boolean encontrePilotoEnEquipo = false;
// Para cada nombre encontrado se revisa que esté en la lista de pilotos del campeonato
for( int k = 0; k < pilotos.size( ); k++ )
{
Piloto piloto = ( Piloto )pilotos.get( k );
if( piloto.darNombre( ).equals( nombrePiloto ) )
{
encontrePilotoEnEquipo = true;
}
}
// No se encontró el nombre del resultado en la lista de pilotos: hay un error
if( !encontrePilotoEnEquipo )
{
System.out.println( nombrePiloto + "/" + c1.darNombre( ) );
return true;
}
}
}
}
return false;
}
// -----------------------------------------------------------------
// Puntos de Extensión
// -----------------------------------------------------------------
/**
* Es el punto de extensión 1
*
* @return respuesta 1
*/
public String metodo1( )
{
return "respuesta 1";
}
/**
* Es el punto de extensión 2
*
* @return respuesta 2
*/
public String metodo2( )
{
return "respuesta 2";
}
}
|
/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* $Id: Carrera.java,v 1.2 2007/02/08 13:25:42 man-muno Exp $
* Universidad de los Andes (Bogota - Colombia)
* Departamento de Ingeniería de Sistemas y Computacion
* Licenciado bajo el esquema Academic Free License versión 2.1
*
* Proyecto Cupi2 (http://cupi2.uniandes.edu.co)
* Ejercicio: n8_formula1
* Autor: Mario Sánchez - 11/08/2005
* Autor: Daniel Romero - 12/03/2006
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*/
package uniandes.cupi2.formula1.mundo;
import java.io.PrintWriter;
import java.io.Serializable;
/**
* Es la clase que representa una carrera. <br>
* <b>inv: </b> <br>
* granPremio != null <br>
* imagen != null <br>
* nombre != null <br>
* resultado != null <br>
* Debe haber 8 datos registrados en los resultados. <br>
* En los resultados no hay ningún piloto repetido.
*/
public class Carrera implements Serializable
{
// -----------------------------------------------------------------
// Constantes
// -----------------------------------------------------------------
/**
* Indicador de versión para la serialización
*/
private static final long serialVersionUID = 300L;
/**
* Representa los resultados significativos de la carrera
*/
private static final int CANTIDAD_RESULTADOS = 8;
// -----------------------------------------------------------------
// Atributos
// -----------------------------------------------------------------
/**
* Es el nombre de la pista. Ej: Hockenheim
*/
private String nombre;
/**
* El nombre del gran premio. Ej: Gran Premio de Europa
*/
private String granPremio;
/**
* Longitud en metros de la pista
*/
private int longitud;
/**
* El número de vueltas que tiene la carrera
*/
private int vueltas;
/**
* El record de vuelta en segundos
*/
private double record;
/**
* Es la ruta hasta la imagen de la pista
*/
private String imagen;
/**
* Es el arreglo con los resultados de la carrera
*/
private String[] resultado;
// -----------------------------------------------------------------
// Constructores
// -----------------------------------------------------------------
/**
* Construye una carrera con los parámetros indicados
* @param nombreC El nombre de la carrera - nombreC != null
* @param granPremioC El nombre del gran premio - granPremioC != null
* @param longitudC La longitud en metros de la pista - longitudC >0
* @param vueltasC El número de vueltas por carrera - vueltas C >0
* @param recordC El record de la pista en segundos - recordC >0
* @param imagenC La ruta a la imagen de la pista - imagenC != null
*/
public Carrera( String nombreC, String granPremioC, int longitudC, int vueltasC, double recordC, String imagenC )
{
nombre = nombreC;
granPremio = granPremioC;
longitud = longitudC;
vueltas = vueltasC;
record = recordC;
imagen = imagenC;
resultado = new String[CANTIDAD_RESULTADOS];
verificarInvariante( );
}
// -----------------------------------------------------------------
// Métodos
// -----------------------------------------------------------------
/**
* Modifica los resultados de la carrera <br>
* <b>post: </b>Se modificaron los resultados de la carrera
* @param resultadosCarrera Es una arreglo con 8 nombres que identifican a los pilotos que ocuparon los 8 primeros lugares en la carrera. <br>
* Si una posición es null significa que en esa posición no se clasificó nadie.
*/
public void modificarResultados( String[] resultadosCarrera )
{
for( int i = 0; i < CANTIDAD_RESULTADOS; i++ )
{
resultado[ i ] = resultadosCarrera[ i ];
}
verificarInvariante( );
}
/**
* Guarda los resultados de esta carrera con el escritor de archivos dado
* @param out Es el escritor del archivo en donde deben guardarse los resultados - el escritor está listo para escribir
*/
public void guardarResultados( PrintWriter out )
{
for( int i = 0; i < CANTIDAD_RESULTADOS; i++ )
{
if( resultado[ i ] != null )
out.print( resultado[ i ] + ";" );
else
out.print( "-" + ";" );
}
}
/**
* Retorna la ruta hasta la imagen de la pista
* @return Se retornó la imagen de la pista
*/
public String darImagen( )
{
return imagen;
}
/**
* Retorna la longitud de la pista
* @return Se retornó la longitud de la pista
*/
public String darLongitud( )
{
return "" + longitud + " metros";
}
/**
* Retorna el nombre de la pista
* @return Se retornó el nombre de la pista
*/
public String darNombre( )
{
return nombre;
}
/**
* Retorna el record de la pista
* @return Se retornó el record de la pista
*/
public double darRecord( )
{
return record;
}
/**
* Retorna el número de vueltas por carrera
* @return Se retornó el número de vueltas por carrera
*/
public String darVueltas( )
{
return "" + vueltas;
}
/**
* Retorna el resultado de la carrera
* @return Se retornó el resultado de la carrera
*/
public String[] darResultado( )
{
return resultado;
}
/**
* Retorna el nombre de este gran premio
* @return Se retornó el nombre del gran premio
*/
public String darGranPremio( )
{
return granPremio;
}
/**
* Este método sirve para saber la cantidad de puntos que ganó un piloto en esta carrera
* @param nombrePiloto El nombre del piloto del cual se quiere saber el número de puntos - nombrePiloto!=null
* @return Se retornó El número de puntos del piloto - Si el piloto no está en los 8 primeros retorna 0
*/
public int darPuntos( String nombrePiloto )
{
int posicion = 999;
for( int i = 0; i < resultado.length && posicion == 999; i++ )
{
if( resultado[ i ] != null && resultado[ i ].equals( nombrePiloto ) )
{
posicion = i;
}
}
return darPuntosPorPosicion( posicion + 1 );
}
/**
* Este método sirve para saber el número de puntos que gana un piloto según la posición que haya alcanzado en la carrera
* @param posicion La posición en la que quedo el piloto
* @return Se retornó el número de puntos
*/
private int darPuntosPorPosicion( int posicion )
{
int puntos = 0;
switch( posicion )
{
case 1:
puntos = 10;
break;
case 2:
puntos = 8;
break;
case 3:
puntos = 6;
break;
case 4:
puntos = 5;
break;
case 5:
puntos = 4;
break;
case 6:
puntos = 3;
break;
case 7:
puntos = 2;
break;
case 8:
puntos = 1;
break;
default:
puntos = 0;
}
return puntos;
}
// -----------------------------------------------------------------
// Invariante
// -----------------------------------------------------------------
/**
* Verifica el invariante de la clase <br>
* <b>inv:</b><br>
* granPremio != null <br>
* imagen != null <br>
* nombre != null <br>
* resultado != null <br>
* Debe haber 8 datos registrados en los resultados. <br>
* En los resultados no hay ningún piloto repetido.
*/
private void verificarInvariante( )
{
assert granPremio != null : "El nombre del Gran Premio es null";
assert imagen != null : "La imagen es null";
assert nombre != null : "El nombre de la pista es null";
assert resultado != null : "Los resultados son null";
assert resultado.length == CANTIDAD_RESULTADOS : "Debe haber 8 posiciones en los resultados";
assert !buscarPilotosRepetidos( ) : "Hay un piloto repetido en los resultados";
}
/**
* Este método sirve para revisar si hay pilotos repetidos dentro de los resultados.
* @return Se retornó true si hay un piloto que aparece repetido dentro de los resultados. Retorna false en caso contrario.
*/
private boolean buscarPilotosRepetidos( )
{
for( int i = 0; i < CANTIDAD_RESULTADOS; i++ )
{
if( resultado[ i ] != null )
{
String p1 = resultado[ i ];
for( int j = 0; j < CANTIDAD_RESULTADOS; j++ )
{
if( resultado[ j ] != null && i != j )
{
String p2 = resultado[ j ];
if( p1.equals( p2 ) )
{
return true;
}
}
}
}
}
return false;
}
}
|
/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* $Id: ElementoNoExisteException.java,v 1.1 2006/12/04 13:49:16 da-romer Exp $
* Universidad de los Andes (Bogota - Colombia)
* Departamento de Ingeniería de Sistemas y Computacion
* Licenciado bajo el esquema Academic Free License versión 2.1
*
* Proyecto Cupi2 (http://cupi2.uniandes.edu.co)
* Ejercicio: n8_formula1
* Autor: Daniel Romero - 12/03/2006
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*/
package uniandes.cupi2.formula1.mundo;
/**
* Esta excepción se lanza cuando se trata de realizar una operación sobre un elemento que no existe
*/
public class ElementoNoExisteException extends Exception
{
// -----------------------------------------------------------------
// Constructor
// -----------------------------------------------------------------
/**
* Construye la excepción con el nombre del elemento que se pasa como parámetro
* @param nombreElemento Nombre del elemento que no existe
*/
public ElementoNoExisteException( String nombreElemento )
{
super( nombreElemento );
}
}
|
/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* $Id: Equipo.java,v 1.1 2006/12/04 13:49:16 da-romer Exp $
* Universidad de los Andes (Bogota - Colombia)
* Departamento de Ingeniería de Sistemas y Computacion
* Licenciado bajo el esquema Academic Free License versión 2.1
*
* Proyecto Cupi2 (http://cupi2.uniandes.edu.co)
* Ejercicio: n8_formula1
* Autor: Mario Sánchez - 11/08/2005
* Autor: Daniel Romero - 12/03/2006
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*/
package uniandes.cupi2.formula1.mundo;
import java.io.Serializable;
/**
* Es la clase que representa a uno de los equipos del campeonato. <br>
* <b>inv: </b> <br>
* nombre != null <br>
* piloto1 != null <br>
* piloto2 != null <br>
* imagenCarro != null <br>
* Tiene exactamente dos pilotos diferentes. Todos los atributos son diferentes de null.
*/
public class Equipo implements Serializable
{
// -----------------------------------------------------------------
// Constantes
// -----------------------------------------------------------------
/**
* Indicador de versión para la serialización
*/
private static final long serialVersionUID = 200L;
// -----------------------------------------------------------------
// Atributos
// -----------------------------------------------------------------
/**
* Es el primer piloto del equipo
*/
private Piloto piloto1;
/**
* Es el segundo piloto del equipo
*/
private Piloto piloto2;
/**
* Es el nombre del equipo
*/
private String nombre;
/**
* Es la ruta hasta la imagen del carro
*/
private String imagenCarro;
// -----------------------------------------------------------------
// Constructores
// -----------------------------------------------------------------
/**
* Construye un nuevo Equipo con los datos suministrados
* @param nombreE Es el nombre del equipo - nombre != null
* @param imagenCarroE Es la ruta hasta la imagen de uno de los carros del equipo - imagenCarro != null
* @param p1 Es el primer piloto del equipo - p1 != null
* @param p2 Es el segundo piloto del equipo - p2 != null
*/
public Equipo( String nombreE, String imagenCarroE, Piloto p1, Piloto p2 )
{
nombre = nombreE;
imagenCarro = imagenCarroE;
piloto1 = p1;
piloto2 = p2;
verificarInvariante( );
}
// -----------------------------------------------------------------
// Métodos
// -----------------------------------------------------------------
/**
* Este método retorna el nombre del equipo
* @return Se retornó el nombre del equipo
*/
public String darNombre( )
{
return nombre;
}
/**
* Retorna la ruta donde se encuentra la imagen del carro
* @return Se retornó la imagen del carro
*/
public String darRutaImagen( )
{
return imagenCarro;
}
/**
* Retorna el piloto 1
* @return se retornó el piloto 1
*/
public Piloto darPiloto1( )
{
return piloto1;
}
/**
* Retorna el piloto 2
* @return Se retornó el piloto 2
*/
public Piloto darPiloto2( )
{
return piloto2;
}
// -----------------------------------------------------------------
// Invariante
// -----------------------------------------------------------------
/**
* Verifica el invariante de la clase <br>
* <b>inv: </b> <br>
* nombre != null <br>
* piloto1 != null <br>
* piloto2 != null <br>
* imagenCarro != null <br>
* Tiene exactamente dos pilotos diferentes. Todos los atributos son diferentes de null.
*/
private void verificarInvariante( )
{
assert nombre != null : "El nombre es nulo";
assert piloto1 != null : "El piloto1 es nulo";
assert piloto2 != null : "El piloto1 es nulo";
assert imagenCarro != null : "La imagen del carro es nula";
assert !piloto1.darNombre( ).equals( piloto2.darNombre( ) ) : "Los pilotos tienen el mismo nombre";
}
}
|
/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* $Id: PersistenciaException.java,v 1.1 2006/12/04 13:49:16 da-romer Exp $
* 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: n8_formula1
* Autor: Mario Sánchez - 26/01/2006
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*/
package uniandes.cupi2.formula1.mundo;
/**
* Esta excepción se lanza cuando se presenta un error al leer o escribir el archivo con la información del estado del modelo del mundo. <br>
* El mensaje asociado con la excepción debe describir el problema que se presentó.
*/
public class PersistenciaException extends Exception
{
// -----------------------------------------------------------------
// Constructor
// -----------------------------------------------------------------
/**
* Construye la excepción con el mensaje que se pasa como parámetro y que describe la causa del problema
* @param causa el mensaje que describe el problema
*/
public PersistenciaException( String causa )
{
super( causa );
}
}
|
/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* $Id: Piloto.java,v 1.2 2007/04/12 04:53:48 carl-veg Exp $
* Universidad de los Andes (Bogota - Colombia)
* Departamento de Ingeniería de Sistemas y Computacion
* Licenciado bajo el esquema Academic Free License versión 2.1
*
* Proyecto Cupi2 (http://cupi2.uniandes.edu.co)
* Ejercicio: n8_formula1
* Autor: Mario Sánchez - 11/08/2005
* Autor: Daniel Romero - 12/03/2006
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*/
package uniandes.cupi2.formula1.mundo;
import java.io.Serializable;
/**
* Es la clase que representa a un piloto que participa en el campeonato <br>
* <b>inv: </b> <br>
* nombre != null <br>
* imagenCasco != null <br>
* pais != null
*/
public class Piloto implements Serializable
{
// -----------------------------------------------------------------
// Constantes
// -----------------------------------------------------------------
/**
* Indicador de versión para la serialización
*/
private static final long serialVersionUID = 100L;
// -----------------------------------------------------------------
// Atributos
// -----------------------------------------------------------------
/**
* Es el nombre del piloto
*/
private String nombre;
/**
* Es el país de origen del piloto
*/
private String pais;
/**
* Es la ruta hasta la imagen del casco del piloto
*/
private String imagenCasco;
/**
* Es el número del carro de este piloto
*/
private int numero;
// -----------------------------------------------------------------
// Constructores
// -----------------------------------------------------------------
/**
* Construye un nuevo piloto con los datos suministrados
* @param numeroP El número del piloto - numeroP>0
* @param nombreP El nombre del piloto - nombreP != null
* @param paisP El país del piloto - paisP != null
* @param imagenCascoP La ruta hasta la imagen del casco - imagenCascoP != null
*/
public Piloto( int numeroP, String nombreP, String paisP, String imagenCascoP )
{
nombre = nombreP;
numero = numeroP;
pais = paisP;
imagenCasco = imagenCascoP;
verificarInvariante( );
}
/**
* Retorna el nombre del piloto
* @return Se retornó el nombre del piloto
*/
public String darNombre( )
{
return nombre;
}
/**
* Retorna el país del piloto
* @return Se retornó el nombre del país del piloto
*/
public String darPais( )
{
return pais;
}
/**
* Retorna el número del piloto
* @return Se retornó el numero del piloto
*/
public int darNumero( )
{
return numero;
}
/**
* Retorna la ruta hasta la imagen del casco
* @return Se retornó la ruta de la imagen del casco
*/
public String darRutaCasco( )
{
return imagenCasco;
}
/**
* Retorna el nombre como representación del piloto en String
* @return String que representa al piloto
*/
public String toString( )
{
return nombre;
}
// -----------------------------------------------------------------
// Invariante
// -----------------------------------------------------------------
/**
* Verifica el invariante de la clase <br>
* <b>inv: </b> <br>
* nombre != null <br>
* imagenCasco != null <br>
* pais != null
*/
private void verificarInvariante( )
{
assert nombre != null : "El nombre es nulo";
assert imagenCasco != null : "La imagen del casco es null";
assert pais != null : "El país es nulo";
}
}
|
Interfaz
DialogoResultadoCarreras