11. Interfaces

LOGRO DE LA UNIDAD DE APRENDIZAJE

Al término de la unidad, ustedes aplicarán el concepto de herencia múltiple. Crearán e implementarán interfaces.

TEMARIO

· Creación e implementación de Interfaces

· Herencia múltiple

· Ejercicios

ACTIVIDADES PROPUESTAS

· Ustedes crean e implementan interfaces

· Ustedes aplican el concepto de herencia múltiple

1) Creación de interfaces

Una interfaz es una clase completamente abstracta, es decir es una clase sin implementación.

Una interfaz es cuando lo único que puede tener son declaraciones de métodos y definiciones de constantes simbólicas. En Java, las interfaces se declaran con la palabra reservada interface.

La clase que implementa una o más interfaces utiliza la palabra reservada implements. Para ello, es necesario que la clase implemente todos los métodos definidos por la interfaz.

Una interfaz podrá verse, simplemente, como una forma, es como un molde; solamente permite declarar nombres de métodos. En este caso, no es necesario definirlos como abstractos, puesto que lo son implícitamente. Y si adicionalmente tiene miembros datos, éstos serán constantes, es decir, static y final.

Al utilizar implements para el interfaz es como si se hiciese una acción de copiar y pegar del código del interfaz, con lo cual no se hereda nada, solamente se pueden usar los métodos.

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

La principal diferencia entre interface y clase abstracta es que una interface proporciona un mecanismo de encapsulamiento sin forzar al usuario a utilizar la herencia.

Ejemplo 1

Código de la interfaz: Constantes

package interfaces;
public interface Constantes {
   double pi = 3.14;
   int constanteInt = 5;
}

Código de la interfaz: Interfaz1

package interfaces;
public interface Interfaz1 {
   void put( int dato );
   int get();
}

Código de la clase: ClaseA

package clases;
import interfaces.*;
public class ClaseA implements Constantes, Interfaz1 {
   double dato;
   
   // El método put del interfaz1
   public void put( int dato ) {
      // Se usa "pi" del interfaz Constantes
      this.dato = dato * pi;
   }

   // El método get del interfaz1
   public int get() {
      return( (int)dato );
   }

   // El método show() no esta declarado en el interfaz1
   public String show() {
      return "imprime " + dato;
   }
}

Código de la clase: ClaseB

package clases;
import interfaces.*;
public class ClaseB implements Constantes, Interfaz1 {
   int dato;

   // El método put del interfaz1
   public void put( int dato ) {
      // Se usa "constanteInt" del interfaz Constantes
      this.dato = dato * constanteInt;
   }
   
   // El método get del interfaz1
   public int get() {
      return dato;
   }
}

Código de la clase: Principal

import interfaces.*;
import clases.*;
...
...
void procesar(){
   // Se crea un objeto de tipo ClaseA
   ClaseA objA = new ClaseA();
   objA.put(2);

   // El método show pertenece a la claseA
   imprimir(objA.show());
   imprimir("dato objA = "+objA.get());

   // Se crea un objeto de tipo ClaseB
   ClaseB objB = new ClaseB();
   objB.put(4);
   
   imprimir("dato objB = " + objB.get());
}

Salida: 

imprime 6.28 

dato objA = 6 

dato objB = 20 

2) Herencia múltiple 

En Java, realmente, no existe la herencia múltiple. Lo que se puede es crear una clase que implemente (implements) más de un interfaz, pero sólo puede extender una clase (extends). 

La siguiente figura muestra la implementación de interfaces:

Dibujable y Rotable son interfaces, cuyos métodos serán implementados en otras clases. Por ejemplo: Cuadrado implementa la interfaz Dibujable y Círculo implementa las interfaces Dibujable y Rotable.

Ejemplo 2

Interface Dibujable

package interfaces;
public interface Dibujable {
   String dibujar();
}

Interfaz Rotable

package interfaces;
public interface Rotable {
   String rotar();
}

Clase Padre Figura

package clases;
public abstract class Figura{
   protected int x;
   protected int y;

   public Figura(int x, int y) {
      this.x = x;
      this.y = y;
   }

   public String ubicacion(){
      return "figura ubicada en: "+x+", "+y;
   }

   public abstract double area() ;
}

Clase hija Cuadrado

package clases;
import interfaces.Dibujable;
public class Cuadrado extends Figura implements Dibujable{
   private double lado;

   public Cuadrado(int x, int y, double lado) {
      super(x, y);
      this.lado = lado;
   }

   //Sobre-escritura
   public double area() {
      return lado*lado;
   }

   //Sobre-escritura
   public String dibujar() {
      return "El cuadrado puede ser dibujado";
   }
}

Clase hija Circulo

package clases;
import interfaces.*;
public class Circulo extends Figura implements Dibujable,Rotable {
   private double radio

   public Circulo(int x, int y, double radio) {
      super(x, y);
      this.radio = radio;
   }

   //Sobre-escritura
   public double area() {
      return Math.PI * radio * radio;
   }

   //Sobre-escritura
   public String dibujar() {
      return "El círculo puede ser dibujado";
   }

   //Sobre-escritura
   public String rotar() {
      return "El círculo puede rotar";
   }
}

Clase Principal

import clases.*;
...
...
void procesar(){
   Cuadrado obj1 = new Cuadrado(10,20,8);
   listar(obj1);

   Circulo obj2 = new Circulo(40,110,3);
   listar(obj2);
}

void listar(Figura x){
   imprimir(x.ubicacion());
   imprimir("El área es:"+x.area());
   if(x instanceof Cuadrado)
       imprimir(((Cuadrado)x).dibujar());
   else{
       imprimir(((Circulo)x).dibujar());
       imprimir(((Circulo)x).rotar());
   }
   imprimir("");
}

Descargar ejercicios 

Descargar archivo

Preguntas
¿Qué es una interfaz?

¿Qué es herencia multiple?