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.
Para declarar una interfaz se utiliza:
--------------------------------------
modificador_acceso interface NombreInterfaz {
....
}
modificador_acceso puede ser public o no existir, siendo entonces por defecto package. 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 implementarla en una clase, se utiliza la forma:
------------------------------------------------------
modificador_acceso NombreClase implements NombreInterfaz1 [, NombreInterfaz2]
Una clase puede implementar varias interfaces, separando los nombres por comas.
El lenguaje de programación Java permite al diseñador de clases especificar que una superclase declara un método pero que no provee una implementación para él. A estos métodos se les denomina métodos abstractos. La implementación de los mismos se realiza en la subclase. Cualquier clase con uno o más métodos abstractos se denomina una clase abstracta.
ResponderEliminarEl compilador Java le avisa en caso de querer instanciar una clase abstracta. Por ejemplo, la sentencia new Vehicle(), con la clase vehicle como clase abstracta, sería ilegal.
Sin embargo, las clases abstractas pueden tener atributos, métodos concretos y constructores.
Los constructores de estas clases se declaran como protected, porque solo tienen sentido para los constructores de las subclases de la clase abstracta.
La interfaz pública de una clase es un contrato entre el código del cliente y la clase que provee el servicio. Las clases concretas implementan cada método. Sin embargo, una clase abstracta puede diferir la implementación declarando que el método sea abstract, mientras que una interfaz Java solamente realiza la declaración del contrato y no la implementación.
Una clase concreta implementa una interfaz definiendo todos los métodos declarados por la interfaz. Muchas clases pueden implementar la misma interfaz. Estas clases no necesitan compartir la misma herencia de clase y, además, una clase puede implementar más de una interfaz. Esto está descrito en la siguiente sección.
Al igual que con las clases abstractas, utilice un nombre de interfaz de la misma forma que el tipo de una variable de referencia. La asignación dinámica (dynamic binding) usual tiene efecto. Las referencias son convertidas a los tipos de la interfaz o a partir de los mismos. Se puede utilizar el operador instanceof para determinar si la clase de un objeto implementa una interfaz.
Imagine un grupo de objetos que comparten la misma habilidad: vuelan. Usted puede construir una interfaz pública, llamada Flyer, que soporta tres operaciones: takeOff (despegar), land (aterrizar) y fly (volar).
Puede haber múltiples clases que implementan la interfaz Flyer. Un aeroplano (airplane) puede volar, un pájaro (bird) también, Superman puede volar, etc.
Un aeroplano es un vehículo, y puede volar. Un pájaro es un animal, y puede volar. Estos ejemplos muestran que una clase puede heredar de otra, pero también implementar otras interfaces.
Esto resulta similar a la herencia múltiple, pero no es así. El riesgo del uso de la herencia múltiple radica en que una clase puede heredar dos implementaciones distintas del mismo método. Con interfaces esto no es posible dado que la declaración de un método de una interfaz no suministra implementación.
Las interfaces pueden utilizarse para:
*Declarar los métodos que, se espera, una o más clases implementen.
*Mostrar una interfaz de programación de un objeto sin revelar el cuerpo de la clase (esto puede ser útil cuando se envía un paquete de clases a otros desarrolladores).
*Capturar la similitud entre clases no relacionadas sin forzarlas a una relación de clases.
*Simular herencia múltiple declarando una clase que implementa varias interfaces.
Bueno eso es un poquito mas a lo que puso Tincho... espero que se sumen mas como invitados...
1.-Se crea una interfaz.
ResponderEliminarpackage Interfaces;
public interface Figura {
public int area();
public void pepe();
}
2.-Se crea una clase que implementa esa interfaz.
package Interfaces;
public class Cuadrado implements Figura {
int lado;
public Cuadrado (int ladoParametro) {
lado = ladoParametro;
}
public int area() {
System.out.println("Paso por AREA");
return lado*lado;
}
public void pepe() {
System.out.println("Pepe");
}
}
3.-Se crea una clase para la prueba del sistemita.
package Interfaces;
public class PruebaInterfaz{
public static void main(String args[]){
Figura figura=new Cuadrado (5);
//Podemos crear una referencia de interface(variable r) y que un objeto que pertenezca
// a una clase que la implementa le sea asignada a la variable
System.out.println(figura.area());
figura.pepe();
}
}