Interfaces em Java

Como uma classe, uma interface pode ter métodos e variáveis, mas os métodos declarados em uma interface são abstratos por padrão (apenas assinatura de método, sem corpo).

As interfaces especificam o que uma classe deve fazer e não como. É o projeto da classe.
Uma Interface é sobre recursos como um Player pode ser uma interface e qualquer classe que implemente Player deve ser capaz de (ou deve implementar) mover(). Portanto, ele especifica um conjunto de métodos que a classe deve implementar.
Se uma classe implementa uma interface e não fornece corpos de método para todas as funções especificadas na interface, a classe deve ser declarada abstrata.
Um exemplo de biblioteca Java é Comparator Interface . Se uma classe implementa essa interface, ela pode ser usada para classificar uma coleção.

Sintaxe:

interface <interface_name> {
    
    // declare constant fields
    // declare methods that abstract 
    // by default.
}

Para declarar uma interface, use a palavra-chave interface . É usado para fornecer abstração total. Isso significa que todos os métodos em uma interface são declarados com um corpo vazio e são públicos e todos os campos são públicos, estáticos e finais por padrão. Uma classe que implementa uma interface deve implementar todos os métodos declarados na interface. Para implementar a interface, use a palavra-chave implements .

Por que usamos interface?

É usado para obter abstração total.
Uma vez que o java não suporta herança múltipla no caso de classe, mas usando a interface, ele pode alcançar herança múltipla.
Ele também é usado para obter um acoplamento frouxo.
As interfaces são usadas para implementar a abstração. Portanto, surge a questão de por que usar interfaces quando temos classes abstratas?

A razão é que as classes abstratas podem conter variáveis não finais, enquanto as variáveis na interface são finais, públicas e estáticas.

// A simple interface
interface Player
{
final int id = 10;
int move();
}

Para implementar uma interface, usamos a palavra-chave: implementa

// Java program to demonstrate working of 
// interface.
import java.io.*;
  
// A simple interface
interface In1
{
    // public, static and final
    final int a = 10;
  
    // public and abstract 
    void display();
}
  
// A class that implements the interface.
class TestClass implements In1
{
    // Implementing the capabilities of
    // interface.
    public void display()
    {
        System.out.println("Geek");
    }
  
    // Driver Code
    public static void main (String[] args)
    {
        TestClass t = new TestClass();
        t.display();
        System.out.println(a);
    }
}

Saída:

Geek
10

Um exemplo do mundo real:
vamos considerar o exemplo de veículos como bicicleta, carro, bicicleta ………, eles têm funcionalidades comuns. Então fazemos uma interface e colocamos todas essas funcionalidades comuns. E permite que Bicicleta, Bicicleta, carro ... etc. implementem todas essas funcionalidades em sua própria classe, à sua maneira.

import java.io.*;
  
interface Vehicle {
      
    // all are the abstract methods.
    void changeGear(int a);
    void speedUp(int a);
    void applyBrakes(int a);
}
  
class Bicycle implements Vehicle{
      
    int speed;
    int gear;
      
     // to change gear
    @Override
    public void changeGear(int newGear){
          
        gear = newGear;
    }
      
    // to increase speed
    @Override
    public void speedUp(int increment){
          
        speed = speed + increment;
    }
      
    // to decrease speed
    @Override
    public void applyBrakes(int decrement){
          
        speed = speed - decrement;
    }
      
    public void printStates() {
         System.out.println("speed: " + speed
              + " gear: " + gear);
    }
}
  
class Bike implements Vehicle {
      
    int speed;
    int gear;
      
    // to change gear
    @Override
    public void changeGear(int newGear){
          
        gear = newGear;
    }
      
    // to increase speed
    @Override
    public void speedUp(int increment){
          
        speed = speed + increment;
    }
      
    // to decrease speed
    @Override
    public void applyBrakes(int decrement){
          
        speed = speed - decrement;
    }
      
    public void printStates() {
         System.out.println("speed: " + speed
             + " gear: " + gear);
    }
      
}
class GFG {
      
    public static void main (String[] args) {
      
        // creating an inatance of Bicycle 
        // doing some operations 
        Bicycle bicycle = new Bicycle();
        bicycle.changeGear(2);
        bicycle.speedUp(3);
        bicycle.applyBrakes(1);
          
        System.out.println("Bicycle present state :");
        bicycle.printStates();
          
        // creating instance of the bike.
        Bike bike = new Bike();
        bike.changeGear(1);
        bike.speedUp(4);
        bike.applyBrakes(3);
          
        System.out.println("Bike present state :");
        bike.printStates();
    }
}

Saída;

Bicycle present state :
speed: 2 gear: 2
Bike present state :
speed: 1 gear: 1

Novos recursos adicionados em interfaces no JDK 8

Antes do JDK 8, a interface não conseguia definir a implementação. Agora podemos adicionar implementação padrão para métodos de interface. Essa implementação padrão tem uso especial e não afeta a intenção por trás das interfaces.

Suponha que precisamos adicionar uma nova função em uma interface existente. Obviamente, o código antigo não funcionará, pois as classes não implementaram essas novas funções. Portanto, com a ajuda da implementação padrão, forneceremos um corpo padrão para as funções recém-adicionadas. Então, os códigos antigos ainda funcionarão.

// An example to show that interfaces can

// have methods from JDK 1.8 onwards

interface In1

{

final int a = 10;

default void display()

{

System.out.println("hello");

}

// A class that implements the interface.

class TestClass implements In1

{

// Driver Code

public static void main (String[] args)

{

TestClass t = new TestClass();

t.display();

}

Saída :

Olá

Outro recurso adicionado no JDK 8 é que agora podemos definir métodos estáticos em interfaces que podem ser chamadas independentemente sem um objeto. Nota: esses métodos não são herdados.

// An example to show that interfaces can

// have methods from JDK 1.8 onwards

interface In1

{

final int a = 10;

static void display()

{

System.out.println("hello");

}

// A class that implements the interface.

class TestClass implements In1

{

// Driver Code

public static void main (String[] args)

{

In1.display();

}

Saída :

Olá

Pontos importantes sobre a interface ou resumo do artigo:

Não podemos criar instância (a interface não pode ser instanciada) da interface, mas podemos fazer referência dela que se refere ao Object de sua classe de implementação.
Uma classe pode implementar mais de uma interface.
Uma interface pode estender outra interface ou interfaces (mais de uma interface).
Uma classe que implementa interface deve implementar todos os métodos de interface.
Todos os métodos são públicos e abstratos. E todos os campos são públicos, estáticos e finais.
É usado para obter herança múltipla.
É usado para obter um acoplamento fraco.

Novos recursos adicionados às interfaces no JDK 9
A partir do Java 9 em diante, as interfaces também podem conter os seguintes

Métodos estáticos
Métodos privados
Métodos estáticos privados

Artigos relacionados:

Este artigo é uma contribuição de Mehak Kumar. e Nitsdheerendra . Escreva comentários se encontrar algo incorreto ou se quiser compartilhar mais informações sobre o tópico discutido acima

Acervo Lima

O maior acervo de tutoriais e referências

Latest posts

Latest posts

Most popular posts