Fique por dentro – Concurso de TI! Interfaces em Java

Fala, meus consagrados! Beleza?

As interfaces são como um contrato ou padrão. Descrevem o que as classes devem fazer sem especificar como devem fazer. Se a classe estiver em conformidade com uma interface, então um determinado serviço será realizado. Ao implementar uma interface, uma classe deve sobrescrever os métodos abstratos da interface.

Uma interface não faze parte de nenhuma hierarquia de classes, embora as interfaces trabalhem em combinação com elas.

As interfaces não podem ser instanciadas, mas apenas podem ser

• Implementadas por classes; e
• Estendidas por outras interfaces.

Essas estruturas fornecem uma alternativa para herança múltipla na linguagem Java:

• Uma classe:
  • Pode herdar apenas uma classe;
  • Mas pode implementar mais de uma interface;
• Uma interface pode herdar de várias outras interfaces.

Quais são os tipos de atributos e de métodos que podemos criar nas interfaces?

Atributos de uma interface em Java são todos automaticamente:

Antes da versão Java 8, todos os métodos de uma interface eram automaticamente:

A partir da versão Java 8, uma interface pode ter métodos:

• Abstratos;
• Default; e
• Estáticos.

Já a partir da versão Java 9, uma interface pode ter métodos:

• Abstratos;
• Default;
• Estáticos;
• Privados; e
• Estáticos privados.

Antes do Java 8, as interfaces eram usadas principalmente para declarar apenas métodos abstratos que as classes implementadoras deveriam definir. Interfaces não podiam conter implementações de métodos (com exceção de métodos estáticos ou default a partir do Java 8). 

Vamos ver um exemplo de como interfaces eram utilizadas antes da introdução de métodos default e estáticos em interfaces no Java 8.

Teremos uma interface Animal e duas classes que implementam essa interface: Cachorro e Gato. Cada animal tem a capacidade de fazer um som característico.

Interface Animal:

public interface Animal {
     // Método abstrato e público para ser implementado por uma classe.
     void fazerSom();
}

Classe Cachorro que implementa a interface Animal:

public class Cachorro implements Animal {
     // A classe Cachorro deve implementar o método fazerSom da              interface Animal.
    public void fazerSom() {
    System.out.println("Au Au");
    }
}

Classe Gato que implementa a interface Animal:

public class Gato implements Animal {
    // A classe Gato deve implementar o método fazerSom da interface Animal
    public void fazerSom() {
    System.out.println("Miau");
    }
}

Testando a interfaces e as classes:

public class Main {
    public static void main(String[] args) {
      Animal rex = new Cachorro();
      Animal xanin = new Gato();
      rex.fazerSom();
      xanin.fazerSom();
   }
}

Resultado da execução do código:

Au Au
Miau

A interface Animal define um método abstrato e público fazerSom(), que não possui corpo. As classes Cachorro e Gato implementam a interface Animal e fornecem a implementação específica do método fazerSom(). Quando o método main é executado, ele cria instâncias de Cachorro e Gato, ambas tratadas como Animal, e chama fazerSom() em cada uma, resultando na saída dos respectivos sons dos animais.

No Java 8, interfaces foram aprimoradas para permitir não apenas a declaração de métodos abstratos, mas também a inclusão de implementações concretas através de métodos default e estáticos.

Os métodos default nas interfaces goram introduzidos no Java 8 e permitem que as interfaces tenham métodos com implementação. As classes que implementam a interface podem herdar o método default sem a necessidade de implementá-lo, embora possam sobrescrevê-lo.

Os métodos estáticos nas interfaces foram introduzidos também no Java 8. São métodos que possuem uma implementação dentro da interface e podem ser chamados no contexto da interface, não sendo herdados pelas classes que a implementam.

Esses recursos permitem que os desenvolvedores criem métodos com comportamentos definidos que não precisam ser implementados pelas classes que usam a interface, proporcionando mais flexibilidade e reutilização de código.

Vamos aprimorar o exemplo com a interface Animal que define um método default para dormir e um método abstrato fazerSom, além de um método static para obter uma descrição geral dos animais:

public interface Animal {
    // Método abstrato e público para ser implementado por uma classe.
    void fazerSom();
    // Método default que fornece uma implementação base
    default void dormir() {
        System.out.println("Este animal está dormindo.");
    }
    // Método static que pode ser chamado na própria interface
    static String getDescricaoGeral() {
    return "Animais são seres vivos que podem se mover e reagir ao ambiente.";
    }
}

Classe Cachorro que implementa a interface Animal:

public class Cachorro implements Animal {
    public void fazerSom() {
        System.out.println("Au Au");
    }
}

Classe Gato que implementa a interface Animal:

public class Gato implements Animal {
    public void fazerSom() {
       System.out.println("Miau");
    }
}

Testando a interfaces e as classes:

public class Main {
     public static void main(String[] args) {
        Animal rex = new Cachorro();
        Animal xanin = new Gato();
        rex.fazerSom();
        xanin.fazerSom();
        // Chamando o método default dos objetos.
        rex.dormir();
        xanin.dormir();
        // Chamando o método static da interface diretamente.
        String descricao = Animal.getDescricaoGeral();
        System.out.println(descricao); 
    }
}

Resultado da execução do código:

Au Au
Miau
Este animal está dormindo.
Este animal está dormindo.
Animais são seres vivos que podem se mover e reagir ao ambiente.

Neste exemplo, a interface Animal define um método abstrato fazerSom que as classes Cachorro e Gato precisam implementar. Além disso, temos um método default chamado dormir, que fornece uma implementação padrão e pode ser acessado por instâncias das classes implementadoras. Não é necessário sobrescrever dormir nas classes Cachorro e Gato, a menos que queiramos fornecer uma implementação diferente da padrão.

O método static getDescricaoGeral pode ser chamado diretamente na interface Animal e não é herdado pelas classes implementadoras, isto é, ele pertence somente à interface.

Com a adição desses novos recursos, o Java 8 melhorou consideravelmente o poder e a flexibilidade das interfaces.

No Java 9, uma novidade importante nas interfaces são os métodos privados. No Java 8, as interfaces podiam conter métodos default e estáticos com implementações, mas não podiam definir métodos privados. A partir do Java 9, os métodos privados e métodos privados estáticos foram introduzidos para permitir o compartilhamento de código entre métodos default e estáticos dentro da própria interface, ajudando a evitar duplicações e tornando o código mais limpo e mantendo a encapsulação.

Vamos fazer um exemplo para entendermos como os métodos privados podem ser usados em interfaces no Java 9.

Interface Calculadora:

public interface Calculadora {
    // Método abstrato que todas as classes implementadoras precisarão definir.
    double calcular(double x, double y);
    // Método default que pode usar métodos privados da interface.
    default double elevarAoQuadradoEAdicionar(double x, double y) {
        return adicionar(elevarAoQuadrado(x), 
        elevarAoQuadrado(y));
     }
    // Método privado usado para evitar duplicação de código.
	private double elevarAoQuadrado(double z) {
		return z * z;
	}
    // Método privado usado para evitar duplicação de código.
    private double adicionar(double a, double b) {
		return a + b;
	}
       // Método estático público que também pode usar métodos privados estáticos.
	static double subtrairEDobrar(double a, double b) {
		return dobrar(subtrair(a, b));
	}
     // Método privado estático usado pelo método estático público.
    private static double subtrair(double a, double b) {
		return a - b;
	}
    // Método privado estático usado pelo método estático público.
    private static double dobrar(double z) {
		return z + z;
	}
}

Classe CalculadoraSimples que implementa a interface Calculadora:

public class CalculadoraSimples implements Calculadora {
    public double calcular(double x, double y) {
        return x + y;
    }
}

Testando a interfaces e a classe:

public class Main {
    public static void main(String[] args) {
         Calculadora calc = new CalculadoraSimples();
         System.out.println(calc.calcular(5, 10));
         System.out.println(calc.elevarAoQuadradoEAdicionar(3, 4));
         System.out.println(Calculadora.subtrairEDobrar(10, 6));
    }
}

Resultado da execução do código:

15.0
25.0
8.0

A interface Calculadora define um método abstrato calcular, que a classe CalculadoraSimples implementa de forma simples, retornando a soma dos dois parâmetros.

A interface Calculadora também inclui um método default chamado elevarAoQuadradoEAdicionar(), que utiliza dois métodos privados: elevarAoQuadrado() e adicionar(). Esses métodos privados não são expostos para as classes que implementam a interface, mas ajudam a reduzir a duplicação de código, permitindo que a lógica compartilhada seja mantida em um só lugar dentro da interface.

Além disso, há um método estático subtrairEDobrar(), que usa os métodos privados estáticos subtrair() e dobrar(). Métodos privados estáticos não podem ser chamados de métodos default, mas podem ser chamados de outros métodos estáticos dentro da interface.

Essa atualização das interfaces na linguagem Java torna as interfaces ferramentas mais poderosas e flexíveis para a criação de APIs robustas e manuteníveis.

Espero que tenham gostado! 

Forte abraço e até a próxima jornada!

_________________________

Professor Rogerão Araújo

---

Quer ficar por dentro dos concursos públicos abertos e previstos pelo Brasil? Clique nos links abaixo:

CONCURSOS 2025

CONCURSOS ABERTOS

QUESTÕES DE CONCURSOS

Receba gratuitamente no seu celular as principais notícias do mundo dos concursos. Clique no link abaixo e inscreva-se:

WHATSAPP

TELEGRAM