Interfaces. Introducción La unidad fundamental en el lenguaje de programación Java es la clase, pero la unidad fundamental del diseño orientado a objetos

Interfaces

Introducción

La unidad fundamental en el lenguaje de programación Java es la clase, pero la unidad fundamental del diseño orientado a objetos es el tipo.

Aunque las clases definen tipos, es muy útil y potente poder definir un tipo sin definir una clase

Introducción Las interfaces definen tipos de un modo

abstracto en forma de una colección de métodos o de otros tipos que forman el contrato del tipo definido.

Las interfaces no contienen implementación y, no pueden crearse instancias (si definir referencias) de una interfaz. Más bien son las clases las que pueden expandir sus propios tipos implementando una o más interfaces

Introducción Una interfaz es una expresión de diseño

puro, mientras que una clase es una mezcla de diseño e implementación

Una clase puede implementar los métodos de una interfaz de cualquier forma que escoja el diseñador de la clase. Por tanto una interfaz tiene muchas más implementaciones posibles que una clase. Toda clase principal en una aplicación debería ser una implementación de alguna interfaz que contenga el contrato de la clase

Introducción Las clases pueden implementar más de una

interfaz. Java permite herencia múltiple de interfaces, pero sólo herencia simple de implementación: una clase sólo puede extender a una sola clase.

Las clases pueden usar herencia de interfaces para expandir su tipo y usar luego, por ejemplo, composición para proporcionar una implementación de esas interfaces. Este diseño permite la flexibilidad de la herencia múltiple, pero evita los peligros de la herencia múltiple de implementación, a costa de un trabajo adicional para el programador

Introducción Dada una clase, las clases que son

extendidas y las interfaces que son implementadas se denominan colectivamente supertipos, y desde el punto de vista de los supertipos, la nueva clase es un subtipo.

La nueva clase incluye a todos sus supertipos, por lo que una referencia a un objeto del subtipo puede usarse polimórficamente en cualquier parte donde se requiera una referencia a cualquiera de sus supertipos (clases e interfaces)

Introducción

Las declaraciones de interface crean nombres de tipos, de la misma forma que las clases. Se puede usar el nombre de la interfaz como el nombre del tipo de una variable y cualquier objeto cuya clase implemente esa interfaz se puede asignar a esa variable

Un ejemplo simple de interfaz

Muchas interfaces simples definen una propiedad que puede adscribirse a una variedad de diferentes objetos de diferentes clases. Estas propiedades se definen, a menudo, en términos de que un objeto es “capaz” de hacer algo.

Un ejemplo simple de interfaz En los paquetes estándar hay diversas

interfaces de “capacidades” como: Comparable: los objetos de este tipo tienen

una ordenación que permite compararlos Serializable: los objetos de este tipo se

pueden pasar a una cadena de bytes de objetos para enviarlos a una nueva máquina virtual o almacenarlos permanentemente y reconstruirlos después como un objeto vivo


Cloneable: los objetos de este tipo admiten la clonación

La interfaz Comparable puede ser implementada por cualquier clase cuyos objetos se pueden comparar entre sí basándose en una “ordenación natural” de la clase


La interfaz contiene un solo método y se declara así:

public interface Comparable{ int compareTo (Object o);

}

Un ejemplo simple de interfaz La declaración de una interfaz es muy

semejante a la declaración de una clase, excepto que se usa la palabra clave interface en vez de class.

Hay también reglas especiales sobre los miembros de una interface

El método compareTo toma como parámetro un solo objeto y lo compara con el objeto actual, devolviendo un entero negativo, 0 o positivo si el objeto actual es menor, igual o mayor que el parámetro, respectivamente. Si los 2 objetos no son mutuamente comparables (lo que significa generalmente que tienen tipos incompatibles) se lanza una excepción ClassCastException

Un ejemplo simple de interfazpublic class PersonaPorEdad implements Comparable {String nombre;//suponer que hay métodos de accesoint edad;PersonaPorEdad(String nombre, int edad) {this.nombre = nombre;this.edad = edad;}public int compareTo(Object p) {if(edad < ( (PersonaPorEdad) p).edad)return -1;else if ( edad > ((PersonaPorEdad) p).edad )return 0;else return 1;}}


Primero declaramos que PersonaPorEdad es una clase Comparable. Una clase identifica los tipos de interface que implementa poniéndolos en una lista tras la palabra clave implements, antes de que se defina el cuerpo de la clase (y después de cualquier cláusula extends)


Todas esas interfaces son las superinterfaces de la clase. La clase debe proporcionar una implementación de todos los métodos definidos en sus superinterfaces, o bien debe declararlos abstract, requiriendo así que una subclase no abstracta los implemente


En el ejemplo, como en la mayoría de las implementaciones de compareTo, hemos utilizado un operador de conversión de tipo, para transformar la referencia genérica a Object en una referencia específica a PersonaPorEdad antes de realizar la comparación real

Un ejemplo simple de interfaz Si el parámetro que se pasa no fuese de

hecho un objeto PersonaPorEdad, la transformación de tipos produciría una excepción ClassCastException.

Las interfaces producen nombres de tipos en la misma forma que las clases, por lo que se pueden declarar variables de esos tipos. Ejemplo: Comparable obj;

Un ejemplo simple de interfaz De hecho, una buena parte de la

potencia de las interfaces radica en la declaración y utilización de variables de tipo interfaz en vez de variables del tipo de alguna clase específica. Por ejemplo, se puede definir una rutina genérica para ordenar un array de objetos Comparable (suponiendo que los objetos son compatibles), sin que importe la clase real de objetos

Un ejemplo simple de interfazpublic class BubbleSort{

// ordena ascendente

static Comparable[] sort( Comparable[] lista ) {

Comparable[] o = lista.clone();

for(int i=0; i<o.length-1;i++) {

for(int j=i;j<o.length;j++) {

if( o[i].compareTo(o[j]) > 0 ) {

Comparable tmp = o[j];

o[j] = o[i];

o[i] = tmp;}}}

return o;}}

Un ejemplo simple de interfaz Las referencias a tipo de interfaz, sin embargo,

sólo se pueden utilizar para acceder a los miembros de la interfaz. Por ejemplo el siguiente código producirá un error de compilación:

Comparable obj=new PersonaPorEdad(“AK”, 56);

String nombre=obj.getNombre(); //error: Comparable no tiene método getNombre()

Un ejemplo simple de interfaz Si deseamos tratar a obj como un

objeto PersonaPorEdad debemos convertirlo explícitamente a un objeto de ese tipo. La excepción a esta regla es que podemos tratar cualquier referencia a una interfaz como una referencia a Object, porque el objeto referido deberá ser de alguna clase, y todas las clases extienden a Object.


Por tanto, lo siguiente es legal: String desc=obj.toString(); Estamos asignando una referencia

a una interfaz a una referencia a un Object

Declaraciones de interface Las interfaces se declaran mediante la

palabra clave interface, dando a la interfaz un nombre y proporcionando una lista de los miembros de la interfaz entre llaves

Una interfaz puede declarar como miembro, entre otros: Constantes (campos) Métodos

Declaraciones de interface

Todos los miembros de una interfaz son implícitamente públicos pero por convención, se omite el modificador public. Tener miembros no públicos en una interfaz tendría poco sentido y, allí donde tuviese sentido se podría usar el control de acceso a la propia interfaz para controlar el acceso a sus miembros

Constantes de interfaz Una interfaz puede declarar constantes

con nombre. Estas constantes se definen como campos pero son implícitamente public static final. De nuevo, por convención se omiten estos modificadores en las declaraciones de estos campos. Estos campos deben tener también inicializadores (los finales en blanco no están permitidos9

Constantes de interfaz Como las interfaces no contienen

detalles de implementación, no pueden definir campos normales, ya que esa definición estaría dictando una política de implementación a las clases que eligieran implementar la interfaz

Las interfaces pueden definir constantes con nombre porque resultan de utilidad en el diseño de tipos.

Métodos de interfaz Los métodos que se declaran en una

interfaz son implícitamente abstract, ya que no se puede dar una implementación para los mismos. Por este motivo el cuerpo del método se especifica como un ; tras la cabecera del método. Por convención en la declaración del método se omite el modificador abstract

Métodos de interfaz En la declaración de un método de interfaz no

se permiten otros modificadores de métodos. Son implícitamente public y, por tanto, no pueden tener ningún otro modificador de acceso.

No pueden ser final ya que no se han implementado todavía ni pueden ser static ya que los métodos static no pueden ser abstract. Por supuesto, la implementación de esos métodos en una clase específica puede incorporar los modificadores que sean apropiados

Modificadores de interfaz Una declaración de interfaz puede ir

precedida por modificadores de interfaz, entre otros: public: una interfaz public es accesible

públicamente. Sin este modificador una interfaz sería accesible sólo desde su propio paquete

abstract: todas las interfaces son implícitamente abstract porque todos sus métodos son abstract. No tienen implementación. De nuevo por convención el modificador abstract se omite

Extensión de interfaces Las interfaces se pueden extender

usando la palabra clave extends. A diferencia de las clases, las interfaces pueden extender más de una interfaz:

public interface SerializableComparable extends java.io.Serializable, Comparable

{ //…. }

Extensión de interfaces La interfaz SerializableComparable

extiende a java.io.Serializable y a Comparable, lo que significa que todos los métodos y constantes definidos por esas interfaces son ahora parte del contrato de SerializableComparable junto con los nuevos métodos y constantes que ella defina.

Las interfaces que son extendidas son superinterfaces de la nueva interfaz y esta última es una subinterfaz de sus superinterfaces

Extensión de interfaces Como las interfaces admiten herencia

múltiple, el árbol de herencias puede contener múltiples caminos que llevan a la misma superinterfaz. Esto quiere decir que las constantes y los métodos pueden se accedidos de diferentes maneras

Sin embargo, como las interfaces no definen la implementación de los métodos, y no proporcionan campos de objetos, no se presentan problemas respecto a la semántica de esta forma de herencia múltiple

Herencia y ocultación de constantes

Una interfaz extendida hereda todas las constantes declaradas en sus superinterfaces. Si una interfaz declara una constante del mismo nombre que una constante heredada independientemente de sus tipos, la nueva constante oculta a la heredada (mismo concepto visto en herencia)

Herencia y ocultación de constantes En la subinterfaz y en cualquier objeto

que implemente a la subinterfaz, cualquier referencia a la constante usando su nombre simple se referirá a la constante definida en la subinterfaz

La constante heredada puede todavía ser accedida usando su nombre calificado, es decir, el nombre de la interfaz seguido por un punto y el nombre de la constante, forma usual de referirse a miembros estáticos


interface X{

int val=1;

}

interface Y extends X{

int val=2;

int sum=val + X.val;

}

Herencia y ocultación de constantes La interfaz Y tiene 2 constantes: val y sum. Para referirnos a val de X, oculto desde el interior de Y, debemos calificarlo como X.val. Podemos acceder externamente a las constantes de Y usando las formas estáticas normales Y.val y Y.sum y, por supuesto, se puede acceder a val de X usando X.val


Estas reglas son, por supuesto, idénticas a las que se refieren a la herencia de los campos estáticos en las clases

Cuando una clase implementa a Y, puede acceder a sus constantes como si fuesen constantes declaradas en la propia clase.

Herencia y ocultación de constantes Por ejemplo, dada la declaración class Z implements Y {} Podemos hacer: System.out.println(“Z.val=“+ Z.val + “ ; Z.sum=“ + Z.sum);

Pero no hay forma de referirse a X.val vía Z. Sin embargo, dada una instancia de Z podemos usar una conversión explícita de tipo para acceder a X.val:

Herencia y ocultación de constantes Z z=new Z(); System.out.println(“z.val=“+ z.val + “, ((Y)z).val=“ + ((Y)z).val + “, ((X)z).val=“ + ((X)z).val);

Que imprimiría z.val=2, ((Y)z).val=2, ((X)z).val=1

Herencia y ocultación de constantes Son las mismas reglas que se aplican a

campos estáticos en las clases extendidas. No importa si una clase hereda un campo estático de una superclase o de una superinterfaz

Aunque todas estas reglas son necesarias desde el punto de vista del lenguaje, tienen pocas consecuencias prácticas. Hay pocas razones para ocultar campos existentes y todos los accesos a campos estáticos, sean de clase o interfaz


Si una interfaz hereda dos o más constantes con el mismo nombre, cualquier referencia simple a una constante resultará ambigua y producirá un error de compilación

Ejemplo: dadas las anteriores declaraciones de interfaces y el siguiente código:

Herencia y ocultación de constantes interface C {

String val=“Interface C”;

}

interface D extends X, C{ } La expresión D.val es ambigua ¿significa

el entero val o la referencia a String.val?En el interior de D tenemos que usar explícitamente X.val o C.val

Herencia y ocultación de constantes Una clase que implemente más de una interfaz

o que extienda a una clase que implemente una o más interfaces, puede experimentar los mismos problemas de ocultación y ambigüedad que una interfaz que extienda a más de una interfaz. Los propios campos estáticos de la clase pueden ocultar a los campos heredados de las interfaces que implementen o de la clase que extiende y las referencias simples a campos no ocultos múltiplemente heredados serán ambigüas

Herencia, redefinición y sobrecarga de métodos Una subinterfaz hereda todos los

métodos declarados en sus superinterfaces. Si un método declarado en una subinterfaz tiene la misma signatura (nombre y lista de parámetros) que un método heredado y el mismo tipo de retorno, la nueva declaración redefine cualquier otra declaración existente.

Herencia, redefinición y sobrecarga de métodos

La redefinición en interfaces, a diferencia de la redefinición en clases, no tiene efectos semánticos: la interfaz contiene efectivamente múltiples declaraciones del mismo método, pero en cualquier implementación que haga una clase sólo habrá una implementación de ese método

Herencia, redefinición y sobrecarga de métodos De forma similar, si una interfaz hereda

más de un método con la misma signatura o una clase implementa diferentes interfaces que contienen un método con la misma signatura, al final sólo existirá un método, cuya implementación será definida en última instancia por la clase que implementa las interfaces. En este caso no existe ninguna posible ambigüedad


La cuestión real es si una sola implementación de un método puede cumplir todos los contratos implicados por el hecho de que ese método es parte de diferentes interfaces. Esto puede ser un requerimiento imposible de satisfacer en algunas circunstancias


interface Recepcion{

void estimar(); //selección de //personas apreciadas

void invitar();//selección de personas

//a invitar

void prohibir();//selección de personas

//no gratas

}

Herencia, redefinición y sobrecarga de métodosinterface ReservaPuestos{ void estimar();//estima posibles //asistentes por defecto

void estimar(Local l);//estima posibles //asistentes a un local void reserva(int puestos); void comida (Menu m); } interface ReservaPuestosRecepción extens Recepcion, ReservaPuestos{}

Herencia, redefinición y sobrecarga de métodos En este ejemplo puede ser difícil escribir

una implementación de estimar() que pueda satisfacer independientemente de los 2 contratos simultáneamente. Si intentamos cumplirlos simultáneamente, es improbable que obtengamos los resultados deseados, pudiendo por ejemplo confundir asistentes por defecto con personas apreciadas


Si un método declarado tiene el mismo nombre que un método heredado pero diferentes parámetros, el método declarado es una forma sobrecargada del método heredado. Una eventual implementación en una clase deberá proporcionar un cuerpo de método para cada una de las formas sobrecargadas.


Si un método declarado sólo se diferencia de un método heredado en el tipo de retorno, o si dos métodos heredados se diferencian sólo en el tipo de retorno, se produce un error

Interfaces marcadoras

Algunas interfaces no declaran métodos sino que implementan marcan que una clase tiene alguna propiedad general.

La interfaz Cloneable es un ejemplo de ello, no tiene métodos ni constantes, sino que marca que una clase toma parte en el mecanismo de clonación


Las interfaces marcadoras son el caso degenerado de un contrato ya que no define comportamiento al nivel de lenguaje: ni métodos ni valores. Todo el contrato está en la documentación que describe las esperanzas que deseamos satisfacer con la implementación de nuestra clase


Las interfaces marcadoras pueden tener un profundo impacto en el compartimiento de las clases que las implementan.

No nos equivoquemos pensando que no son importantes simplemente porque no tienen métodos

Documents

Interfaces. Introducción La unidad fundamental en el lenguaje de programación Java es la clase, pero la unidad fundamental del diseño orientado a objetos