91.    Implementación (concepto)

Se dice que una clase implementa una interfaz cuando proporciona código para concreto para los métodos definidos en la interfaz.

interface Coordenada.java

public interface Coordenada {

 

    double x();

 

    double y();

 

    double distancia(Coordenada q);

}       

class Punto implements Coordenada

public class Punto

        implements Coordenada {

    private double x, y;

 

    public Punto(double x, double y) {

        this.x = x;

        this.y = y;

    }

 

    public double x() {

        return x;

    }

 

    public double y() {

        return y;

    }

 

    public double distancia(Coordenada q) {

        double dx = q.x() - x;

        double dy = q.y() - y;

        return Math.sqrt(dx * dx + dy * dy);

    }

}     

 

Se dice que los métodos en la clase concreta implementan a sus homónimos en la interface, debiendo cumplir las siguientes condiciones

·         mismos argumentos (número, clase y orden)

Misma clase implica que no vale recurrir a argumentos de tipos que sean superclase o subclase del prometido en la interface.

·         misma clase de resultado (vale que la implementación devuelva una subclase)

·         igual o mayor visibilidad
"de paquete" < protected < public

·         igual o menos capacidad de lanzar excepciones; el método que implementa puede

·         no lanzar excepción alguna

·         lanzar excepciones que sean subclases de la del método implementado

·         lanzar las mismas excepciones que el método implementado

De una misma interfaz pueden derivarse múltiples implementaciones.

interface Funcion

public interface Funcion {

    double y(double x)

            throws Exception;

}     

class Seno

class Coseno

class Seno

  implements Funcion {

  public double y(double x) {

      return Math.sin(x);

    }

}

class Coseno

  implements Funcion {

  public double y(double x) {

      return Math.cos(x);

    }

}

class Tangente

class Suma

class Tangente

        implements Funcion {

    public double y(double x)

            throws Exception {

        double seno =

               Math.sin(x);

        double coseno =

               Math.cos(x);

        if (Math.abs(coseno)

                        < 1e-6)

            throw new Exception();

        return seno / coseno;

    }

}

class Suma

        implements Funcion {

    private final Funcion f1;

    private final Funcion f2;

 

    Suma(Funcion f1, Funcion f2) {

        this.f1 = f1;

        this.f2 = f2;

    }

 

    public double y(double x)

            throws Exception {

        return f1.y(x) + f2.y(x);

    }

}

 

Y se puede usar el tipo de la interfaz para referenciar a cualquier implementación

Funcion f1 = new Seno();

Funcion f2 = new Coseno();

Funcion f3 = new Suma(f1, f2);

Temas relacionados

Vademécum
implementación múltiple
implementación parcial