Practica 1: Repaso
Orientación Objetos y Java
El objetivo de esta práctica es retomar el ejemplo
visto en curso para repasar los principios de:
- Herencia
- Asociación
- Polimorfismo
En esta práctica vamos a programar con Java desde la
consola. Más adelante utilizaremos un entorno de desarrollo
integrado.
Creación de un proyecto Java
En general, se recomienda estructurar un proyecto Java dentro de un
directorio raiz que contiene a su vez un conjunto de sub-directorios:
- Vehiculos
- src - archivos fuente
- build - directorio en donde se ponen los archivos
compilados
- dist - distribución del proyecto
- doc - documentación
- lib - librerias
Paso 1.- Crea dentro de
tu cuenta una estructura de directorios cómo la antes descrita
Creación de un espacio de nombres (package)
En clase vimos el concepto de espacio de nombres (que en Java
se define usando la palabra reservada package).
Sun define un conjunto de convenciones para nombrar los
diferentes elementos en Java (packages, clases, etc...). Estas
convenciones se encuentran en la liga siguiente:
Paso 2.- Ver la
convencion para el package y escoger un nombre de package. Una vez que
hayas escogido tu nombre de package, crea dentro del directorio src los diferentes sub-directorios
que corresponden al nombre de tu package.
Creación de las diferentes clases y comentarios de
código
La figura siguente muestra el diagrama de clases del ejemplo
visto en clase:
Una vez que hayas creado tus directorios correspondientes al
package, puedes comenzar a escribir las distintas clases presentadas en
el diagrama presentado arriba. En particular tienes que escribir las
clases siguientes:
- clase Abstracta Vehiculo
- sub-clase Coche
- sub-clase Camion
- interfase Motor
- implementación MotorTurbo
- implementación MotorAltoRendimiento
Un ejemplo de clase Java es el siguiente:
package
mi.espacio.nombres;
/**
* Clase Ejemplo.
*
*/
class Ejemplo
{
private String miNombre;
/**
* Este es el constructor de la clase Ejemplo
*
*/
public Ejemplo(String cadena)
{
System.out.println("Ejemplo.Ejemplo()");
miNombre
= cadena;
}
/**
* Este es el constructor de la clase Ejemplo
*
*/
public String leeMiNombre()
{
System.out.println("Ejemplo.leeMiNombre()");
return miNombre;
}
}
Para hacer la herencia se utiliza la palabra reservada extends.
Por ejemplo:
class
OtroEjemplo extends Ejemplo
{
}
Para
hacer una inferfase se utiliza la palabra reservada interface y
todos los metodos declarados tienen que ser públicos.
Por ejemplo:
interface
UnaInterface
{
public void unMetodo();
}
Una implementación de esta interfase se realiza
utilizando la palabra reservada implements.
Por ejemplo:
<>class
UnaImplementacion implements UnaInterface
{
public void unMetodo()
{
// Cuerpo del metodo
}
}
Paso 3.- Escribe las
clases tomando en cuenta las siguientes consideraciones:
- Dentro de los metodos de las distintas clases vamos a
realizar una traza utilizando el metodo System.out.println("").
Las trazas deberán indicar el nombre de la clase y el metodo en
donde se encuentran.
- Las sub-clases de Vehiculo deben recibir dentro de sus
constructores una referencia hacia un motor.
Paso 4.-
Creación de una clase principal
En un espacio de nombres distinto al que hiciste tus clases,
crea una
clase llamada Principal que
va a contener un metodo main() que
va a permitir lanzar el programa. Esta clase va a ser encargada de
instanciar
dos motores y dos vehiculos y de asociarlos (pasando el motor al
constructor del vehiculos). Una vez que los vehiculos hayan sido
instanciados, llamar al metodo enciende y apaga de cada uno de ellos.
La clase principal debe importar las clases correspondientes
al los vehiculos y motores, ya que se encuentran en un espacio de
nombres distinto (ver figura). Para ello se utiliza la palabra
reservada imports.
import
mi.espacio.nombres.MotorAltoRendimiento;
import
mi.espacio.nombres.MotorTurbo;
import
mi.espacio.nombres.Coche;
import
mi.espacio.nombres.Camion
class Principal
{
public
static void main(String []args)
{
...
}
}
Compilación
Para realizar la compilación del código, se utiliza el
comando javac
(Java Compiler). La línea siguiente, ejecutada desde la raiz del
proyecto, compila las distintas clases y las pone en el directorio
build:
- javac -d build/ src/mi/espacio/nombres/*.java
src/mi/espacio/nombres/principal/*.java
Si quieres conocer las diferentes opciones de javac
teclea el comando sin ningun parámetro.
Paso 5.- Realizar la
compilación y verificar que se generan diferentes archivos .class bajo
el directorio build. Corregir los errores
Ejecución
Para ejecutar nuestro código, utilizamos el comando java y
hacemos referencia a la clase principal.
- java
-classpath build/ mi.espacio.nombres.principal.Principal
El classpath le indica al
entorno de ejecución en que directorio va a encontrar las clases.
A la salida, debemos obtener una traza similar a esta:
Coche
creado!
Camion
creado!
Encendiendo:coche
Motor
Turbo activado!
Apagando:coche
Motor
Turbo desactivado!
Checando
llenado...
Encendiendo:camion
Motor
Alto Rendimiento activado!
Apagando:camion
Motor
Alto Rendimiento desactivado!
Documentación
Java provee un mecanismo que permite, a partir del código
fuente, generar la documentación de un proyecto en formato HTML.
Para ello es necesario comentar el código siguiendo unas
convenciones particulares descritas
aquí.
El código del API de Java está comentado utilizando
Javadoc. La
documentación de este código está aqui.
El ejemplo de código anterior con su documentación
Javadoc queda cómo sigue:
package
mi.espacio.nombres;
/**
* Clase Ejemplo.
*
* @author Humberto Cervantes
* @version 1.0
*/
class Ejemplo
{
private String miNombre;
/**
* Este es el constructor de la clase Ejemplo
*
* @param cadena cadena que inicializa el nombre
*/
public Ejemplo(String cadena)
{
System.out.println("Ejemplo.Ejemplo()");
miNombre
= cadena;
}
/**
* Este es el constructor de la clase Ejemplo
*
* @return regresa una cadena que contiene el
nombre
*/
public String leeMiNombre()
{
System.out.println("Ejemplo.leeMiNombre()");
return miNombre;
}
}
Paso 6.- Generación
de Javadoc.
En una primera etapa, comenta el código que escribiste
utilizando convenciones Javadoc. Una vez que esto esté hecho,
genera la documentación utilizando el comando javadoc:
- javadoc
-d docs/javadoc/ -sourcepath src/ mi.espacio.nombres
mi.espacio.nombres.principal
Si quieres conocer las diferentes opciones de javadoc
teclea el comando sin ningún parámetro.
Comprueba que se generó la documentación dirigiendo tu
navegador al directorio (docs/javadoc) donde se generó la
documentación:
Empaquetamiento
El empaquetamiento va a permitir poner juntos los diferentes
archivos de nuestro proyecto dentro de un sólo archivo con
extensión JAR (Java Archive).
Paso 7.- Para realizar el
empaquetamiento de los archivos compilados, se utiliza el comando jar. La
sintáxis es la siguiente:
- jar
cvf dist/vehiculos.jar -C build/ mi/espacio/nombres/
Esto genera una salida similar a la siguiente:
added
manifest
adding:
mx/uam/vehiculos/(in = 0) (out= 0)(stored 0%)
adding:
mx/uam/vehiculos/principal/(in = 0) (out= 0)(stored 0%)
adding:
mx/uam/vehiculos/principal/Principal.class(in = 612) (out=
393)(deflated 35%)
adding:
mx/uam/vehiculos/Camion.class(in = 648) (out= 419)(deflated 35%)
adding:
mx/uam/vehiculos/Motor.class(in = 151) (out= 128)(deflated 15%)
adding:
mx/uam/vehiculos/Vehiculo.class(in = 914) (out= 506)(deflated 44%)
adding:
mx/uam/vehiculos/Coche.class(in = 460) (out= 313)(deflated 31%)
adding:
mx/uam/vehiculos/MotorAltoRendimiento.class(in = 594) (out=
345)(deflated 41%)
adding:
mx/uam/vehiculos/MotorTurbo.class(in = 552) (out= 332)(deflated 39%)
Una vez
que se ha empaquetado verificar que bajo el directorio dist se
encuentra el archivo vehiculos.jar.
Ejecución desde JAR
Paso 8. Se puede
ejecutrar el programa desde un archivo jar que contenga código
binario. Basta poner el archivo jar dentro del classpath:
- java
-classpath dist/vehiculos.jar mi.espacio.nombres.principal.Principal
Verificar que se obtiene la salida correcta.
A Entregar
Hacer un archivo Jar que contenga todos los directorios y
enviarlo por correo.
Síntesis
Esta practica permitió repasar los conceptos orientados a
objetos estudiados en clase y probar las herramientas que provee el SDK
de Java para:
- Compilar (javac)
- Documentar (javadoc)
- Empaquetar (jar)
- Ejecutar (java)
Sin embargo, la ejecución desde la línea de comando de
estos comandos tiene sus inconvenientes:
- Complicado
- Dificil de repetir
- No portable
|
