En una exposición canina se realizan desfiles de ejemplares de diferentes razas. De cada ejemplar se manejan la siguiente información: nombre (el cual debe ser único en toda la exposición), raza, edad y puntos otorgados en la exposición.
El cliente necesita una aplicación que permita manipular la información de los participantes de los desfiles caninos. Además de la información básica, se tiene también la foto de cada perro.
La aplicación debe:
1. Mostrar la lista de los perros registrados en la exposición, ordenada por raza, puntos o edad.
2. Mostrar la información de un perro específico.
3. Registrar un nuevo perro.
4. Localizar un perro por su nombre.
5. Buscar el perro ganador de la exposición (el que tiene un mayor puntaje asignado).
6. Buscar el perro con el menor puntaje.
7. Buscar el perro más viejo de todos (con mayor edad).
La información inicial de los perros se obtiene de un archivo de propiedades. Al ejecutar el programa, se carga esta información.
/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* $Id: InterfazExposicionCanina.java,v 1.10 2010/03/29 20:47:53 lr.ruiz114 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: n7_exposicionCanina
* Autor: Mario Sánchez - 26/08/2005
* Modificado por: Daniel Romero- 30/06/2006
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*/ package uniandes.cupi2.exposicionCanina.interfaz;
/**
* Es la clase principal de la interfaz
*/ public class InterfazExposicionCanina extends JFrame
{
// -----------------------------------------------------------------
// Constantes
// -----------------------------------------------------------------
/**
* La ruta del archivo con la información de los perros
*/ public static final String ARCHIVO_PERROS = "./data/perros.txt";
/**
* Es una referencia a la exposición de perros
*/ private ExposicionPerros exposicion;
// -----------------------------------------------------------------
// Atributos de la Interfaz
// -----------------------------------------------------------------
/**
* Es el panel donde se muestra la lista de perros
*/ private PanelListaPerros panelLista;
/**
* Es el panel donde se muestran los datos de un perro
*/ private PanelDatosPerro panelDatos;
/**
* Es el panel donde se introducen los datos para agregar un perro
*/ private PanelAgregarPerro panelAgregar;
/**
* Es el panel donde están los botones para los puntos de extensión
*/ private PanelExtension panelExtension;
/**
* Es el panel donde están los botones para la realización de ordenamientos y búsqueda
*/ private PanelBusquedaOrdenamientos panelBusquedaOrdenamientos;
/**
* Es el panel donde están las opciones para la realización de consultas
*/ private PanelConsultas panelConsultas;
/**
* Construye la interfaz e inicializa todos sus componentes.
* @param archivoPerros es el nombre del archivo de propiedades que contiene la información de los perros
*/ public InterfazExposicionCanina( String archivoPerros )
{
exposicion = new ExposicionPerros( );
cargarPerros( archivoPerros );
/**
* Actualiza la lista de perros mostrada.
*/ private void actualizarLista( )
{
panelLista.refrescarLista( exposicion.darPerros( ) );
}
/**
* Ordena los perros por raza y actualiza la lista.
*/ public void ordenarPorRaza( )
{
exposicion.ordenarPorRaza( );
panelDatos.limpiarDatos( );
actualizarLista( );
}
/**
* Ordena los perros por altura y actualiza la lista.
*/ public void ordenarPorPuntos( )
{
exposicion.ordenarPorPuntos( );
panelDatos.limpiarDatos( );
actualizarLista( );
}
/**
* Ordena los perros por edad y actualiza la lista.
*/ public void ordenarPorEdad( )
{
exposicion.ordenarPorEdad( );
panelDatos.limpiarDatos( );
actualizarLista( );
}
/**
* Busca un perro usando el nombre y cuando lo encuentra lo selecciona en la lista y muestra sus datos.
*/ public void buscar( )
{
String nombreBuscado = JOptionPane.showInputDialog( this, "Nombre del perro" ); if( nombreBuscado != null )
{ int posicion = exposicion.buscarPerro( nombreBuscado );
if( posicion != -1 )
{
actualizarLista( );
panelLista.seleccionar( posicion );
Perro p = ( Perro )exposicion.darPerros( ).get( posicion );
verDatos( p );
} else
{
JOptionPane.showMessageDialog( this, "No se encontró el perro" );
}
}
}
/**
* Muestra los datos de un perro en el panel correspondiente.
* @param perro es el perro del que se quieren ver los datos - perro != null
*/ public void verDatos( Perro perro )
{
panelDatos.mostrarDatos( perro );
}
/**
* Agrega un nuevo perro.
* @param nombreP es el nombre del perro - nombreP != null
* @param razaP es la raza del perro - razaP != null
* @param imagenP La ruta a la imagen del perro - imagenP != null
* @param alturaP La altura del perro - alturaP > 0
* @param edadP La edad en meses del perro - edadP > 0
*/ public void agregarPerro( String nombreP, String razaP, String imagenP, int alturaP, int edadP )
{
boolean agrego = exposicion.agregarPerro( nombreP, razaP, imagenP, alturaP, edadP ); if( !agrego )
JOptionPane.showMessageDialog( this, "No se pudo agregar el perro dado que el nombre " + nombreP + " ya lo tiene otro perro", "Error", JOptionPane.ERROR_MESSAGE ); else
{
actualizarLista( );
panelLista.seleccionar( exposicion.darPerros( ).size( ) - 1 );
}
}
/**
* Carga los perros iniciales de la exposición a partir de un archivo de propiedades.
* @param archivo nombre del archivo de propiedades que contiene la información de los perros - archivo!=null
*/ private void cargarPerros( String archivo )
{
try
{
FileInputStream fis = new FileInputStream( new File( archivo ) );
Properties propiedades = new Properties( );
propiedades.load( fis );
// Cargar los perros
String dato;
String nombre;
String raza;
String imagen; int puntos; int edad;
String aux;
dato = "total.perros";
aux = propiedades.getProperty( dato ); int cantidad = Integer.parseInt( aux );
for( int cont = 1; cont <= cantidad; cont++ )
{
// Carga un perro
dato = "perro" + cont + ".nombre";
nombre = propiedades.getProperty( dato );
dato = "perro" + cont + ".raza";
raza = propiedades.getProperty( dato );
dato = "perro" + cont + ".raza";
raza = propiedades.getProperty( dato );
dato = "perro" + cont + ".imagen";
imagen = propiedades.getProperty( dato );
dato = "perro" + cont + ".puntos";
aux = propiedades.getProperty( dato );
puntos = Integer.parseInt( aux );
dato = "perro" + cont + ".edad";
aux = propiedades.getProperty( dato );
edad = Integer.parseInt( aux );
// Sólo se carga el perro si los datos son correctos if( nombre != null && raza != null && imagen != null && puntos >= 0 && edad > 0 )
exposicion.agregarPerro( nombre, raza, imagen, puntos, edad );
fis.close( );
}
} catch( FileNotFoundException e )
{
e.printStackTrace( );
} catch( IOException e )
{
e.printStackTrace( );
}
}
/**
* Busca el perro ganador y muestra sus datos en el panel de datos.
*
*/ public void buscarGanador( )
{ int posicion = exposicion.buscarPerroMayorPuntaje( );
actualizarLista( ); if( posicion != -1 )
{
panelLista.seleccionar( posicion );
Perro p = ( Perro )exposicion.darPerros( ).get( posicion );
verDatos( p );
} else
{
JOptionPane.showMessageDialog( this, "No hay perros registrados en la exposición" );
}
}
/**
* Busca el perro con menor puntaje en la exposición y muestra sus datos en el panel de datos
*
*/ public void buscarMenorPuntaje( )
{ int posicion = exposicion.buscarPerroMenorPuntaje( );
actualizarLista( ); if( posicion != -1 )
{
panelLista.seleccionar( posicion );
Perro p = ( Perro )exposicion.darPerros( ).get( posicion );
verDatos( p );
} else
{
JOptionPane.showMessageDialog( this, "No hay perros registrados en la exposición" );
}
}
/**
* Busca el perro de mayor edad y muestra sus datos en el panel de datos
*
*/ public void buscarMayorEdad( )
{ int posicion = exposicion.buscarPerroMayorEdad( );
actualizarLista( ); if( posicion != -1 )
{
panelLista.seleccionar( posicion );
Perro p = ( Perro )exposicion.darPerros( ).get( posicion );
verDatos( p );
} else
{
JOptionPane.showMessageDialog( this, "No hay perros registrados en la exposición" );
}
}
// -----------------------------------------------------------------
// Puntos de Extensión
// -----------------------------------------------------------------
/**
* Ejecuta el punto de extensión 1
*/ public void reqFuncOpcion1( )
{
String respuesta = exposicion.metodo1( );
JOptionPane.showMessageDialog( this, respuesta, "Respuesta", JOptionPane.INFORMATION_MESSAGE );
}
/**
* Ejecuta el punto de extensión 2
*/ public void reqFuncOpcion2( )
{
String respuesta = exposicion.metodo2( );
JOptionPane.showMessageDialog( this, respuesta, "Respuesta", JOptionPane.INFORMATION_MESSAGE );
}
// -----------------------------------------------------------------
// Main
// -----------------------------------------------------------------
/**
* Ejecuta la aplicación
* @param args son los parámetros de ejecución de la aplicación. No deben usarse
*/ public static void main( String[] args )
{
InterfazExposicionCanina iec = new InterfazExposicionCanina( ARCHIVO_PERROS );
iec.setVisible( true );
}
}
/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* $Id: PanelAgregarPerro.java,v 1.6 2006/08/04 15:12:57 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: n7_exposicionCanina
* Autor: Mario Sánchez - 26/08/2005
* Modificado por: Daniel Romero- 30/06/2006
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*/
/**
* Este es el panel donde se agregan perros
*/ public class PanelAgregarPerro extends JPanel implements ActionListener
{
// -----------------------------------------------------------------
// Constantes
// -----------------------------------------------------------------
private static final String AGREGAR = "AgregarPerro";
private static final String BUSCAR = "BuscarImagen";
/**
* Es una referencia a la clase principal de la interfaz
*/ private InterfazExposicionCanina principal;
// -----------------------------------------------------------------
// Atributos de la Interfaz
// -----------------------------------------------------------------
/**
* Es el campo para la ruta hasta la imagen del perro
*/ private JTextField txtImagen;
/**
* Es el campo para el nombre del perro
*/ private JTextField txtNombre;
/**
* Es el campo para la raza del perro
*/ private JTextField txtRaza;
/**
* Es el campo para la edad del perro
*/ private JTextField txtEdad;
/**
* Es el campo para los puntos del perro
*/ private JTextField txtPuntos;
/**
* Es la etiqueta para la imagen del perro
*/ private JLabel etiquetaImagen;
/**
* Es la etiqueta para el nombre del perro
*/ private JLabel etiquetaNombre;
/**
* Es la etiqueta para la raza del perro
*/ private JLabel etiquetaRaza;
/**
* Es la etiqueta para los puntos del perro
*/ private JLabel etiquetaPuntos;
/**
* Es la etiqueta para la edad del perro
*/ private JLabel etiquetaEdad;
/**
* Es el botón que se usa para agregar un perro
*/ private JButton botonAgregar;
/**
* Es el botón que se usa para examinar el disco buscando la imagen del perro
*/ private JButton botonExaminar;
/**
* Construye el panel e inicializa sus componentes.
* @param iec es una referencia a la clase principal de la interfaz
*/ public PanelAgregarPerro( InterfazExposicionCanina iec )
{
principal = iec;
setLayout( new GridBagLayout( ) );
setBorder( new CompoundBorder( new EmptyBorder( 4, 3, 3, 3 ), new TitledBorder( "Agregar Perro" ) ) );
JPanel panelDatos = new JPanel( new GridBagLayout( ) );
// Nombre
etiquetaNombre = new JLabel( "Nombre: " );
GridBagConstraints gbc = new GridBagConstraints( );
gbc.gridx = 0;
gbc.gridy = 0;
panelDatos.add( etiquetaNombre, gbc );
txtNombre = new JTextField( "" );
gbc = new GridBagConstraints( );
gbc.gridx = 1;
gbc.gridy = 0;
gbc.fill = GridBagConstraints.BOTH;
gbc.gridwidth = 1;
/**
* Este es el método que se ejecuta cuando se hace click sobre un botón.
* @param evento es el evento del click sobre el botón
*/ public void actionPerformed( ActionEvent evento )
{
String comando = evento.getActionCommand( );
if( AGREGAR.equals( comando ) )
{ try
{
String nombre = txtNombre.getText( );
String raza = txtRaza.getText( );
String imagen = txtImagen.getText( ); int puntos = Integer.parseInt( txtPuntos.getText( ) ); int edad = Integer.parseInt( txtEdad.getText( ) );
if( nombre == null || nombre.equals( "" ) )
{
JOptionPane.showMessageDialog( this, "Debe ingresar el nombre del perro", "Error", JOptionPane.ERROR_MESSAGE );
} else if( raza == null || raza.equals( "" ) )
{
JOptionPane.showMessageDialog( this, "Debe ingresar la raza del perro", "Error", JOptionPane.ERROR_MESSAGE );
} else if( imagen == null || imagen.equals( "" ) )
{
JOptionPane.showMessageDialog( this, "Debe ingresar la imagen del perro", "Error", JOptionPane.ERROR_MESSAGE );
} else
{
principal.agregarPerro( nombre, raza, imagen, puntos, edad );
txtNombre.setText( "" );
txtRaza.setText( "" );
txtImagen.setText( "" );
txtPuntos.setText( "" );
txtEdad.setText( "" );
}
} catch( NumberFormatException e )
{
JOptionPane.showMessageDialog( this, "Los campos de puntos y edad deben ser números", "Error", JOptionPane.ERROR_MESSAGE );
}
} else if( BUSCAR.equals( comando ) )
{
JFileChooser fc = new JFileChooser( "./data" );
fc.setDialogTitle( "Buscar imagen de perro" );
fc.setMultiSelectionEnabled( false );
/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* $Id: PanelBusquedaOrdenamientos.java,v 1.4 2006/08/04 15:12:57 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: n7_exposicionCanina
* Autor: Daniel Romero- 30/06/2006
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*/ package uniandes.cupi2.exposicionCanina.interfaz;
/**
* Este es el panel donde se encuentran los botones para realizar los ordenamientos por distintos criterios y las búsquedas.
*/ public class PanelBusquedaOrdenamientos extends JPanel implements ActionListener
{
// -----------------------------------------------------------------
// Constantes
// -----------------------------------------------------------------
private static final String BUSCAR = "Buscar";
private static final String ORDENAR_PUNTOS = "OrdenarPuntos";
private static final String ORDENAR_EDAD = "OrdenarEdad";
private static final String ORDENAR_RAZA = "OrdenarRaza";
/**
* Es una referencia a la clase principal de la interfaz
*/ private InterfazExposicionCanina principal;
// -----------------------------------------------------------------
// Atributos de la Interfaz
// -----------------------------------------------------------------
/**
* Es el botón para ordenar la lista de perros por raza
*/ private JButton botonOrdenarRaza;
/**
* Es el botón para ordenar la lista de perros por puntos
*/ private JButton botonOrdenarPuntos;
/**
* Es el botón para ordenar la lista de perros por edad
*/ private JButton botonOrdenarEdad;
/**
* Es el botón para realizar una búsqueda
*/ private JButton botonBuscar;
/**
* Construye el panel e inicializa todos sus componentes.
* @param ventanaPrincipal es una referencia a la clase principal de la interfaz - ventanaPrincipal != null
*/ public PanelBusquedaOrdenamientos( InterfazExposicionCanina ventanaPrincipal )
{
principal = ventanaPrincipal;
setPreferredSize( new Dimension( 200, 0 ) );
setBorder( new CompoundBorder( new EmptyBorder( 4, 3, 3, 3 ), new TitledBorder( "Búsqueda y ordenamientos" ) ) );
setLayout( new GridBagLayout( ) );
botonOrdenarRaza = new JButton( "Ordenar por Raza" );
GridBagConstraints gbc = new GridBagConstraints( );
gbc.gridx = 0;
gbc.gridy = 0;
gbc.insets = new Insets( 0, 0, 10, 0 );
gbc.fill = GridBagConstraints.BOTH;
botonOrdenarRaza.setActionCommand( ORDENAR_RAZA );
botonOrdenarRaza.addActionListener( this );
add( botonOrdenarRaza, gbc );
botonOrdenarPuntos = new JButton( "Ordenar por Puntos" );
botonOrdenarPuntos.setActionCommand( ORDENAR_PUNTOS );
botonOrdenarPuntos.addActionListener( this );
gbc = new GridBagConstraints( );
gbc.gridx = 0;
gbc.gridy = 1;
gbc.insets = new Insets( 0, 0, 10, 0 );
gbc.fill = GridBagConstraints.BOTH;
add( botonOrdenarPuntos, gbc );
botonOrdenarEdad = new JButton( "Ordenar por Edad" );
botonOrdenarEdad.setActionCommand( ORDENAR_EDAD );
botonOrdenarEdad.addActionListener( this );
gbc = new GridBagConstraints( );
gbc.gridx = 0;
gbc.gridy = 2;
gbc.insets = new Insets( 0, 0, 10, 0 );
gbc.fill = GridBagConstraints.BOTH;
add( botonOrdenarEdad, gbc );
/**
* Ejecuta una acción según el botón que se haya presionado.
* @param evento es el evento de click sobre un botón
*/ public void actionPerformed( ActionEvent evento )
{
String comando = evento.getActionCommand( );
/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* $Id: PanelConsultas.java,v 1.4 2006/08/04 15:12:57 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: n7_exposicionCanina
* Autor: Daniel Romero- 30/06/2006
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*/ package uniandes.cupi2.exposicionCanina.interfaz;
/**
* Este es el panel donde se encuentran los botones para hacer consulta sobre la exposición
*
*/ public class PanelConsultas extends JPanel implements ActionListener
{
// -----------------------------------------------------------------
// Constantes
// -----------------------------------------------------------------
private static final String GANADOR = "Ganador";
private static final String MENOS_PUNTOS = "Menos puntos";
private static final String MAYOR_EDAD = "Mayor edad";
/**
* Es una referencia a la clase principal de la interfaz
*/ private InterfazExposicionCanina principal;
// -----------------------------------------------------------------
// Atributos de la Interfaz
// -----------------------------------------------------------------
/**
* Es el botón para mostrar el nombre del perro ganador
*/ private JButton botonGanador;
/**
* Es el botón para mostrar el perro con menos puntos
*/ private JButton botonMenosPuntos;
/**
* Es el botón para mostrar el nombre del perro con mayor edad
*/ private JButton botonMayorEdad;
// -----------------------------------------------------------------
// Constructores
// -----------------------------------------------------------------
/**
* Construye el panel e inicializa sus componentes.
* @param ventanaPrincipal es una referencia a la clase principal de la interfaz - ventanaPrincipal != null
*/ public PanelConsultas( InterfazExposicionCanina ventanaPrincipal )
{
principal = ventanaPrincipal;
setLayout( new GridLayout( 4, 1, 10, 10 ) );
setBorder( new CompoundBorder( new EmptyBorder( 4, 3, 3, 3 ), new TitledBorder( "Consultas Exposición" ) ) );
// Ganador
botonGanador = new JButton( "Ganador" );
botonGanador.addActionListener( this );
botonGanador.setActionCommand( GANADOR );
add( botonGanador );
// Menos puntos
botonMenosPuntos = new JButton( "Menor Puntaje" );
botonMenosPuntos.addActionListener( this );
botonMenosPuntos.setActionCommand( MENOS_PUNTOS );
add( botonMenosPuntos );
// Mayos edad
botonMayorEdad = new JButton( "Más Viejo" );
botonMayorEdad.addActionListener( this );
botonMayorEdad.setActionCommand( MAYOR_EDAD );
add( botonMayorEdad );
}
/**
* Ejecuta una acción según el botón que se haya presionado.
* @param evento es el evento de click sobre un botón
*/ public void actionPerformed( ActionEvent evento )
{
String comando = evento.getActionCommand( );
/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* $Id: PanelDatosPerro.java,v 1.4 2006/11/23 00:10:37 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
*
* Las imágenes de los perros fueron tomadas de:
* http://www.mascotanet.com
*
* Proyecto Cupi2 (http://cupi2.uniandes.edu.co)
* Ejercicio: n7_exposicionCanina
* Autor: Mario Sánchez - 26/08/2005
* Modificado por: Daniel Romero- 30/06/2006
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*/ package uniandes.cupi2.exposicionCanina.interfaz;
/**
* Es el panel donde se muestran los datos de un perro
*/ public class PanelDatosPerro extends JPanel
{
// -----------------------------------------------------------------
// Constantes
// -----------------------------------------------------------------
/**
* Esta constante indica la altura que debe tener la imagen de un individuo
*/ private static final int ALTURA = 200;
/**
* Esta constante indica el ancho que debe tener la imagen de un individuo
*/ private static final int ANCHO = 200;
// -----------------------------------------------------------------
// Atributos de la Interfaz
// -----------------------------------------------------------------
/**
* Es la etiqueta donde se muestra la imagen del perro
*/ private JLabel etiquetaImagen;
/**
* Es la etiqueta para el nombre del perro
*/ private JLabel etiquetaNombre;
/**
* Es la etiqueta para la raza del perro
*/ private JLabel etiquetaRaza;
/**
* Es la etiqueta donde se muestra los puntos del perro
*/ private JLabel etiquetaPuntos;
/**
* Es la etiqueeta para la edad del perro
*/ private JLabel etiquetaEdad;
/**
* Es el campo para el nombre del perro
*/ private JTextField txtNombre;
/**
* Es el campo para la raza del perro
*/ private JTextField txtRaza;
/**
* Es el campo para la edad del perro
*/ private JTextField txtEdad;
/**
* Es el campo para la altura del perro
*/ private JTextField txtAltura;
/**
* Construye el panel e inicializa sus componentes.
*/ public PanelDatosPerro( )
{
setLayout( new BorderLayout( ) );
setBorder( new CompoundBorder( new EmptyBorder( 4, 3, 3, 3 ), new TitledBorder( "Datos Perro" ) ) );
JPanel panelImagen = new JPanel( );
etiquetaImagen = new JLabel( );
etiquetaImagen.setBorder( new LineBorder( Color.BLACK, 1 ) );
etiquetaImagen.setMinimumSize( new Dimension( 230, 153 ) );
etiquetaImagen.setMaximumSize( new Dimension( 230, 153 ) );
/**
* Muestra los datos del perro en los campos.
* @param perro es el perro del que se quieren mostrar los datos - perro!= null
*/ public void mostrarDatos( Perro perro )
{ try
{
String imagen = perro.darImagen( );
BufferedImage bImagen = ImageIO.read( new File( imagen ) );
Image laImagen = bImagen.getScaledInstance( ( int ) ( ANCHO * 0.85 ), ( int ) ( ALTURA * 0.85 ), Image.SCALE_AREA_AVERAGING );
etiquetaImagen.setIcon( new ImageIcon( laImagen ) );
validate( );
} catch( IOException e )
{
JOptionPane.showMessageDialog(this, "Error al cargar la imagen del perro "+perro.darNombre(), "Error", JOptionPane.ERROR_MESSAGE);
}
}
/**
* Limpia todos los campos.
*/ public void limpiarDatos( )
{
etiquetaImagen.setIcon( null );
txtNombre.setText( "" );
txtRaza.setText( "" );
txtAltura.setText( "" );
txtEdad.setText( "" );
}
}
/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* $Id: PanelExtension.java,v 1.4 2006/08/06 20:34:34 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: n7_exposicionCanina
* Autor: Mario Sánchez - 25/08/2005
* Modificado por: Daniel Romero- 30/06/2006
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*/
/**
* Es el panel que contiene los botones de extensión
*/ public class PanelExtension extends JPanel implements ActionListener
{
// -----------------------------------------------------------------
// Constantes
// -----------------------------------------------------------------
/**
* El comando para el botón 1
*/ private final String OPCION_1 = "opcion 1";
/**
* El comando para el botón 2
*/ private final String OPCION_2 = "opcion 2";
/**
* Es la referencia a la interfaz de la aplicación
*/ private InterfazExposicionCanina principal;
// -----------------------------------------------------------------
// Atributos de la Interfaz
// -----------------------------------------------------------------
/**
* Es el botón 1
*/ private JButton botonOpcion1;
/**
* Es el botón 2
*/ private JButton botonOpcion2;
/**
* Construye el panel con una referencia a la ventana principal de la aplicación.
* @param iec es una referencia a la ventana principal - ie!=null
*/ public PanelExtension( InterfazExposicionCanina iec )
{
principal = iec;
inicializar( );
}
/**
* Inicializa los componentes del panel. <br>
* <b>post: </b> Se inicializaron y se ubicaron los componentes del panel.
*/ private void inicializar( )
{
setBorder( new TitledBorder( "Puntos de Extensión" ) );
setLayout( new FlowLayout( ) );
botonOpcion1 = new JButton( "Opción 1" );
botonOpcion1.setActionCommand( OPCION_1 );
botonOpcion1.addActionListener( this );
botonOpcion2 = new JButton( "Opción 2" );
botonOpcion2.setActionCommand( OPCION_2 );
botonOpcion2.addActionListener( this );
add( botonOpcion1 );
add( botonOpcion2 );
}
/**
* Este método se llama cuando se presiona uno de los botones.
* @param event es el evento del click en el botón
*/ public void actionPerformed( ActionEvent event )
{
String comando = event.getActionCommand( ); if( OPCION_1.equals( comando ) )
{
principal.reqFuncOpcion1( );
} else if( OPCION_2.equals( comando ) )
{
principal.reqFuncOpcion2( );
}
}
}
/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* $Id: PanelListaPerros.java,v 1.9 2010/03/29 20:47:53 lr.ruiz114 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: n7_exposicionCanina
* Autor: Mario Sánchez - 26/08/2005
* Modificado por: Daniel Romero- 30/06/2006
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*/ package uniandes.cupi2.exposicionCanina.interfaz;
/**
* Es el panel donde se muestra la lista de perros y están los botones para interactuar con la lista
*/ public class PanelListaPerros extends JPanel implements ListSelectionListener
{
// -----------------------------------------------------------------
// Atributos
// -----------------------------------------------------------------
/**
* Es una referencia a la clase principal de la interfaz
*/ private InterfazExposicionCanina principal;
// -----------------------------------------------------------------
// Atributos de la Interfaz
// -----------------------------------------------------------------
/**
* Es la lista que se muestra
*/ private JList listaPerros;
/**
* Componente de desplazamiento para contener la lista gráfica
*/ private JScrollPane scroll;
/**
* Construye el panel e inicializa todos sus componentes
* @param ventanaPrincipal es una referencia a la clase principal de la interfaz - ventanaPrincipal != null
*/ public PanelListaPerros( InterfazExposicionCanina ventanaPrincipal )
{
principal = ventanaPrincipal;
setLayout( new BorderLayout( ) );
setBorder( new CompoundBorder( new EmptyBorder( 4, 3, 3, 3 ), new TitledBorder( "Perros en la exposición" ) ) );
listaPerros = new JList( );
listaPerros.setSelectionMode( ListSelectionModel.SINGLE_SELECTION );
listaPerros.addListSelectionListener( this );
scroll = new JScrollPane( listaPerros );
scroll.setHorizontalScrollBarPolicy( JScrollPane.HORIZONTAL_SCROLLBAR_NEVER );
scroll.setVerticalScrollBarPolicy( JScrollPane.VERTICAL_SCROLLBAR_ALWAYS );
scroll.setBorder( new CompoundBorder( new EmptyBorder( 3, 3, 3, 3 ), new LineBorder( Color.BLACK, 1 ) ) );
/**
* Actualiza la lista de perros que se está mostrando
* @param nuevaLista es una lista con los perros que deben mostrarse
*/ public void refrescarLista( ArrayList nuevaLista )
{
listaPerros.setListData( nuevaLista.toArray( ) );
listaPerros.setSelectedIndex( 0 );
}
/**
* Selecciona un elemento de la lista
* @param seleccionado es la posición del elemento que se debe seleccionar
*/ public void seleccionar( int seleccionado )
{
listaPerros.setSelectedIndex( seleccionado );
listaPerros.ensureIndexIsVisible( seleccionado );
}
/**
* Cambia la información del perro que se está mostrando de acuerdo al nuevo perro seleccionado
* @param e es el evento de cambio el ítem seleccionado en la lista
*/ public void valueChanged( ListSelectionEvent e )
{ if( listaPerros.getSelectedValue( ) != null )
{
Perro p = ( Perro )listaPerros.getSelectedValue( );
principal.verDatos( p );
}
}
}
/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* $Id: ExposicionPerros.java,v 1.5 2006/08/04 15:12:57 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: n7_exposicionCanina
* Autor: Mario Sánchez - 26/08/2005
* Modificado por: Daniel Romero- 30/06/2006
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*/ package uniandes.cupi2.exposicionCanina.mundo;
import java.util.*;
/**
* Es la clase que se encarga de manejar, organizar, cargar y salvar los perros. <br>
* <b>inv: </b> <br>
* perros != null <br>
* no hay dos perros con el mismo nombre
*/ public class ExposicionPerros
{
// -----------------------------------------------------------------
// Atributos
// -----------------------------------------------------------------
/**
* Es el vector que contiene todos los perros
*/ private ArrayList perros;
/**
* Retorna una lista de perros. La lista que se retorna no es la misma que la almacenada en esta clase, pero si tiene el mismo orden.
* @return Lista de perros
*/ public ArrayList darPerros( )
{
ArrayList copiaLista = new ArrayList( perros ); return copiaLista;
}
/**
* Organiza la lista de perros por raza usando el algoritmo de burbuja. <br>
* <b>post: </b>La lista de perros está ordenada por raza (orden ascendente).
*/ public void ordenarPorRaza( )
{ for( int i = perros.size( ); i > 0; i-- )
{ for( int j = 0; j < i - 1; j++ )
{
Perro p1 = ( Perro )perros.get( j );
Perro p2 = ( Perro )perros.get( j + 1 );
// Si es necesario se deben intercambiar p1 y p2 if( p1.compararPorRaza( p2 ) > 0 )
{
perros.set( j, p2 );
perros.set( j + 1, p1 );
}
}
}
verificarInvariante( );
}
/**
* Organiza la lista de perros por nombre usando el algoritmo de burbuja. <br>
* <b>post: </b>La lista de perros está ordenada por nombre (orden ascendente).
*/ public void ordenarPorNombre( )
{ for( int i = perros.size( ); i > 0; i-- )
{ for( int j = 0; j < i - 1; j++ )
{
Perro p1 = ( Perro )perros.get( j );
Perro p2 = ( Perro )perros.get( j + 1 );
// Si es necesario se deben intercambiar p1 y p2 if( p1.compararPorNombre( p2 ) > 0 )
{
perros.set( j, p2 );
perros.set( j + 1, p1 );
}
}
}
verificarInvariante( );
}
/**
* Organiza la lista de perros por puntos usando el algoritmo de inserción. <br>
* <b>post: </b>La lista de perros está ordenada por puntos (orden ascendente).
*/ public void ordenarPorPuntos( )
{ for( int i = 1; i < perros.size( ); i++ )
{
Perro porInsertar = ( Perro )perros.get( i ); boolean termino = false; for( int j = i; j > 0 && !termino; j-- )
{
Perro actual = ( Perro )perros.get( j - 1 ); if( actual.compararPorPuntos( porInsertar ) > 0 )
{
perros.set( j, actual );
perros.set( j - 1, porInsertar );
} else
termino = true;
}
}
verificarInvariante( );
}
/**
* Organiza la lista de perros por edad usando el algoritmo de selección. <br>
* <b>post: </b>La lista de perros está ordenada por edad (orden ascendente).
*/ public void ordenarPorEdad( )
{ int inicial;
// En cada iteración se sabe que:
// 1. Todos los valores antes de perros[inicial] están ordenados por edad
// 2. No hay ningún valor después de perros[inicial-1] que sea menor que perros[inicial-1]
// En cada iteración se busca el menor entre perros[inicial] y perros[final] y se ubica en perros[inicial]
// Buscar el perro de menor edad entre inicial y final for( int i = inicial + 1; i < perros.size( ); i++ )
{
Perro perroPosicion = ( Perro )perros.get( i );
// El perro de la posición actual es menor que el menor encontrado hasta el momento if( perroPosicion.compararPorEdad( perroMenor ) < 0 )
{
perroMenor = perroPosicion;
posicionMenor = i;
}
}
/**
* Busca un perro según su nombre y retorna la posición en la que se encuentra.
* @param nombre es el nombre del perro buscado - nombre!=null
* @return Retorna la posición donde se encuentra un perro con el nombre dado. Si no se encuentra ningún perro con ese nombre retorna -1
*/ public int buscarPerro( String nombre )
{ int posicion = -1; boolean termine = false;
for( int i = 0; i < perros.size( ) && !termine; i++ )
{
Perro perroPosicion = ( Perro )perros.get( i );
String nombrePerro = perroPosicion.darNombre( );
// Los nombres son iguales if( nombrePerro.equalsIgnoreCase( nombre ) )
{
posicion = i;
termine = true;
}
}
return posicion;
}
/**
* Busca un perro utilizando una búsqueda binaria. <br>
* <b>pre: </b> La lista de perros se encuentra ordenada por nombre.
* @param nombre es el nombre del perro que se va a buscar - nombre!=null
* @return La posición del perro con el nombre dado. Si el perro no existe se retorna -1.
*/ public int buscarBinarioPorNombre( String nombre )
{ int posicion = -1; int inicio = 0; int fin = perros.size( ) - 1;
Perro aBuscar = new Perro( nombre, "", "", 1, 1 ); while( inicio <= fin && posicion == -1 )
{ int medio = ( inicio + fin ) / 2;
Perro mitad = ( Perro )perros.get( medio ); if( mitad.compararPorNombre( aBuscar ) == 0 )
{
posicion = medio;
} else if( mitad.compararPorNombre( aBuscar ) > 0 )
{
fin = medio - 1;
} else
{
inicio = medio + 1;
}
} return posicion;
}
/**
* Agrega un nuevo perro a la exposición. <br>
* <b>post: </b> El perro fue agregado a la exposición si no existe otro perro con el mismo nombre.
* @param nombreP es el nombre del perro - nombreP != null
* @param razaP es la raza del perro - razaP != null
* @param imagenP es la ruta a la imagen del perro - imagenP != null
* @param puntosP son Los puntos del perro en la exposición - puntosP >= 0
* @param edadP es la edad en meses del perro - edadP >= 0
* @return True si el perro fue adicionado o false de lo contrario
*/ public boolean agregarPerro( String nombreP, String razaP, String imagenP, int puntosP, int edadP )
{ int perroBuscado = buscarPerro( nombreP ); boolean agregado = false; if( perroBuscado == -1 )
{
Perro nuevoPerro = new Perro( nombreP, razaP, imagenP, puntosP, edadP );
perros.add( nuevoPerro );
agregado = true;
}
verificarInvariante( );
return agregado;
}
/**
* Busca el perro que tenga el mayor puntaje en la exposición.
* @return Retorna la posición donde se encuentra el perro con el mayor puntaje. Si no hay perros en la exposición se retorna -1
*/ public int buscarPerroMayorPuntaje( )
{ int posicion = -1;
if( perros.size( ) > 0 )
{
Perro pMayorPuntaje = ( Perro )perros.get( 0 );
posicion = 0; for( int i = 1; i < perros.size( ); i++ )
{
Perro perroPosicion = ( Perro )perros.get( i );
/**
* Busca el perro que tenga el menor puntaje en la exposición.
* @return Retorna la posición donde se encuentra el perro con el menor puntaje. Si no hay perros en la exposición se retorna -1
*/ public int buscarPerroMenorPuntaje( )
{ int posicion = -1;
if( perros.size( ) > 0 )
{
Perro pMenorPuntaje = ( Perro )perros.get( 0 );
posicion = 0; for( int i = 1; i < perros.size( ); i++ )
{
Perro perroPosicion = ( Perro )perros.get( i );
/**
* Busca el perro que tenga la mayor edad.
* @return Retorna la posición donde se encuentra el perro con la mayor edad. Si no hay perros en la exposición se retorna -1
*/ public int buscarPerroMayorEdad( )
{ int posicion = -1;
if( perros.size( ) > 0 )
{
Perro pMayorEdad = ( Perro )perros.get( 0 );
posicion = 0; for( int i = 1; i < perros.size( ); i++ )
{
Perro perroPosicion = ( Perro )perros.get( i );
/**
* Verifica el invariante de la clase. <br>
* <b>inv </b> perros != null y no hay dos perros con el mismo nombre
*/ private void verificarInvariante( )
{ assert ( perros != null ) : "La lista de perros no debe ser null"; assert ( !buscarPerrosConNombresRepetidos( ) ) : "Hay dos perros con el mismo nombre";
}
/**
* Verifica si hay dos perros con el mismo nombre.
* @return Retorna true si hay dos perros con el mismo nombre, retorna false en caso contrario
*/ private boolean buscarPerrosConNombresRepetidos( )
{ for( int i = 0; i < perros.size( ); i++ )
{
Perro perroI = ( Perro )perros.get( i ); for( int j = 0; j < perros.size( ); j++ )
{ if( i != j )
{
Perro perroJ = ( Perro )perros.get( j ); if( perroJ.darNombre( ).equals( perroI.darNombre( ) ) )
{ return true;
}
}
}
} return false;
}
// -----------------------------------------------------------------
// Puntos de Extensión
// -----------------------------------------------------------------
/**
* Ejecuta el punto de extensión 1.
* @return respuesta 1
*/ public String metodo1( )
{ return "respuesta1";
}
/**
* Ejecuta el punto de extensión 2.
* @return respuesta 2
*/ public String metodo2( )
{ return "respuesta2";
}
}
/**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* $Id: Perro.java,v 1.7 2010/03/29 20:47:53 lr.ruiz114 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: n7_exposicionCanina
* Autor: Mario Sánchez - 26/08/2005
* Modificado por: Daniel Romero- 30/06/2006
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*/ package uniandes.cupi2.exposicionCanina.mundo;
/**
* Es la clase que representa a un perro. <br>
* <b>inv: </b> <br>
* puntos >= 0 <br>
* edad > 0 <br>
* imagen != null <br>
* nombre != null <br>
* raza != null
*/ public class Perro
{
// -----------------------------------------------------------------
// Atributos
// -----------------------------------------------------------------
/**
* El nombre del perro
*/ private String nombre;
/**
* La raza del perro
*/ private String raza;
/**
* La ruta hasta la imagen del perro
*/ private String imagen;
/**
* Los puntos del perro en la exposición
*/ private int puntos;
/**
* La edad en meses del perro
*/ private int edad;
/**
* Construye un nuevo perro con los parámetros indicados. <br>
* <b>post: </b> Se construyó un perro con los parámetros especificados.
* @param nombreP es el nombre del perro - nombreP != null
* @param razaP es la raza del perro - razaP != null
* @param imagenP es la ruta a la imagen del perro - imagenP != null
* @param puntosP son los puntos del perro - puntosP >= 0
* @param edadP es la edad en meses del perro - edadP > 0
*/ public Perro( String nombreP, String razaP, String imagenP, int puntosP, int edadP )
{
nombre = nombreP;
raza = razaP;
imagen = imagenP;
puntos = puntosP;
edad = edadP;
/**
* Retorna el nombre del perro.
* @return Nombre del perro
*/ public String darNombre( )
{ return nombre;
}
/**
* Retorna la raza del perro.
* @return La raza del perro
*/ public String darRaza( )
{ return raza;
}
/**
* Retorna la ruta a la imagen del perro.
* @return La imagen del perro
*/ public String darImagen( )
{ return imagen;
}
/**
* Retorna los puntos del perro en la exposición.
* @return Los puntos del perro en la exposición
*/ public int darPuntos( )
{ return puntos;
}
/**
* Retorna la edad en meses del perro.
* @return La edad en meses del perro.
*/ public int darEdad( )
{ return edad;
}
/**
* Compara dos perros según el nombre. <br>
* @param p es el perro contra el que se está comparando - p !=null
* @return Retorna 0 si los perros tienen el mismo nombre. <br>
* Retorna -1 si el perro p tiene una valor "MAYOR" para el nombre. <br>
* Retorna 1 si el perro p tiene una valor "MENOR" para el nombre. <br>
*/ public int compararPorNombre( Perro p )
{ int valorComparacion = nombre.compareToIgnoreCase( p.nombre ); if(valorComparacion < 0){
valorComparacion = -1;
}else if(valorComparacion == 0){
valorComparacion = 0;
}else{
valorComparacion = 1;
} return valorComparacion;
}
/**
* Compara dos perros según su raza. <br>
* @param p es el perro contra el que se está comparando - p != null
* @return Retorna 0 si los perros tienen la misma raza. <br>
* Retorna -1 si el perro p tiene una valor "MAYOR" para la raza. <br>
* Retorna 1 si el perro p tiene una valor "MENOR" para la raza. <br>
*/ public int compararPorRaza( Perro p )
{ int valorComparacion = raza.compareToIgnoreCase( p.raza ); if(valorComparacion < 0){
valorComparacion = -1;
}else if(valorComparacion == 0){
valorComparacion = 0;
}else{
valorComparacion = 1;
} return valorComparacion;
}
/**
* Compara dos perros según sus puntos. <br>
* @param p El perro contra el que se está comparando - p!= null
* @return Retorna 0 si los perros tienen los mismos puntos. <br>
* Retorna -1 si el perro p tiene una valor "MAYOR" para puntos . <br>
* Retorna 1 si el perro p tiene una valor "MENOR" para los puntos. <br>
*/ public int compararPorPuntos( Perro p )
{ if( puntos == p.puntos ) return 0; else if( puntos > p.puntos ) return 1; else return -1;
}
/**
* Compara dos perros según su edad. <br>
* @param p El perro contra el que se está comparando - p!=null
* @return Retorna 0 si los perros tienen la misma edad. <br>
* Retorna -1 si el perro p tiene una valor "MAYOR" para la edad. <br>
* Retorna 1 si el perro p tiene una valor "MENOR" para la edad. <br>
*/ public int compararPorEdad( Perro p )
{ if( edad == p.edad ) return 0; else if( edad > p.edad ) return 1; else return -1;
}
/**
* Retorna una cadena con el nombre del perro
* @return La representación del perro en String
*/ public String toString( )
{ return nombre + " (" + raza + ")";
}
/**
* Verifica el invariante de la clase. <br>
* <b>inv: </b> altura > 0 y edad > 0 y imagen != null y nombre != null y raza != null
*/ private void verificarInvariante( )
{ assert ( puntos >= 0 ) : "Los puntos no pueden ser menores a 0"; assert ( edad > 0 ) : "La edad no puede ser 0"; assert ( imagen != null ) : "La imagen no puede ser null"; assert ( nombre != null ) : "El nombre no puede ser null"; assert ( raza != null ) : "La raza no puede ser null";
}
}
Interfaz
InterfazExposicionCanina