Interface Java

Neste tutorial, aprenderemos sobre interfaces Java. Aprenderemos como implementar interfaces e quando usá-las em detalhes com a ajuda de exemplos.

Uma interface é uma classe totalmente abstrata. Inclui um grupo de métodos abstratos (métodos sem corpo).

Usamos o interface palavra-chave para criar uma interface em Java. Por exemplo,

interface Language {
  public void getType();

  public void getVersion();
}

Aqui,

Idioma é uma interface.
Inclui métodos abstratos:getType() e getVersion() .

Implementando uma interface

Assim como as classes abstratas, não podemos criar objetos de interfaces.

Para usar uma interface, outras classes devem implementá-la. Usamos o implements palavra-chave para implementar uma interface.

Exemplo 1:Interface Java

interface Polygon {
  void getArea(int length, int breadth);
}

// implement the Polygon interface
class Rectangle implements Polygon {

  // implementation of abstract method
  public void getArea(int length, int breadth) {
    System.out.println("The area of the rectangle is " + (length * breadth));
  }
}

class Main {
  public static void main(String[] args) {
    Rectangle r1 = new Rectangle();
    r1.getArea(5, 6);
  }
}

Saída

The area of the rectangle is 30

No exemplo acima, criamos uma interface chamada Polygon . A interface contém um método abstrato getArea() .

Aqui, o Retângulo classe implementa Polygon . E fornece a implementação do getArea() método.

Exemplo 2:Interface Java

// create an interface
interface Language {
  void getName(String name);
}

// class implements interface
class ProgrammingLanguage implements Language {

  // implementation of abstract method
  public void getName(String name) {
    System.out.println("Programming Language: " + name);
  }
}

class Main {
  public static void main(String[] args) {
    ProgrammingLanguage language = new ProgrammingLanguage();
    language.getName("Java");
  }
}

Saída

Programming Language: Java

No exemplo acima, criamos uma interface chamada Language . A interface inclui um método abstrato getName() .

Aqui, a ProgrammingLanguage A classe implementa a interface e fornece a implementação para o método.

Implementação de várias interfaces

Em Java, uma classe também pode implementar várias interfaces. Por exemplo,

interface A {
  // members of A
}

interface B {
  // members of B
}

class C implements A, B {
  // abstract members of A
  // abstract members of B
}

Estendendo uma interface

Semelhante às classes, as interfaces podem estender outras interfaces. O extends palavra-chave é usada para estender interfaces. Por exemplo,

interface Line {
  // members of Line interface
}

// extending interface
interface Polygon extends Line {
  // members of Polygon interface
  // members of Line interface
}

Aqui, o Polígono interface estende a Linha interface. Agora, se alguma classe implementar Polygon , ele deve fornecer implementações para todos os métodos abstratos de Line e Polígono .

Estendendo várias interfaces

Uma interface pode estender várias interfaces. Por exemplo,

interface A {
   ...
}
interface B {
   ... 
}

interface C extends A, B {
   ...
}

Vantagens da Interface em Java

Agora que sabemos o que são interfaces, vamos aprender por que as interfaces são usadas em Java.

Semelhante às classes abstratas, as interfaces nos ajudam a alcançar a abstração em Java .

Aqui, conhecemos getArea() calcula a área dos polígonos, mas a forma como a área é calculada é diferente para polígonos diferentes. Portanto, a implementação de getArea() é independente um do outro.
As interfaces fornecem especificações que uma classe (que a implementa) deve seguir.

Em nosso exemplo anterior, usamos getArea() como uma especificação dentro da interface Polygon . Isso é como definir uma regra de que devemos ser capazes de obter a área de cada polígono.

Agora, qualquer classe que implemente o Polygon interface deve fornecer uma implementação para o getArea() método.
As interfaces também são usadas para obter herança múltipla em Java. Por exemplo,
```
interface Line {
…
}

interface Polygon {
…
}

class Rectangle implements Line, Polygon {
…
}
```
Aqui, a classe Retângulo está implementando duas interfaces diferentes. É assim que conseguimos herança múltipla em Java.

Observação :Todos os métodos dentro de uma interface são implicitamente public e todos os campos são implicitamente public static final . Por exemplo,

interface Language {
  
  // by default public static final
  String type = "programming language";

  // by default public
  void getName();
}

métodos padrão em interfaces Java

Com o lançamento do Java 8, agora podemos adicionar métodos com implementação dentro de uma interface. Esses métodos são chamados de métodos padrão.

Para declarar métodos padrão dentro de interfaces, usamos o default palavra-chave. Por exemplo,

public default void getSides() {
   // body of getSides()
}

Por que métodos padrão?

Vamos pegar um cenário para entender por que os métodos padrão são introduzidos em Java.

Suponha que precisamos adicionar um novo método em uma interface.

Podemos adicionar o método em nossa interface facilmente sem implementação. No entanto, esse não é o fim da história. Todas as nossas classes que implementam essa interface devem fornecer uma implementação para o método.

Se um grande número de classes estava implementando essa interface, precisamos rastrear todas essas classes e fazer alterações nelas. Isso não é apenas tedioso, mas também propenso a erros.

Para resolver isso, Java introduziu métodos padrão. Métodos padrão são herdados como métodos comuns.

Vamos dar um exemplo para entender melhor os métodos padrão.

Exemplo:método padrão na interface Java

interface Polygon {
  void getArea();

  // default method 
  default void getSides() {
    System.out.println("I can get sides of a polygon.");
  }
}

// implements the interface
class Rectangle implements Polygon {
  public void getArea() {
    int length = 6;
    int breadth = 5;
    int area = length * breadth;
    System.out.println("The area of the rectangle is " + area);
  }

  // overrides the getSides()
  public void getSides() {
    System.out.println("I have 4 sides.");
  }
}

// implements the interface
class Square implements Polygon {
  public void getArea() {
    int length = 5;
    int area = length * length;
    System.out.println("The area of the square is " + area);
  }
}

class Main {
  public static void main(String[] args) {

    // create an object of Rectangle
    Rectangle r1 = new Rectangle();
    r1.getArea();
    r1.getSides();

    // create an object of Square
    Square s1 = new Square();
    s1.getArea();
    s1.getSides();
  }
}

Saída

The area of the rectangle is 30
I have 4 sides.
The area of the square is 25
I can get sides of a polygon.

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

Aqui, criamos duas classes Rectangle e Quadrado que implementam Polygon .

O Retângulo classe fornece a implementação do getArea() e substitui o getSides() método. No entanto, o Quadrado classe fornece apenas a implementação do getArea() método.

Agora, ao chamar o getSides() usando o método Retângulo objeto, o método substituído é chamado. No entanto, no caso do Quadrado objeto, o método padrão é chamado.

Métodos privados e estáticos na interface

O Java 8 também adicionou outro recurso para incluir métodos estáticos dentro de uma interface.

Semelhante a uma classe, podemos acessar métodos estáticos de uma interface usando suas referências. Por exemplo,

// create an interface
interface Polygon {
  staticMethod(){..}
}

// access static method
Polygon.staticMethod();

Observação :Com o lançamento do Java 9, os métodos privados também são suportados nas interfaces.

Não podemos criar objetos de uma interface. Assim, métodos privados são usados como métodos auxiliares que fornecem suporte a outros métodos em interfaces.

Exemplo prático de interface

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

// To use the sqrt function
import java.lang.Math;

interface  Polygon {
   void getArea();
  
 // calculate the perimeter of a Polygon
   default void getPerimeter(int... sides) {
      int perimeter = 0;
      for (int side: sides) {
         perimeter += side;
      }

   System.out.println("Perimeter: " + perimeter);
   }
}

class Triangle implements Polygon {
   private int a, b, c;
   private double s, area;

// initializing sides of a triangle
   Triangle(int a, int b, int c) {
      this.a = a;
      this.b = b;
      this.c = c;
      s = 0;
   }

// calculate the area of a triangle
   public void getArea() {
      s = (double) (a + b + c)/2;
      area = Math.sqrt(s*(s-a)*(s-b)*(s-c));
      System.out.println("Area: " + area);
   }
}

class Main {
   public static void main(String[] args) {
      Triangle t1 = new Triangle(2, 3, 4);

// calls the method of the Triangle class
      t1.getArea();

// calls the method of Polygon
      t1.getPerimeter(2, 3, 4);
   }
}

Saída

Area: 2.9047375096555625
Perimeter: 9

No programa acima, criamos uma interface chamada Polygon . Inclui um método padrão getPerimeter() e um método abstrato getArea() .

Podemos calcular o perímetro de todos os polígonos da mesma maneira, então implementamos o corpo de getPerimeter() em Polígono .

Agora, todos os polígonos que implementam Polygon pode usar getPerimeter() para calcular o perímetro.

No entanto, a regra para calcular a área é diferente para diferentes polígonos. Portanto, getArea() está incluído sem implementação.

Qualquer classe que implemente Polygon deve fornecer uma implementação de getArea() .

Classe abstrata Java e métodos abstratos Polimorfismo Java

Java