S?bado, 25 de octubre de 2014

Fuente:

http://docs.oracle.com/javase/tutorial/java/IandI/interfaceDef.html

Los tutoriales de Java.

¿Qué es una interface?

Como previamente has aprendido, los objetos definen su interacción con el mundo exterior por medio de los métodos que ellos exponen. Los métodos forman la interfaz del mundo real; el conjunto de botones frente al televisor, son la interfaz entre usted y el cableado eléctrico en el otro lado de su carcasa plástica. Al presionar el botón de “encendido” el televisor se enciende y se apaga.

En su forma más común, una interfaz es un grupo de métodos relacionados sin escritura de código. Un comportamiento de una bicicleta, si se especifica como una interfaz, debe de escribirse de la siguiente manera:

interface Bicycle {

// wheel revolutions per minute

void changeCadence(int newValue);

void changeGear(int newValue);

void speedUp(int increment);

void applyBrakes(int decrement);

}

Para implementar esta interfaz, el nombre de tu clase debería de cambiar (a una marca en particular de bicicleta, por ejemplo ACMEBicycle) y deberías de usar la palabra reservada implements en la declaración de la clase:

class ACMEBicycle implements Bicycle {

int cadence = 0;

int speed = 0;

int gear = 1;

// El compilador ahora requerirá que los métodos

// changeCadence, changeGear, speedUp, and applyBrakes

// all be implemented. Compilation will fail if those

// methods are missing from this class.

void changeCadence(int newValue) {

       cadence = newValue;

}

void changeGear(int newValue) {

      gear = newValue;

}

void speedUp(int increment) {

     speed = speed + increment;

}

void applyBrakes(int decrement) {

    speed = speed - decrement;

}

void printStates() {

      System.out.println("cadence:" +

      cadence + " speed:" +

      speed + " gear:" + gear);

}

}

Implementando una interfaz permite a una clase darle formalidad sobre la funcionalidad que se compromete a proporcionar. La forma de las interfaces es un contrato entre la clase y el mundo exterior, y este contrato esta obligado en tiempo de construcción por el compilador. Si tu clase demanda implementar una interface, todos los métodos definidos por la interfaz deben aparecer en su código fuente antes de que la clase sea compilada exitosamente.

Definiendo una interface

Una declaración de una interfaz consiste de modificadores, la palabra reservada interface, el nombre de la interfaz, una lista separada por comas de interfaces padre (si las hay), y el “cuerpo” de la interfaz. Por ejemplo:

public interface GroupedInterface extends Interface1, Interface2, Interface3 {

// declaración de constantes

// Base de los logaritmos naturales

double E = 2.718282;

// firma de métodos

void doSomething (int i, double x);

      int doSomethingElse(String s);

}

El modificador de acceso public indica que la interfaz puede ser usada por alguna clase de cualquier paquete. Si no especificas que la clase es pública (public), entonces tu interfaz es solo accesible para las clases en el mismo paquete de la interface.

Una interfaz puede extender (heredar) otras interfaces, al igual que una sub-clase o otra clase heredada. Aunque, mientras que una clase puede heredar solo de una clase, una interfaz puede heredar de varias interfaces. La declaración de la interfaz incluye una lista separada por comas de todas las interfaces que hereda (o extiende).

El cuerpo de la interface

El cuerpo de la interfaz puede contener métodos abstractos, métodos por default, y métodos estáticos. Un método abstracto dentro de una interfaz es seguido de un punto y coma, pero no de llaves (un método abstracto no contiene alguna implementación). Los métodos default son definidos por el modificador default, y los métodos estáticos con la palabra reservada static. Los métodos default, abstractos y estáticos son implicitamente públicos (public), por lo que se puede omitir el modificador public.

También, una interfaz puede contener declaraciones de constantes. Todos los valores constantes definidos en una interfaz son implícitamente públicos (public), estáticos (static) y finales (final). Por lo que se pueden omitir estos modificadores.

Implementando una interface

Para declarar una clase que implementa una interfaz, debes incluir la clausula implements en la declaración de la clase. Tu clase puede implementar más de una interfaz, así que la palabra reservada implements es seguida de una lista seperada por comas de las interfaces implementadas por la clase. Por convención, la clausula implements sigue de la clausula extends, si hay alguna implementación.

Un ejemplo de interface, Relatable

Consideremos una interfaz que define como comparar el tamaño de 2 objetos.

public interface Relatable {

// this (object calling isLargerThan)

// and other must be instances of

// the same class returns 1, 0, -1

// if this is greater than,

// equal to, or less than other

public int isLargerThan(Relatable other);

}

Si tu quieres habilitarla para que compare el tamaño de dos objetos similares, sin importar que son, la clase que instancía a ella debería implementar Relatable.

Cualquier clase puede implementar Relatable si hay una misma forma para comparar los tamaños relativos de objetos instanciados de la clase. Para cadenas, pudiera ser el número de caracteres; para libros pudiera ser el número de páginas; para estudiantes, el peso y así según sea el caso. Para objetos geométricos planos, el área debería de ser una buena opción (vea la clase RectanglePlus), mientras que el volumen sería idóneo para objetos tridimensionales. Todas las clases pueden implementar el método isLargerThan().

Si tu sabes que una clase implementa Relatable, entonces debes saber que puedes comparar el tamaño de los objetos instanciados de la clase.

Implementando la interface Relatable.

Tenemos la clase Rectagle vista en la sección de Creación de objetos, re-escrita para implementar Relatable.

public class RectanglePlus

implements Relatable {

public int width = 0;

public int height = 0;

public Point origin;

// four constructors

public RectanglePlus() {

        origin = new Point(0, 0);

}

public RectanglePlus(Point p) {

       origin = p;

}

public RectanglePlus(int w, int h) {

        origin = new Point(0, 0);

        width = w;

        height = h;

}

public RectanglePlus(Point p, int w, int h) {

        origin = p;

        width = w;

        height = h;

}

// a method for moving the rectangle

public void move(int x, int y) {

        origin.x = x;

        origin.y = y;

}

// a method for computing

// the area of the rectangle

public int getArea() {

        return width * height;

}

// a method required to implement

// the Relatable interface

public int isLargerThan(Relatable other) {

       RectanglePlus otherRect

           = (RectanglePlus)other;

      if (this.getArea() < otherRect.getArea())

            return -1;

      else if (this.getArea() > otherRect.getArea())

           return 1;

      else

          return 0;

}

}

Porque RectanglePlus implementa Relatable, el tamaño de alguno de los dos objetos puede ser comparado.

Aplicación utilizando el IDE Netbeans 7.4 con Linux-Ubuntu..

Clase Point

Interface Redatable

Implementación de la interface

Prueba de la interface.

Salida.


Publicado por neofito69 @ 11:05  | Java SE8
Comentarios (0)  | Enviar
Comentarios