Interfaces Java (Interface)

Neste tutorial, vamos aprender sobre interfaces Java. Vamos aprender por meio de exemplos como implementar interfaces e quando usá-las.

No Java, a interface define um conjunto de especificações que outras classes devem implementar. Por exemplo,

interface Polygon {
　　　public void getArea();
}

Aqui Polygon é uma interface. Usamos a palavra-chave interface para declarar uma interface.

O método getArea() é uma especificação definida na interface Polygon. Todas as classes que utilizam essa interface devem implementar o método getArea().

A interface pode conter métodos abstratos e constantes. Por exemplo,

interface Polygon {
　　　public static final String color = "blue";
　　　
　　　public void getArea();
}

No exemplo acima, criamos uma interface Polygon. Ela inclui uma variável constante color e um método abstrato getArea().

É importante notar que todos os métodos dentro da interface são implicitamente publicos, todos os campos são implicitamente public static final. Portanto, não é necessário especificar o modificador de acesso dentro da interface. Por exemplo, podemos escrever o código acima da seguinte forma

interface Polygon {
　　　String cor = "blue";
　　　
　　　　void getArea();
}

Interface e palavra-chave implements

Da mesma forma que as classes abstratas, não podemos criar objetos de interface. No entanto, podemos implementar interfaces em outras classes. No Java, usamos a palavra-chave implements para implementar interfaces. Por exemplo:

interface Polygon {
　　　　void getArea(int comprimento, int largura);
}
class Rectangle implements Polygon {
　　　　public void getArea(int comprimento, int largura) {
　　　　　　　　System.out.println("A área do retângulo é "　+　(comprimento　*　largura));
　　　　}
}
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　Rectangle r1　= new Rectangle();
　　　　　　　　r1.getArea(5,　6);
　　　　}
}

Resultados de saída

A área do retângulo é　30

No programa acima, criamos uma interface Polygon. A interface Polygon possui o método abstrato getArea().

　Isso significa que qualquer classe que implementar Polygon deve fornecer uma implementação para o método getArea().

Atenção, a classe Rectangle (que implementa a interface Polygon) tem métodos com implementação getArea().

Por que usar interfaces?

Agora que sabemos o que é uma interface, vamos entender por que usamos interfaces no Java.

• As interfaces fornecem especificações que as classes (que as implementam) devem seguir.

• No exemplo acima, usamos getArea() como a especificação da interface Polygon. Isso é como definir uma regra, que é possível obter a área de cada polígono. Portanto, qualquer classe que implementar a interface Polygon deve fornecer uma implementação do método getArea().

• Da mesma forma que as classes abstratas, as interfaces podem nos ajudar a implementar abstração no Java. Aqui, sabemos que getArea() calcula a área do polígono, mas para diferentes poligonos, as maneiras de calcular a área são diferentes. Portanto, as implementações de getArea() são independentes.

• As interfaces também são usadas para implementar múltipla herança no Java. Se a subclasse herda de duas ou mais classes, é múltipla herança.

  No Java, não é possível realizar múltipla herança por meio de classes herdadas. No entanto, uma classe pode implementar várias interfaces. Isso nos permite obter a funcionalidade de múltipla herança no Java. Por exemplo:

  interface Line {
  　　　...
  }
  interface Polygon {
  　　　...
  }
  class Rectangle implements Line, Polygon{
  　　　...
  }

  Aqui, Rectangle deve fornecer implementações de todos os métodos de Line e Polygon.

Métodos privados e estáticos em interfaces

Java 8Neste momento, as interfaces podem conter métodos estáticos.

Da mesma forma que as classes, podemos usar suas referências para acessar métodos estáticos de interfaces. Por exemplo:

Polygon.staticMethod();

Além disso, em Java 9A versão de lançamento suporta métodos privados. Agora, você pode usá-los em interfaces.método privadoeMétodo estático privado。

Como não é possível instanciar uma interface, métodos privados são usados como métodos auxiliares para fornecer suporte para outros métodos da interface.

Métodos padrão na interface

Java 8Em, métodos com implementação foram introduzidos dentro da interface (métodos padrão). Antes disso, todos os métodos eram métodos abstratos no Java.

Para declarar métodos padrão dentro da interface, usamos a palavra-chave default. Por exemplo,

public default void getSides() {
　　　//Corpo do método getSides()
}

Por que usar métodos padrão?

Vamos usar um cenário para entender por que o Java introduziu métodos padrão.

Suponha que precisemos adicionar um novo método à interface.

Podemos facilmente adicionar esse método à interface sem execução. Mas, isso ainda não é o fim da história. Todos os classes que implementam essa interface devem fornecer a implementação desse método.

Se muitos classes estão implementando essa interface, precisamos rastrear todas essas classes e fazer alterações nelas. Isso não só é complicado, mas também fácil de errar.

Para resolver esse problema, o Java introduziu métodos padrão. Os métodos padrão herdam como métodos normais.

Vamos usar um exemplo para entender melhor o método padrão.

Exemplo2：método padrão

interface Polygon {
　　　void getArea();
　　　default void getSides() {
　　　　　　System.out.println("Eu posso obter os lados do polígono.");
　　　}
}
class Rectangle implements Polygon {
　　　public void getArea() {
　　　　　　int length =　6;
　　　　　　int largura =　5;
　　　　　　int area = length　*　largura;
　　　　　　System.out.println("A área do retângulo é "+area);
　　　}
　　　public void getSides() {
　　　　　　System.out.println("Eu tenho quatro lados.");
　　　}
}
class Square implements Polygon {
　　　public void getArea() {
　　　　　　int length =　5;
　　　　　　int area = length　*　length;
　　　　　　System.out.println("A área do quadrado é "+area);
　　　}
}
class Main {
　　　public static void main(String[] args) {
　　　　　　Rectangle r1　= new Rectangle();
　　　　　　r1.getArea();
　　　　　　r1.getSides();
　　　　　　Square s1　= new Square();
　　　　　　s1.getArea();
　　　}
}

Resultados de saída

A área do retângulo é　30
Eu tenho quatro lados.
A área do quadrado é　25

No exemplo acima, criamos uma interface Polygon. Polygon possui um método padrão getSides() e um método abstrato getArea().

Então, a classe Rectangle implementa Polygon, Rectangle fornece a implementação do método abstrato getArea() e sobrescreve o método padrão getSides().

Criamos outra classe Square, que também implementa Polygon. Aqui, Square fornece apenas a implementação do método abstrato getArea().

Exemplo prático de aplicação da interface

Vamos ver um exemplo mais prático de interface Java.

//usar a função sqrt
import java.lang.Math;
interface Polygon {
　　　void getArea();
　　
　　　　　//calcular o perímetro do polígono
　　　default void getPerimeter(int... sides) {
　　　　　　int perimeter = 0;
　　　　　　for (int side: sides) {
　　　　　　　　　perimeter　+= side;
　　　　　　}
　　　System.out.println("Perímetro: "　+　perimeter);
　　　}
}
class Triangle implements Polygon {
　　　private int a, b, c;
　　　private double s, area;
　　　　//inicializar os lados do triângulo
　　　Triangle(int a, int b, int c) {
　　　　　　this.a = a;
　　　　　　this.b = b;
　　　　　　this.c = c;
　　　　　　s = 0;
　　　}
　　　　//calcular a área do triângulo
　　　public void getArea() {
　　　　　　s = (double) (a　+　b　+　c)/2;
　　　　　　area = Math.sqrt(s*(s-a)*(s-b)*(s-c));
　　　　　　System.out.println("Área: "　+　area);
　　　}
}
class Main {
　　　public static void main(String[] args) {
　　　　　　Triangle t1　= new Triangle(2,　3,　4);
　　　　　　//chamando o método da classe Triangle
　　　　　　t1.getArea();
　　　　　　//chamando o método da classe Polygon
　　　　　　t1.getPerimeter(2,　3,　4);
　　　}
}

Resultados de saída

Área:　2.9047375096555625
Perímetro:　9

No programa acima, criamos uma interface Polygon. Ela inclui o método padrão getParameter() e o método abstrato getArea().

Podemos calcular o perímetro de todos os polígonos da mesma forma, portanto, implementamos o corpo de getPerimeter() em Polygon. Agora, todos os polígonos que implementam Polygon podem usar getPerimeter() para calcular o perímetro.

Mas, o método de cálculo da área é diferente para diferentes polígonos, porque as regras de cálculo da área são diferentes para diferentes polígonos.

Portanto, não há implementação em Polygon e inclui getArea(). E qualquer classe que implementar Polygon deve fornecer a implementação de getArea().

Interface e a palavra-chave extends

Como as classes, as interfaces podem herdar outras interfaces, usando a palavra-chave extends. Por exemplo,

interface Line {
　　　//Membros da interface Line
}
interface Polygon extends Line {
　　　//Membros da interface Polygon e Line
}

No exemplo acima, a interface Polygon estende a interface Line. Agora, se um classe implementar Polygon, deve fornecer a implementação de todos os métodos abstratos de Line e Polygon.

Atenção, um interface pode herdar múltiplos interfaces, semelhante a uma classe que implementa múltiplos interfaces. Por exemplo,

interface A {
　　　...
}
interface B {
　　　...　
}
Interface C extends A, B {
　　　...
}