Prctica

Sesin 1: INTERFACES Y PAQUETES CON J2EE SERVER

I. OBJETIVOS
Definir Interfaces y Paquetes. Demostrar la utilidad de Interfaces y Paquetes.

II. MARCO TEORICO

INTERFACE Un interface se podra ver como un contrato donde se menciona qu puede hacer la clase, sin decir nada sobre cmo lo har. Es una coleccin de definiciones de mtodos (sin implementaciones) y de valores constantes. Los interfaces se utilizan para definir un protocolo de comportamiento que puede ser implementado por cualquier clase del rbol de clases. Los interfaces son tiles para: capturar similitudes entre clases no relacionadas sin forzar una relacin entre ellas. declarar mtodos que una o varias clases necesitan implementar. revelar el interface de programacin de un objeto sin revelar sus clases (los objetos de este tipo son llamados objetos annimos y pueden ser tiles cuando compartas un paquete de clases con otros desarrolladores). LA DECLARACIN DE INTERFACE Como mnimo, una declaracin de interface contiene la palabra clave interface y el nombre del interface que se va a crear: interface Contable { ... } Una declaracin de interface puede tener otros dos componentes: el especificador de acceso public y una lista de "superinterfaces". Un interface puede extender otros interfaces como una clase puede extender o subclasificar otra clase. Sin embargo, mientras que una clase slo puede extender una superclase, los interfaces pueden extender de cualquier nmero de interfaces. As, una declaracin completa de interface se parecera a esto: [public] interface NombredeInterface [extends listadeSuperInterfaces] { ... } El especificador de acceso public indica que el interface puede ser utilizado por todas las clases en cualquier paquete. Si el interface no se especifica como pblico, slo ser accesible para las clases definidas en el mismo paquete que el interface. La clausula extends es similar a la utilizada en la declaracin de una clase, sin embargo, un interface puede extender varios interfaces (mientras una clase slo puede extender una), y un

interface no puede extender clases. Esta lista de superinterfaces es una lista delimitada por comas de todos los interfaces extendidos por el nuevo interface. EL CUERPO DEL INTERFACE El cuerpo del interface contiene las declaraciones de mtodos para los mtodos definidos en el interface. Este cdigo define un nuevo interface llamado coleccin que contiene un valor constante y tres declaraciones de mtodos: interface coleccion { int MAXIMO = 500; void aadir(Object obj); void borrar(Object obj); Object buscar(Object obj); int contadorActual(); } El interface anterior puede ser implementado por cualquier clase que represente una coleccin de objetos como pueden ser pilas, vectores, enlaces, etc... Observe que cada declaracin de mtodo est seguida por un punto y coma (;) porque un interface no proporciona implementacin para los mtodos declarados dentro de l. IMPLEMENTAR UN INTERFACE Para utilizar un interface se debe escribir una clase que lo implemente. Una clase declara todos los interfaces que implementa en su declaracin de clase. Para declarar que una clase implementa uno o ms interfaces, se utiliza la palabra clave implements seguida por una lista delimitada por comas con los interfaces implementados por la clase. class PilaFIFO implements coleccion { ... void aadir(Object obj) { ... } void borrar(Object obj) { ... } Object buscar(Object obj) { ... } int contadorActual() { ... } } Todos los mtodos de un interface son abstractos y pblicos. No es necesario especificarlo. Un mtodo de interface no debe ser esttico, ni final, ni de tipo strictfp, ni nativo. Todas las variables definidas en un interface deben ser pblicas, estticas y finales, en otras palabras, un interface puede declarar solo constantes, no variables de instancia. Los interfaces son implcitamente abstractos. El modificador pblico ser requerido si queremos que el interface tenga acceso pblico en vez del acceso por defecto.

Un interface puede extender una o ms interfaces y no puede extender otra cosa que no sea otros interfaces. Un interface no puede implementar otra interface o una clase. Por ejemplo, las siguientes 5 declaraciones de mtodos, si se declaran dentro de sus propios interfaces, son legales e idnticos: void bounce(); public void bounce(); abstract void bounce(); public abstract void bounce(); abstract public void bounce(); Las siguientes declaraciones de mtodos de interface no compilarn: final void bounce(); // mtodos finales y abstractos no pueden ser usados nunca juntos, // y los abstractos son los implcitos en este caso static void bounce(); // los interfaces definen mtodos de instancia. private void bounce(); // mtodos de interface son siempre pblicos. protected void bounce(); // la misma explicacin anterior. DECLARANDO CONSTANTES EN UN INTERFACE Al declarar constantes en un interface, se garantiza que cualquier clase que implemente la interface tendr acceso a la misma constante. La regla de oro es que una constante de un interface debe ser siempre pblica, esttica y final. Veamos este ejemplo: interface Foo { int BAR = 42; void go(); } class Zap implements Foo { public void go() { BAR = 27; } } No se puede cambiar el valor a una constante. Una vez que su valor ha sido asignado en la declaracin del interface, el valor nunca podr modificarse. Entonces la instruccin BAR = 27 no compilar. Por ejemplo, las siguientes declaraciones de constantes en un interface son idnticos: public int x=1; // parece no esttico y no final, pero no lo es int x = 1; // parece de tipo por defecto, no final, no esttico, pero no lo es static int x=1; // no se muestra final ni pblico final int x=1; // no se muestra esttico ni pblico public static int x=1; // no se muestra final public final int x=1; // no se muestra esttico static final int x=1; // no se muestra pblico public static final int x=1; // sto es lo que es implcitamente

PAQUETES Java organiza las clases dentro de paquetes, y usa la instruccin import para dar a los programadores una forma consistente de manejar y acceder a las clases que necesitan. Los paquetes son grupos relacionados de clases e interfaces y proporcionan un mecanismo conveniente para manejar un gran juego de clases e interfaces y evitar los conflictos de nombres. Adems de los paquetes de Java puede crear tus propios paquetes y poner en ellos definiciones de clases y de interfaces utilizando la sentencia package. Se declara un paquete utilizando la sentencia package: package graphics; interface Draggable { ... } class Circle { ... } class Rectangle { ... } La primera lnea del cdigo anterior crea un paquete llamado graphics. Todas las clases e interfaces definidas en el fichero que contiene esta sentencia son miembros del paquete. Por lo tanto, Draggable, Circle y Rectangle son miembros del paquete graphics. Las instrucciones import y package se aplican a todas las clases dentro de un archivo de cdigo. Osea que no hay forma de declarar mltiples clases en un archivo y tenerlas en diferentes paquetes, o usar diferentes imports. CLASSPATH CLASSPATH es una lista de directorios que indica al sistema donde ha instalado varias clases e interfaces compiladas Java. Cuando busque una clase, el intrprete Java busca un directorio en su CLASSPATH cuyo nombre coincida con el nombre del paquete del que la clase es miembro. Los ficheros .class para todas las clases e interfaces definidas en un paquete deben estar en ese directorio de paquete. ENCONTRANDO UN PAQUETE Cuando se colocan las clases dentro de paquetes y luego se usa classpaths para encontrar estas clases, las cosas se vuelven un poco complicadas. Veamos el siguiente cdigo: package com.foo; public class MyClass {public void hi() { } } Estamos diciendo que MyClass es un miembro del paquete com.foo. Esto significa que el nombre calificado completo de la clase ahora es com.foo.MyClass. Una vez que una clase est en un paquete, su nombre es atmico, no podr ser dividido nunca, ni en una linea de comando, ni en una instruccin import. Ahora veamos como se usa com.foo.MyClass en otra clase, en otro archivo: import com.foo.MyClass; import com.foo.*; // ambos imports funcionarn

public class another { void go() { MyClass m1 = new MyClass(); // nombre alias com.foo.MyClass m2 = new com.foo.MyClass(); m1.hi(); m2.hi(); } }

// nombre completo

La instruccin import es como un alias para el nombre completo de la clase. Una vez que lo defines, puedes usarlo en el cdigo. Ahora veamos cmo funciona en conjunto con los classpaths y las lneas de comando. El nombre completo de una clase hace referencia a una estructura de directorio. Por ejemplo, referente al actual estructura de directorio, la clase cuyo cdigo es package com.foo; public class MyClass {public void hi() { } } debera estar ubicado aqu: com/foo/MyClass.class Veamos otro ejemplo: import com.wickedlysmart.Utils; class TestClass { void doStuff() { Utils u = new Utils(); // nombre simple u.doX(arg1,arg2); com.wickedlysmart.Date(); // nombre completo d.getMonth(Oct); } } No tenemos que escribir su nombre completo dentro de la clase pues hemos usado la clausula import. Al tiempo de compilar o ejecutar TestClass, el classpath tendr que incluir un directorio con los siguientes atributos: un subdirectorio llamado com (que lo llamaremos directorio raiz) un subdirectorio en com llamado wickedlysmart dos archivos en wickedlysmart llamados Utils.class y Date.class

Finalmente el directorio que tiene todos estos atributos tiene que ser accesible (via classpath) en una de las siguientes formas: 1. El camino al directorio debe ser absoluto, en otras palabras, desde la raz del sistema (no del paquete). La instruccin podra ser -cp /dirA:/dirA/dirB si consideramos un rbol de directorios /dirA/dirB 2. El camino al directorio tiene que ser correcto relativo desde el actual directorio. La instruccin podra ser -cp dirB:dirB/dirC si consideramos un rbol de directiorios /dirA/dirB/dirC y si el directorio actual es dirB.

CREANDO ARCHIVOS JAR Una vez que tienes probada y construida tu aplicacin, probablemente querrs empaquetarla en un solo archivo para facilitarte su distribucin e instalacin. Un mecanismo que Java provee son los archivos jar (java archive). stos son usados para comprimir y archivar datos. Veamos una aplicacin con clases en diferentes paquetes: test UseStuff.java ws (crear MyJar.jar aqu) myApp utils Dates.class engine rete.class minmax.class

(package myApp.utils;) (package myApp.engine;) (package myApp.engine;)

Puedes crear un archivo simple jar que contenga todos los archivos en MyApp, y as mantener la estructura de directorios de myApp. Una vez que este jar es creado, puede ser llevado a cualquier lugar, a cualquier mquina y, todas las clases en el archivo jar podrn ser accesibles, via classpath, por java y javac sin siquiera desempaquetar el archivo jar. Supongamos que el directorio actual es ws, para crear el archivos jar debemos especificar: cd ws jar -cf MyJar.jar myApp El comando jar crear el archivo jar llamado MyJar.jar y que contendr el directorio myApp y todos sus subdirectorios y archivos. Se puede observar el contenido de un archivo jar as: jar -tf MyJar.jar que producir: META-INF/ META-INF/MANIFEST.MF myApp/ myApp/.DS_Store myApp/utils/ myApp/utils/Dates.class myApp/engine/ myApp/engine/rete.class myApp/engine/minmax.class Si deseamos compilar UseStuff.java en el directorio test y resulta que UseStuff.java necesita acceder a una clase contenida en myApp.jar, haremos lo siguiente: cd test javac -classpath ws/myApp.jar UseStuff.java Sin embargo si quisieramos usar una clase en un paquete (a diferencia de usar un archivo jar), por ejemplo si UseStuff.java necesita usar las clases en el paquete myApp.utils, y la clase no est en un jar, se hara lo siguiente: cd test javac -classpath ws UseStuff.java

Ejemplo 1 import java.io.PrintWriter; public class CallbackTest { public static void main(String args[]) { LoopingClient client = new LoopingClient(); new MessageServer (5, 100, client); // create a new server client.run(); // run the client } } class LoopingClient implements MessagePrintable { int counter = 0; PrintWriter out = new PrintWriter (System.out, true); void run() { while (counter++ < 2000000) { int dummy = counter * counter / (counter + 1); } } public void printMessage() { out.println("The counter value is now: " + counter); } } class MessageServer extends Thread { int times; int interval; MessagePrintable object; MessageServer (int times, int interval, MessagePrintable object) { this.times = times; this.interval = interval; this.object = object; this.setPriority (Thread.NORM_PRIORITY + 2); // let server get higher priority this.start(); // start running the new thread } public void run() { // repeat sleep-printMessage several times for (int i = 0; i < times; i++) { try { // try-catch is for exception handling sleep (interval); } catch (InterruptedException e) {} object.printMessage(); } } } interface MessagePrintable { void printMessage(); } Compilar
C:\SistemasDistribuidos\Pract1>javac CallbackTest.java

Resultados
C:\SistemasDistribuidos\Pract1>java CallbackTest The counter value is now: 2000001 The counter value is now: 2000001 The counter value is now: 2000001 The counter value is now: 2000001 The counter value is now: 2000001

Ejemplo 2 OperacionesInterface.java package PaqueteOperaciones; import java.rmi.*; import javax.swing.*; public interface OperacionesInterface { public int Sumar(int x, int y); public int Restar(int x, int y); } OperacionesImpl.java package PaqueteOperaciones; import javax.swing.*; import java.io.PrintWriter; public class OperacionesImpl implements OperacionesInterface { public void OperacionesImpl() { } public int Sumar(int x, int y) { return (x+y); } public int Restar(int x, int y) { return (x-y); } } principal.java package PaqueteOperaciones; import java.rmi.*; import javax.swing.*; import PaqueteOperaciones.*; class principal { public static void main(String arg[])

{ OperacionesImpl op=new OperacionesImpl(); //OperacionesInterface op=new OperacionesInterface(); System.out.println("suma: " + op.Sumar(3,9)); } } C:\SistemasDistribuidos\Pract1>set CLASSPATH=c:\SistemasDistribuidos\Pract1;c:\SistemasDistribuidos\Pract1\PaqueteOperaciones Resultados C:\SistemasDistribuidos\Pract1>javac PaqueteOperaciones/OperacionesInterface.java C:\SistemasDistribuidos\Pract1>javac PaqueteOperaciones/OperacionesImpl.java C:\SistemasDistribuidos\Pract1>javac PaqueteOperaciones/principal.java C:\SistemasDistribuidos\Pract1>java PaqueteOperaciones/principal suma: 12 C:\SistemasDistribuidos\Pract1>

III. ACTIVIDADES
1. En un centro mdico se tiene: Hospital Paciente Personal Nombre. IdPaciente DNI Direccin. DNI Direccin Telefono. NombreApellido. Telfono. Fax. Direccin Cargo. Telfono. Desarrolle la Interfaz para Hospital, Paciente, Personal. Implemente las Interfaces y sus mtodos. Agrupe todo en un paquete de nombre Hospital Generar el archivo Hospital.jar para poder distribuirlo a los usuarios finales.