CONCEPTO DE INTERFAZ EN JAVA.

INVESTIGAR Y RESPONDER LOS SIG. PUNTOS:

1. QUE ES UNA INTERFAZ

2. PARA QUE SIRVE

3. CUALES SON SUS CARACTERISTICAS O PROPIEDADES

4. EN QUE DIFIERE DE UNA CLASE ABSTRACTA

5. COMO SE USA. UTILIZAR AL MENOS 2 EJEMPLOS

6. COMO SE PUEDE APLICAR LA IDEA DE HERENCIA MULTIPLE USANDO INTERFACES

Interfaces

Concepto de Interface

El concepto de Interface lleva un paso más adelante la idea de las clases abstractas. En Java una interface es una clase abstracta pura, es dcir una clase donde todos los métodos son abstractos (no se implementa ninguno). Permite al diseñador de clases establecer la forma de una clase (nombres de métodos, listas de argumentos y tipos de retorno, pero no bloques de código). Una interface puede también contener datos miembro, pero estos son siempre static y final. Una interface sirve para establecer un 'protocolo' entre clases. 

Para crear una interface, se utiliza la palabra clave interface en lugar de class. La interface puede definirse public o sin modificador de acceso, y tiene el mismo significado que para las clases. Todos los métodos que declara una interface son siempre public. 

Para indicar que una clase implementa los métodos de una interface se utiliza la palabra clave implements. El compilador se encargará de verificar que la clase efectivamente declare e implemente todos los métodos de la interface. Una clase puede implementar más de una interface.

Declaración y uso

Una interface se declara:

interface nombre_interface {    tipo_retorno nombre_metodo ( lista_argumentos ) ;    . . . }

Por ejemplo:

interface InstrumentoMusical {    void tocar();    void afinar();    StringtipoInstrumento();}

Y una clase que implementa la interface:

class InstrumentoViento extends Object implements InstrumentoMusical {    void tocar() { . . . };    void afinar() { . . .};    StringtipoInstrumento() {}}

class Guitarra extends InstrumentoViento {    StringtipoInstrumento() {        return "Guitarra";    }}   

La clase InstrumentoViento implementa la interface, declarando los métodos y escribiendo el código correspondiente. Una clase derivada puede también redefinir si es necesario alguno de los métodos de la interface. 

Referencias a Interfaces

Es posible crear referencias a interfaces, pero las interfaces no pueden ser instanciadas. Una referencia a una interface puede ser asignada a cualquier objeto que implemente la interface. Por ejemplo:

InstrumentoMusical instrumento = new Guitarra();instrumento.play();System.out.prinln(instrumento.tipoInstrumento());

InstrumentoMusical i2 = new InstrumentoMusical(); //error.No se puede instanciar

Extensión de interfaces

Las interfaces pueden extender otras interfaces y, a diferencia de las clases, una interface puede extender más de una interface. La sintaxis es:

interface nombre_interface  extends nombre_interface  , . . . {    tipo_retorno nombre_metodo ( lista_argumentos ) ;    . . . }

Agrupaciones de constantes

Dado que, por definición, todos los datos miembros que se definen en una interface son static y final, y dado que las interfaces no pueden instanciarse resultan una buena herramienta para implantar grupos de constantes. Por ejemplo:

public interface Meses {    int ENERO = 1 , FEBRERO = 2 . . . ;    String [] NOMBRES_MESES = { " " , "Enero" , "Febrero" , . . . };}

Esto puede usarse simplemente:

System.out.println(Meses.NOMBRES_MESES[ENERO]);

 

Un ejemplo casi real

El ejemplo mostrado a continuación es una simplificación de como funciona realmente la gestión de eventos en el sistema gráfico de usuario soportado por el API de Java (AWT o swing). Se han cambiado los nombres y se ha simplificado para mostrar un caso real en que el uso de interfaces resuelve un problema concreto.

Supongamos que tenemos una clase que representa un botón de acción en un entorno gráfico de usuario (el típico botón de confirmación de una acción o de cancelación). Esta clase pertenecerá a una amplia jerarquía de clases y tendrá mecanismos complejos de definición y uso que no son objeto del ejemplo. Sin embargo podríamos pensar que  la clase Boton tiene miembros como los siguientes.

class Boton extends . . . {    protected int x , y, ancho, alto; // posicion del boton    protected String texto;  // texto del boton    Boton(. . .) {        . . .    }    void dibujar() { . . .}    public void asignarTexto(String t) { . . .}    public StringobtenerTexto() { . . .)    . . .}   

Lo que aquí nos interesa es ver lo que sucede cuando el usuario, utilizando el ratón pulsa sobre el botón. Supongamos que la clase Boton tiene un método, de nombre por ejemplo click(), que es invocado por el gestor de ventanas cuando ha detectado que el usuario ha pulsado el botón del ratón sobre él. El botón deberá realizar alguna acción como dibujarse en posición 'pulsado' (si tiene efectos de tres dimensiones) y además, probablemente, querrá informar a alguien de que se ha producido la acción del usuario. Es en este mecanismo de 'notificación' donde entra el concepto de interface. Para ello definimos una interface Oyente de la siguiente forma:

interface Oyente {    voidbotonPulsado(Boton b);}

La interface define un único método botonPulsado. La idea es que este método sea invocado por la clase Boton cuando el usuario pulse el botón. Para que esto sea posible en algún momento hay que notificar al Boton quien es el Oyente que debe ser notificado. La clase Boton quedaría:

class Boton extends . . . {    . . .    private Oyente oyente;

    void registrarOyente(Oyente o) {        oyente = o;    }    void click() {        . . .        oyente.botonPulsado(this);    }}

El método registrarOyente sirve para que alguien pueda 'apuntarse' como receptor de las acciones del usuario. Obsérvese que existe una referencia de tipo Oyente. A Boton no le importa que clase va a recibir su notificación. Simplemente le importa que implante la interface Oyente para poder invocar el método botonPulsado. En el método click se invoca este método. En el ejemplo se le pasa como parámetro una referencia al propio objeto Boton. En la realidad lo que se pasa es un objeto 'Evento' con información detallada de lo que ha ocurrido.

Con todo esto la clase que utiliza este mecanismo podría tener el siguiente aspecto:

class miAplicacion extends . . . implements Oyente {    public static main(String [] args) {        new miAplicacion(. . .);         . . .    }     . . .     miAplicacion(. . .) {        . . .        Boton b = new Boton(. . .);        b.registrarOyente(this);    }

    . . .    void botonPulsado(Boton x) {        // procesar click        . . .    }}

Obsérvese en el método registrarOyente que se pasa la referencia thisque en el lado de la clase Boton es recogido como una referencia

a la interface Oyente. Esto es posible porque la clasemiAplicacion implementa la interface Oyente . En términos clásicos de herencia miAplicacion ES un Oyente .

Interfaces en JavaUna interfaz en java es un conjunto de métodos abstractos y propiedades. En ellas se especifica qué se debe hacer pero no su

implementación. Serán las clases que implementen estas interfaces las que describan la lógica del comportamiento de los

métodos.

Ventajas al utilizar interfaces: Se organiza la programación.

Obligar a que ciertas clases utilicen los mismos métodos (nombres y parámetros).

Establecer relaciones entre clases que no estén relacionadas.Cómo usarlas?

Java utiliza dos palabras reservadas para trabajar con interfaces que son interface e implements.

Para declarar una interfaz se debe seguir el siguiente orden:

modificador_accesointerfaceNombreInterfaz 

{código de interfaz}

El modificador de acceso permitido dentro de una interfaz es public o puede no existir. Los atributos que definamos en el cuerpo de la interfaz serán atributos de tipo constante en las clases en las que se implemente.

Para implementar una interfaz en una clase se debe seguir el siguiente orden:modificador_accesoNombreClaseimplements NombreInterfaz1 [, NombreInterfaz2]

NOTA: Una clase puede implementar varias interfaces, separando los nombres por comas.Ejemplo:Definición de una interfaz:interface Nave {publicstatic final int VIDA = 100;

publicabstractvoidmoverPosicion (int x, int y);publicabstractvoid disparar(); ..... }

Uso de la interfaz definida:publicclassNaveJugadorimplements Nave {publicvoidmoverPosicion (int x, int y)

{ //Implementación del método }publicvoid disparar() { //Implementación del método } ..... }En resumen los métodos forman la interfaz del objeto con el mundo exterior, un ejemplo, los botones en el frente del televisor, son la interfaz entre el usuario y el cableado eléctrico en el otro lado de la carcasa de plástico. Presiona el botón "POWER" para encender o apagar el televisor.En su forma más común, una interfaz es un grupo de métodos relacionados con cuerpos vacíos. El comportamiento de una bicicleta, si se especifica como una interfaz, podría aparecer como sigue:interface Bicicleta{voidchangeCadence(intnewValue); // Revoluciones de la rueda por minutovoidchangeGear(intnewValue);voidspeedUp(intincrement);voidapplyBrakes(intdecrement);}Para implementar esta interfaz, el nombre de la clase debe cambiar (a una marca concreta de la bicicleta, por ejemplo, como ACMEBicycle), y tendrá que utilizar la palabra clave implements en la declaración de la clase:ACMEBicycle clase implementsBicicleta (// resto de esta clase implementada como antes)

Al implementar una interfaz esto permite que la clase se vuelva más formal sobre el comportamiento que se compromete a proporcionar. Para crea una interfaz:

http://4.bp.blogspot.com/_FLFvTrRosn0/S8P5eaOd6pI/AAAAAAAAAF8/HE_Y1FvD29E/s1600/New+Interface.png

Interfaz (Java)Una interfaz en Java es una colección de métodos abstractos y propiedades. En ellas se especifica qué

se debe hacer pero no su implementación. Serán las clases que implementen estas interfaces las que

describan la lógica del comportamiento de los métodos.

La principal diferencia entre interface y abstract es que un interface proporciona un mecanismo de

encapsulación de los protocolos de los métodos sin forzar al usuario a utilizar la herencia.

Índice

  [ocultar] 

1   Ventajas

2   Uso

o 2.1   Ejemplo

3   Enlaces externos

Ventajas[editar]

El uso de interfaces proporciona las siguientes ventajas:

Organizar la programación.

Obligar a que ciertas clases utilicen los mismos métodos (nombres y parámetros).

Establecer relaciones entre clases que no estén relacionadas.

Uso[editar]

Java proporciona dos palabras reservadas para trabajar con interfaces: interface e implements.

Para declarar una interfaz se utiliza:

modificador_accesointerfaceNombreInterfaz{

....

}

modificador_acceso puede ser una clase de objetos que nos permite utilizar herencian en abstraccionpo

constante en las clases en las que se implemente.

Para implementarla en una clase, se utiliza la forma:

modificador_accesoclassNombreClaseimplements NombreInterfaz1 [,

NombreInterfaz2]

Una clase puede implementar varias interfaces de los paquetes que se han importado dentro del

programa, separando los nombres por comas.

Ejemplo[editar]

Definición de una interfaz:

interface Nave {

publicvoidmoverPosicion(int x, int y);

publicvoid disparar();

.....

}

Uso de la interfaz definida:

publicclassNaveJugadorimplements Nave {

publicvoidmoverPosicion(int x, int y){

//Implementación del método

posAcutalx=posAcutalx-x;

posAcutaly=posAcutaly-y;

}

publicvoid disparar(){

//Implementación del método

}

...

}

Interfaces

Anterior | Siguiente

Los métodos abstractos son útiles cuando se quiere que cada implementación de la clase parezca y funcione igual, pero se necesita crear una nueva clase para utilizar los métodos abstractos. Las interfaces proporcionan un mecanismo para abstraer los métodos a un nivel superior, lo que permite simular la herencia múltiple de otros lenguajes.

Una interfaz sublima el concepto de clase abstracta hasta su grado más alto. Una interfaz podrá verse simplemente como una forma, parecido a un molde, solamente permite declarar nombres de métodos, listas de argumentos, tipos de retorno y adicionalmente miembros datos (los cuales podrán ser únicamente tipos básicos y serán tomados como constantes en tiempo de compilación). A pesar de que las constantes se definen como campos, son implícitamente public,  stat ic  y final .

Una interfaz contiene una colección de métodos que se implementan en otro lugar. Siendo estos métodos implícitamente abstract  y public .

Las dos diferencias principales entre las interfaces y las clases abstractas son:

Las interfaces proporcionan una forma de herencia múltiple, ya que pueden implementar múltiples interfaces. Una clase sólo puede extender a otra clase, incluso aunque esa clase sólo tenga métodos abstract .

Una clase abstract  puede tener una implementación parcial, partes protegidas, métodos estáticos, etc., mientras que las interfaces están limitadas a constantes públicas y métodos públicos sin implementación

La principal diferencia entre interface y abstract es que una interfaz proporciona un mecanismo de encapsulación de los protocolos de los métodos sin forzar al usuario a utilizar la herencia. Por ejemplo:

public interface VideoClip { // comienza la reproduccion del videovoidplay(); // reproduce el clip en un buclevoid bucle(); // detiene la reproduccionvoid stop();}

Las clases que quieran utilizar la interfaz VideoClip utilizarán la palabra implements  y proporcionarán el código necesario para implementar los métodos que se han definido para la interfaz:

classMiClaseimplementsVideoClip {voidplay() {<código> }void bucle() {<código> }

void stop() {<código> }}

Al utilizar implements  para la interface es parecido a la acción de copiar-y-pegar del código de la interface, con lo cual no se hereda nada, solamente se pueden usar los métodos.

La ventaja principal del uso de interfaces es que la interface puede ser implementada por cualquier número de clases, permitiendo a cada clase compartir la interfaz de programación sin tener que ser consciente de la implementación que hagan las otras clases que implementen la interface.

classMiOtraClaseimplementsVideoClip {voidplay() {<código nuevo> }void bucle() {<código nuevo> }void stop() {<código nuevo> }}

Es decir, el aspecto más importante del uso de interfaces es que múltiples objetos de clases diferentes pueden ser tratados como si fuesen de un mismo tipo común, donde este tipo viene indicado por el nombre de la interfaz.

Aunque se puede considerar el nombre de la interfaz como un tipo de prototipo de referencia a objetos, no se pueden instanciar objetos en sí del tipo interfaz. En la definición de una interfaz no se tienen constructores, por lo que no es posible invocar el operador new  sobre un tipo interfaz.

Una interfaz puede heredar de varias interfaces sin ningún problema. Sin embargo, una clase solamente puede heredar de una clase base, pero puede implementar varias interfaces. La plataforma Java 2 ofrece la posibilidad de definir una interfaz vacía, como es el caso de Serialize, que permite serializar un objeto. Una interfaz vacía se puede utilizar como un marcador para señalar a una clase con una propiedad determinada.

La aplicación java514.java, ilustra algunos de los conceptos referentes a las interfaces. Se definen dos interfaces, en una de ellas se definen dos constantes y en la otra se declara un método put() y un métodoget(). Las constantes y los métodos se podrían haber colocado en la misma definición de la interfaz, pero se han separado para mostrar que una clase simple puede implementar dos o más interfaces utilizando el separador coma (,) en la lista de interfaces.

También se definen dos clases, implementando cada una de ellas las dos interfaces. Esto significa que cada clase define el método put() y el método get(), declarados en una interfaz y hacen uso de las constantes definidas en la otra interfaz. Estas clase se encuentran en ficheros separados por exigencias del compilador, los ficheros son Constantes.java y MiInterfaz.java, y el contenido de ambos ficheros es el que se muestra a continuación:

public interface Constantes {

public final double pi = 6.14;public final intconstanteInt = 125;}

public interface MiInterfaz {voidput( int dato );intget();}

Es importante observar que en la definición de los dos métodos de la interfaz, cada clase los define de la forma más adecuada para esa clase, sin tener en cuenta cómo estará definidos en las otras clases.

Una de las clases también define el método show(), que no está declarado en la interfaz. Este método se utiliza para demostrar que un método que no está declarado en la interfaz no puede ser accedido utilizando una variable de referencia de tipo interfaz.

El método main() en la clase principal ejecuta una serie de instanciaciones, invocaciones de métodos y asignaciones destinadas a mostrar las características de las interfaces descritas anteriormente. Si se ejecuta la aplicación, las sentencias que se van imprimiendo en pantalla son autoexplicactivas de lo que está sucediendo en el corazón de la aplicación.

classClaseAimplements Constantes, MiInterfaz {doubledDato;

// Define las versiones de put() y get() que utiliza la ClaseApublicvoidput( int dato ) { // Se usa "pi" de la interfaz ConstantesdDato = (double)dato * pi;System.out.println( "En put() de ClaseA, usando pi de la interfaz Constantes: " + dDato ); }

publicintget() {return( (int)dDato ); }

// Se define un metodo show() para la ClaseA que no esta declarado // en el interfaz MiInterfazvoid show() {System.out.println( "En show() de ClaseA, dDato = " + dDato ); }}

classClaseBimplementsConstantes,MiInterfaz {intdDato;

// Define las versiones de put() y get() que utiliza la ClaseBpublicvoidput( int dato ) { // Se usa "constanteInt" del interfaz ConstantesdDato = dato * constanteInt;System.out.println(

"En put() de ClaseB, usando constanteInt del interfaz Constantes: " + dDato ); }

publicintget() {return( dDato ); }}

class java514 {publicstaticvoidmain( Stringargs[] ) {System.out.println( "Instancia objA de tipo ClaseA, mete datos y los muestra." );ClaseAobjA = new ClaseA();objA.put( 2 );objA.show();

System.out.println( "\nAsignaobjA a la variable de referencia de tipo " + "MiInterfaz llamada objAA." );MiInterfazobjAA = objA;System.out.println( "Invoca el metodoput() sobre objAA para modificar los datos.");objAA.put( 4 );System.out.println( "Invoca el metodoget() sobre objAA para ver los datos modificados.");System.out.println("dato objA = " + objAA.get() );

System.out.println( "\nInstancia un objeto de tipo ClaseB llamado objB.\n" + "Asigna inmediatamente la refrencia a una variable de referecia " + " de tipo MiInterfaz\n en lugar de a una variable de tipo ClaseB" );MiInterfazobjB = new ClaseB();System.out.println( "Invoca a su metodoput() para guardar datos." );objB.put(11);System.out.println( "Invoca su metodoget() para visualizar los datos." );System.out.println( "dato objB = " + objB.get() );

System.out.println( "\nAsigna correctamente objA a objB y muestra objB" );objB = objA;System.out.println( "dato objB = " + objB.get() );

System.out.println( "\nInvoca el metodoput() sobre objAA para modificar sus datos.");objAA.put( 16 );System.out.println( "Asigna correctamente objAA a objB y muestra objB" );objB = objAA;System.out.println( "dato objB = " + objB.get() );

System.out.println(

"\nRestaura a objB su tipo y valor iniciales." ); // objB ya esta definido como tipo MiInterfazobjB = new ClaseB();objB.put( 11 );System.out.println( "Asigna correctamente objB a objAA y muestra objAA" );objAA = objB;System.out.println( "dato objAA = " + objAA.get() );

System.out.println( "\nIntenta asignar objB a objA y falla porque se necesita " + "un \n\"Moldeado especifico que convierta MiInterfaz a ClaseA\"." ); // objA = objB; // Comentado para poder ejecutar

System.out.println( "\nIntenta invocar el metodo show() de objAA y falla porque" + "\n\"El metodo show() no esta declarado en el " + "interfaz MiInterfaz\"." ); // objAA.show(); // Comentado para poder ejecutar

System.out.println("Fin del programa."); }}

Las interfaces son útiles para recoger las similitudes entre clases no relacionadas, forzando una relación entre ellas. También para declarar métodos que forzosamente una o más clases han de implementar. Y también, para tener acceso a un objeto permitiendo el uso de un objeto sin revelar su clase, son los llamados objetos anónimos, que son muy útiles cuando se vende un paquete de clases a otros desarrolladores.

En algunos lenguajes del tipo OOP permiten al programador crear nuevas clases como una subclase de dos o más superclases diferentes, como en C++, lo anterior se conoce como herencia múltiple. En Java no se permite herencia múltiple. Hay autores que dicen que la interfaz de Java es un sustituto de la herencia múltiple y hay otros que están en desacuerdo con eso. Lo cierto es que sí parece una alternativa y las interfaces resuelven algunos de los problemas de la herencia múltiple, por ejemplo:

No se pueden heredar variables desde una interfaz. No se pueden heredar implementaciones de métodos desde una interfaz. La jerarquía de una interfaz es independiente de la jerarquía de clases que implementen la misma

interfaz.

Definición

La definición de una interfaz es semejante a la de una clase. La definición de interfaz tiene dos componentes, declaración y cuerpo. En forma esquemática sería:

DeclaracionInterfaz { // cuerpoInterfaz}

Declaración

La mínima declaración consiste en la palabra clave interface  y el nombre de la interfaz. Por convenio, los nombres de interfaces comienzan con una letra mayúscula, como los nombres de las clases, pero no es obligatorio.

La declaración de la interfaz puede tener dos componentes adicionales, el especificador de accesopublic  y la lista de superinterfaces.

Una interfaz puede extender otras interfaces. Sin embargo, mientras que una clase solamente puede extender otra clase, una interfaz puede extender cualquier número de interfaces. En el ejemplo se muestra la definición completa de una interfaz, declaración y cuerpo.

public interface MiInterfazextendsInterfazA, InterfazB {public final double PI = 3.14159;public final int entero = 125;voidput( int dato );intget();}

El especificador de acceso public  indica que la interfaz puede ser utilizado por cualquier clase de cualquier paquete. Si se omite, la interfaz solamente será accesible a aquellas clases que estén definidas en el mismo paquete.

La cláusula extends  es similar a la de la declaración de clase, aunque una interfaz puede extender múltiples interfaces. Una interfaz no puede extender clases.

La lista de superinterfaces es un lista separada por comas de todas las interfaces que la nueva interfaz va a extender. Una interfaz hereda todas las constantes y métodos de sus superinterfaces, excepto si la interfaz oculta una constante con otra del mismo nombre, o si redeclara un método con una nueva declaración de ese método.

El cuerpo de la interfaz contiene las declaraciones de los métodos, que terminan en un punto y coma y no contienen código alguno en su cuerpo. Todos los métodos declarados en una interfaz son implícitamente, public  y abstract , y no se permite el uso de transient , volati le , private , protected  osyncronized  en la declaración de miembros en una interfaz. En el cuerpo de la interfaz se pueden definir constantes, que serán implícitamente public , static  y final .

Implementación

Una interfaz se utiliza definiendo una clase que implemente la interfaz a través de su nombre. Cuando una clase implementa una interfaz, debe proporcionar la definición completa de todos los métodos declarados en la interfaz y, también, la de todos los métodos declarados en todos los superinterfaces de esa interfaz.

Una clase puede implementar más de una interfaz, incluyendo varios nombre de interfaces separados por comas. En este caso, la clase debe proporcionar la definición completa de todos los métodos

declarados en todos las interfaces de la lista y de todos los superinterfaces de esos interfaces.

En el ejemplo anterior, java514.java, se puede observar una clase que implementa dos interfaces,Constantes  y MiInterfaz .

classClaseAimplements Constantes, MiInterfaz {doubledDato;

// Define las versiones de put() y get() que utiliza la ClaseApublicvoidput( int dato ) { // Se usa "pi" de la interfaz ConstantesdDato = (double)dato * pi;System.out.println( "En put() de ClaseA, usando pi del interfaz Constantes: " + dDato ); }

publicintget() {return( (int)dDato ); }

// Se define un metodo show() para la ClaseA que no esta declarado // en el interfaz MiInterfazvoid show() {System.out.println( "En show() de ClaseA, dDato = " + dDato ); }}

Como se puede observar, esta clase proporciona la definición completa de los métodos put() y get() de la interfaz MiInterfaz , a la vez que utiliza las constantes definidas en la interfaz Constantes . Además, la clase proporciona la definición del método show() que no está declarado en ninguno de los interfaces, sino que es propio de la clase.

La definición de una interfaz es una definición de un nuevo tipo de datos. Se puede utilizar el nombre de la interfaz en cualquier lugar en que se pueda utilizar un nombre de tipo de dato. Sin embargo, no se pueden instanciar objetos del tipo interfaz, porque una interfaz no tiene constructor. En esta sección, hay numerosos ejemplos de uso del nombre de una interfaz como tipo.