Interfaz en Java

Como sabes, todo en Java consta de objetos, y los objetos tienen estado (campos) y comportamiento (definidos por métodos). El comportamiento de una clase es lo que puede vincularla a otras clases. El comportamiento puede tener diferentes características, y en ocasiones puede resultar más conveniente trasladarlo fuera de la clase, especialmente a la hora de interactuar con el mundo exterior. Al igual que el control remoto del televisor está fuera de la "caja". El control remoto es una interfaz para la interacción del usuario con las funciones del televisor. Por ejemplo, puedes imaginar una clase que implemente un avión o un helicóptero abstracto. Los objetos de ambas clases, como la mayoría de los pájaros, pueden volar, y todos lo hacen de forma diferente. ¿Quizás valga la pena trasladar esta característica a una entidad separada, y todos los posibles "volantes" se heredarán de esta entidad? Si ya está familiarizado con las clases abstractas, puede simplemente crear una clase abstracta Flyable y “heredar” las clases Copter y Plane de ella. Sin embargo, ¿qué pasa si existen varias de estas propiedades? Por ejemplo, los aviones y los helicópteros pueden volar, pero también viajar por tierra. Incluso si creamos la clase Ride, ya no podemos asignarle Copter y Plane. Después de todo, cada clase Java tiene sólo una clase principal. El uso de interfaces en lenguaje Java resuelve parcialmente este problema. Las interfaces en Java definen algunas funciones que no tienen una implementación específica, que luego es implementada por clases que usan estas interfaces. Y una clase puede implementar muchas interfaces. De hecho, al implementar una interfaz en Java, declaramos que nuestra clase puede hacer algo, informamos de su comportamiento. Ya realizamos la implementación concreta del comportamiento en la clase. Entonces. un avión y un helicóptero despegan de forma diferente: un avión necesita una pista, mientras que un helicóptero suele despegar verticalmente. Estos detalles se implementan mejor dentro de la clase.

Interfaces en Java

Para definir una interfaz en lenguaje Java, se utiliza la palabra clave interfaz. Por ejemplo:

interface Voice {

    void talk();
}

La interfaz anterior se llama Voz . Una interfaz en Java puede definir constantes y métodos, que pueden tener o no implementaciones. Normalmente, los métodos de interfaz no tienen implementación, como en este ejemplo. Los métodos en interfaces sin implementación son como métodos abstractos de clases abstractas. Los métodos de interfaz normalmente no tienen modificadores de acceso. Sin embargo, el acceso es público de forma predeterminada porque el propósito de una interfaz es definir la funcionalidad para la implementación de una clase. Por lo tanto, todas las funciones deben estar abiertas para su implementación. Para implementar una interfaz, use la palabra clave Implements mientras declara su clase. Además, si una interfaz contiene un método sin implementación, entonces ese método debe implementarse en la clase de implementación.

public class Duck implements Voice {


@Override
public void voice() {
   System.out.println("Quack");
}


    }

Ejemplo de código de interfaz

Pongamos un ejemplo más completo. Todos (bueno, casi todos) los animales tienen la capacidad de emitir sonidos. Creemos una interfaz Java Voice para este caso. Tiene un método talk() sin implementación.

public interface Voice {
   void talk();
}

Ahora todas las clases que soportan la interfaz Voice deben tener una implementación del método talk() . Creemos dos clases: Gato y Perro e indiquemos que implementan la interfaz de Voz . En este caso, si no implementas una clase en él, el programa no funcionará. Los métodos de implementación son muy simples. Al llamar al método talk() de un objeto de la clase Gato , se mostrará en pantalla el texto equivalente a un maullido, en el caso de la clase Perro , un ladrido. También agregaremos captadores, definidores y un constructor a las clases.

public class Cat implements Voice {
   String name;
   String breed;
   int year;

   public Cat(String name, String breed, int year) {
       this.name = name;
       this.breed = breed;
       this.year = year;
   }

   public String getName() {
       return name;
   }

   public void setName(String name) {
       this.name = name;
   }

   public String getBreed() {
       return breed;
   }

   public void setBreed(String breed) {
       this.breed = breed;
   }

   public int getYear() {
       return year;
   }

   public void setYear(int year) {
       this.year = year;
   }

   @Override
   public void talk() {
       System.out.println("meow...");
   }
}

public class Dog implements Voice {
   String name;
   String color;
   int year;

   public Dog(String name, String color, int year) {
       this.name = name;
       this.color = color;
       this.year = year;
   }

   public String getName() {
       return name;
   }

   public void setName(String name) {
       this.name = name;
   }

   public String getColor() {
       return color;
   }

   public void setColor(String color) {
       this.color = color;
   }

   public int getYear() {
       return year;
   }

   public void setYear(int year) {
       this.year = year;
   }

   @Override
   public void talk() {
       System.out.println("WOF WOF");
   }
}

De hecho, nuestras implementaciones de clases y métodos son muy similares. Creemos otra clase, Parrot , con soporte de voz . Sólo el método talk() funcionará de manera diferente: el usuario ingresará una cadena en la consola y el loro la "repetirá" usando el método talk() .

import java.util.Scanner;

public class Parrot implements Voice {
   String name;
   String color;
   int year;

   public String getName() {
       return name;
   }

   public void setName(String name) {
       this.name = name;
   }

   public String getColor() {
       return color;
   }

   public void setColor(String color) {
       this.color = color;
   }

   public int getYear() {
       return year;
   }

   public void setYear(int year) {
       this.year = year;
   }

   @Override
   public void talk() {
       Scanner scanner = new Scanner(System.in);
       System.out.println("WHat should I repeat after you?...");
       String s =  scanner.nextLine();
       System.out.println(s);
   }
}

Ahora creemos una clase de prueba y veamos qué resultado producirá el programa si llamamos al método talk() de los objetos de las clases Cat , Dog y Parrot .

public class InterfaceDemo {
   public static void main(String[] args) {
       Cat cat = new Cat ("Mewie", "Siam" ,2021);
       cat.talk();
       Dog dog = new Dog("Snoopy", "White and black", 2020);
       dog.talk();
       Parrot parrot = new Parrot();
       parrot.talk();
   }
}

El resultado está a continuación. El texto verde es el único usuario impreso en la consola.

Métodos predeterminados

Antes del lanzamiento de JDK 8, al implementar una interfaz en Java, teníamos que implementar todos sus métodos en una clase. Al mismo tiempo, la propia interfaz Java podría contener sólo definiciones de métodos sin una implementación específica. JDK 8 agrega una nueva funcionalidad: métodos predeterminados. Ahora las interfaces Java pueden tener no sólo definiciones de métodos sino también implementaciones predeterminadas. Se utilizan si la clase implementa la interfaz pero no implementa el método. Por ejemplo, cambiemos el método talk() en la interfaz de Voice al método predeterminado. También escribiremos una nueva clase Duck habilitada para voz que no tiene una implementación del método de conversación .

public interface Voice {
   default void talk() {
       System.out.println("I can talk...");
   }
}

public class Duck implements Voice {

   public void moveForward() {
       System.out.println(" Quack, I am moving forward...");
   }

   public void TurnRight(){
       System.out.println("I am turning right...");
   }
   public void TurnLeft(){
       System.out.println("I am turning left...");

   }

   public void Stop() {
       System.out.println("Quack. I am relaxing on the surface of the water...");
   }

   public void fly(){
       System.out.println("I am flying!!!");
   }

}

Ahora cambiemos un poco nuestra clase de prueba.

public class InterfaceDemo {
   public static void main(String[] args) {
       Cat cat = new Cat ("Mewie", "Siam" ,2021);
       cat.talk();
       Dog dog = new Dog("Snoopy", "White and black", 2020);
       dog.talk();
       Duck duck = new Duck();
       duck.talk();
   }
}

El resultado está aquí: ¿Ver? En los objetos de las clases Dog y Cat , se llama al método anulado talk() , pero en un objeto de la clase Duck , se llama al método predeterminado de la interfaz. Por tanto, el método predeterminado es sólo un método sin modificadores y está marcado con la palabra clave predeterminada. No tenemos que implementar el método predeterminado en la clase que implementa la interfaz, pero podemos anularlo.

Métodos estáticos

Dado que los métodos estáticos de JDK 8 están disponibles en las interfaces Java, son similares a los métodos de clase:

interface Voice {

    void talk();

    static void check(){

        System.out.println("checked...");
    }
}

Para hacer referencia a un método estático de una interfaz, al igual que en el caso de las clases, escribe el nombre de la interfaz y el método:

public static void main(String[] args) {

    Voice.check();
}

Implementación múltiple de interfaces

Si necesitamos aplicar varias interfaces en la clase Java, todas se enumeran con una coma después de la palabra implements :

public class Duck implements Swimmable, Flyable, Voice {

    public void moveForward() {
        System.out.println(" Quack, I am moving forward...");
    }

    public void TurnRight(){
        System.out.println("I am turning right...");
    }
    public void TurnLeft(){
        System.out.println("I am turning left...");

    }

    public void Stop() {
        System.out.println("Quack. I am relaxing on the surface of the water...");
    }

    public void fly(){
        System.out.println("I am flying!!!");
    }

}