Interface em Java

Como você sabe, tudo em Java consiste em objetos, e os objetos possuem estado (campos) e comportamento (definido por métodos). O comportamento de uma classe é o que pode vinculá-la a outras classes. O comportamento pode ter características diferentes e às vezes pode ser mais conveniente movê-lo para fora da classe, principalmente quando se trata de interagir com o mundo exterior. Assim como o controle remoto da TV fica fora da própria “caixa”. O controle remoto é uma interface para interação do usuário com as funções da TV. Por exemplo, você pode imaginar uma classe que implemente um avião ou helicóptero abstrato. Objetos de ambas as classes, como a maioria dos pássaros, podem voar, e todos fazem isso de maneira diferente. Talvez valha a pena mover esse recurso para uma entidade separada, e todos os “folhetos” em potencial serão herdados dessa entidade? Se você já está familiarizado com classes abstratas, você pode simplesmente criar uma classe abstrata Flyable e “herdar” as classes Copter e Plane dela. No entanto, e se existirem várias dessas propriedades? Por exemplo, aviões e helicópteros podem voar, mas também viajar no solo. Mesmo se criarmos a classe Ride, não poderemos mais atribuir Copter e Plane a ela. Afinal, cada classe Java possui apenas uma classe pai. O uso de interfaces na linguagem Java resolve parcialmente esse problema. As interfaces em Java definem algumas funcionalidades que não possuem uma implementação específica, que são então implementadas por classes que utilizam essas interfaces. E uma classe pode implementar muitas interfaces. Na verdade, ao implementar uma interface em Java, declaramos que nossa classe pode fazer algo, reportamos seu comportamento. Já realizamos a implementação concreta do comportamento na classe. Então. um avião e um helicóptero decolam de maneira diferente: um avião precisa de uma pista, enquanto um helicóptero geralmente decola verticalmente. Esses detalhes são melhor implementados dentro da classe.

Interfaces em Java

Para definir uma interface em linguagem Java, a palavra-chave interface é usada. Por exemplo:

interface Voice {
 
    void talk();
}

A interface acima é chamada Voice . Uma interface em Java pode definir constantes e métodos, que podem ou não ter implementações. Normalmente, os métodos de interface não possuem implementação, assim como neste exemplo. Métodos em interfaces sem implementação são como métodos abstratos de classes abstratas. Os métodos de interface geralmente não possuem modificadores de acesso. No entanto, o acesso é público por padrão porque o objetivo de uma interface é definir funcionalidade para uma implementação de classe. Portanto, todas as funcionalidades devem estar abertas para implementação. Para implementar uma interface, use a palavra-chave Implements ao declarar sua classe. Além disso, se uma interface contém um método sem implementação, então esse método deve ser implementado na classe de implementação.

public class Duck implements Voice {


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


    }

Exemplo de código de interface

Vejamos um exemplo mais completo. Todo (bem, quase todo) animal tem a capacidade de emitir sons. Vamos criar uma interface Java Voice para este caso. Possui um método talk() sem implementação.

public interface Voice {
   void talk();
}

Agora todas as classes que suportam a interface Voice devem ter uma implementação do método talk() . Vamos criar duas classes — Cat e Dog e indicar que elas implementam a interface Voice . Neste caso, se você não implementar uma classe nele, o programa não funcionará. Implementar métodos é muito simples. Ao chamar o método talk() de um objeto da classe Cat , será exibido na tela o texto equivalente a um miado, no caso da classe Dog , um latido. Também adicionaremos getters, setters e um construtor às classes.

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");
   }
}

Na verdade, nossas implementações de classes e métodos são muito semelhantes. Vamos criar outra classe, Parrot , com suporte a Voice . Somente o método talk() funcionará de maneira diferente nele: o usuário inserirá uma string no console e o papagaio irá “repeti-la” usando o 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);
   }
}

Agora vamos criar uma classe de teste e ver qual resultado o programa produzirá se chamarmos o método talk() dos objetos das classes Cat , Dog e Parrot por sua vez.

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();
   }
}

A saída está abaixo. O texto verde é o usuário impresso no console.

Métodos padrão

Antes do lançamento do JDK 8, ao implementar uma interface em Java, tínhamos que implementar todos os seus métodos em uma classe. Ao mesmo tempo, a própria interface Java poderia conter apenas definições de métodos sem uma implementação específica. JDK 8 adiciona novas funcionalidades — métodos padrão. Agora, as interfaces Java podem ter não apenas definições de métodos, mas também implementações padrão. Eles são usados ​​se a classe implementa a interface, mas não implementa o método. Por exemplo, vamos alterar o método talk() na interface do Voice para o método padrão. Também escreveremos uma nova classe Duck habilitada para Voice que não possui uma implementação do método talk .

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!!!");
   }

}

Agora vamos mudar um pouco nossa classe de teste.

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();
   }
}

A saída está aqui: Ver? Em objetos das classes Dog e Cat , o método substituído talk() é chamado, mas em um objeto da classe Duck , o método padrão da interface é chamado. Assim, o método padrão é apenas um método sem modificadores e é marcado com a palavra-chave padrão. Não precisamos implementar o método padrão na classe que implementa a interface, mas podemos substituí-lo.

Métodos estáticos

Como os métodos estáticos do JDK 8 estão disponíveis nas interfaces Java - eles são semelhantes aos métodos de classe:

interface Voice {
     
    void talk();
     
    static void check(){
         
        System.out.println("checked...");
    }
}

Para se referir a um método estático de uma interface, assim como no caso das classes, escreva o nome da interface e do método:

public static void main(String[] args) {
         
    Voice.check(); 
}

Implementação múltipla de interfaces

Se precisarmos aplicar várias interfaces na classe Java, todas elas serão listadas com uma vírgula após a palavra 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!!!");
    }

}