Como Definir e Implementar Interfaces em Java 7 e Java 8

Entendendo Interfaces em Java com Simplicidade

Imagine que você está aprendendo a cozinhar. Você tem um livro de receitas que descreve os passos essenciais para preparar diferentes pratos, mas não diz exatamente como você deve mexer sua panela ou em qual velocidade deve cortar os vegetais. Isso é semelhante ao que as interfaces fazem em Java.

Uma interface é como um conjunto de promessas. Quando uma classe decide “implementar” uma interface, está prometendo que vai cumprir essas promessas, ou seja, realizar todas as ações (métodos) listadas na interface.

Em termos técnicos, uma interface é um tipo especial de definição no Java que enumera um grupo de métodos relacionados, mas não diz nada sobre como esses métodos devem ser realizados. É como se a interface dissesse: “Qualquer um que me implemente precisa saber fazer estas coisas, mas cada um pode fazer à sua maneira”.

Exemplo do Dia a Dia

Imagine a interface como uma lista de tarefas para funcionários de uma lanchonete. A lista poderia ser algo assim:

Preparar o sanduíche
Fritar as batatas
Servir o refrigerante

Cada funcionário (que seria como uma “classe” em Java) saberá realizar essas tarefas à sua maneira, mas todos devem segui-las. Portanto, a interface é essa lista de tarefas que garante a padronização do serviço ao cliente, mesmo sendo executadas de forma individual por cada colaborador.

Para que serve?

No mundo da programação, usar interfaces ajuda a manter um design limpo e organizado. Quando várias classes implementam a mesma interface, você pode ter certeza de que todas elas podem realizar as mesmas ações, mesmo que cada uma tenha uma forma única de fazê-lo.

Um dos principais benefícios das interfaces é que elas promovem a reutilização do código. Você pode escrever uma função que trabalhe com qualquer classe que implemente uma interface específica, em vez de escrever uma função para cada classe. Isso não só economiza tempo, mas também torna o seu código mais fácil de ler e manter.

Interfaces no Java

Até o Java 7, as interfaces eram bem rígidas: só podiam ter definições de métodos que não eram implementados (tarefas sem a descrição de como fazê-las) e constantes (valores que nunca mudam). No entanto, a partir do Java 8, as interfaces ficaram mais flexíveis. Agora, podem conter métodos com uma implementação padrão (default), que oferecem uma forma básica de realização da tarefa, e métodos estáticos, que são métodos que pertencem à interface e não a uma instância de uma classe.

Em resumo, as interfaces são uma maneira de garantir que diferentes classes possam ser usadas de forma intercambiável, contanto que elas se comprometam a realizar um conjunto básico de ações. Isso torna o nosso código mais modular, flexível e poderoso – um grande passo na cozinha da programação Java!

Demonstração do Uso de Interfaces em Java 7 e Java 8

Vamos explorar a evolução das interfaces em Java 7 e Java 8 com o exemplo da interface FormaGeometrica. Primeiramente, vamos criar a interface com o método calcularArea() e depois implementá-la em uma classe Quadrado em ambas as versões do Java.

Interface em Java 7

// Interface em Java 7
public interface FormaGeometrica {
    double calcularArea();
}

// Interface em Java 7

public interface FormaGeometrica {

double calcularArea();

}

Implementação em Java 7

// Implementação em Java 7
public class Quadrado implements FormaGeometrica {
    private double lado;

    public Quadrado(double lado) {
        this.lado = lado;
    }

    @Override
    public double calcularArea() {
        return lado * lado;
    }
}

// Implementação em Java 7

public class Quadrado implements FormaGeometrica {

private double lado;

public Quadrado(double lado) {

this.lado = lado;

}

@Override

public double calcularArea() {

return lado * lado;

}

Interface em Java 8

// Interface em Java 8
public interface FormaGeometrica {
    double calcularArea();

    default void mostrarDescricao() {
        System.out.println("Esta é uma forma geométrica.");
    }

    static void mostrarInfo() {
        System.out.println("Interface para cálculo de áreas de formas geométricas.");
    }
}

// Interface em Java 8

public interface FormaGeometrica {

double calcularArea();

default void mostrarDescricao() {

System.out.println("Esta é uma forma geométrica.");

}

static void mostrarInfo() {

System.out.println("Interface para cálculo de áreas de formas geométricas.");

}

Implementação em Java 8

// Implementação em Java 8
public class Quadrado implements FormaGeometrica {
    private double lado;

    public Quadrado(double lado) {
        this.lado = lado;
    }

    @Override
    public double calcularArea() {
        return lado * lado;
    }
}

// Implementação em Java 8

public class Quadrado implements FormaGeometrica {

private double lado;

public Quadrado(double lado) {

this.lado = lado;

}

@Override

public double calcularArea() {

return lado * lado;

}

Ao criar a classe Quadrado implementando a interface FormaGeometrica nas versões do Java 7 e do Java 8, percebemos a adição dos métodos mostrarDescricao() e mostrarInfo() na versão do Java 8, proporcionando funcionalidades extras sem a necessidade de reimplementação.

Essa evolução demonstra como o Java 8 trouxe mais flexibilidade e recursos às interfaces, tornando-as mais poderosas e versáteis para simplificar o desenvolvimento e manutenção de código, promovendo uma abordagem mais moderna e eficiente no desenvolvimento de aplicações.

Demonstração do Uso da Interface em um Programa Principal

Para demonstrar o uso da interface FormaGeometrica no método main() de um programa principal, iremos criar um exemplo que instancia a classe Quadrado e utiliza os métodos da interface tanto em Java 7 quanto em Java 8.

Uso da Interface em Java 7

// Uso da Interface em Java 7
public class ProgramaPrincipal {
    public static void main(String[] args) {
        Quadrado quadrado = new Quadrado(5.0);

        double areaQuadrado = quadrado.calcularArea();
        System.out.println("Área do Quadrado em Java 7: " + areaQuadrado);
    }
}

// Uso da Interface em Java 7

public class ProgramaPrincipal {

public static void main(String[] args) {

Quadrado quadrado = new Quadrado(5.0);

double areaQuadrado = quadrado.calcularArea();

System.out.println("Área do Quadrado em Java 7: " + areaQuadrado);

}

Uso da Interface em Java 8

// Uso da Interface em Java 8
public class ProgramaPrincipal {
    public static void main(String[] args) {
        Quadrado quadrado = new Quadrado(5.0);

        double areaQuadrado = quadrado.calcularArea();
        System.out.println("Área do Quadrado em Java 8: " + areaQuadrado);

        quadrado.mostrarDescricao(); // Método default da interface
        FormaGeometrica.mostrarInfo(); // Método estático da interface
    }
}

// Uso da Interface em Java 8

public class ProgramaPrincipal {

public static void main(String[] args) {

Quadrado quadrado = new Quadrado(5.0);

double areaQuadrado = quadrado.calcularArea();

System.out.println("Área do Quadrado em Java 8: " + areaQuadrado);

quadrado.mostrarDescricao(); // Método default da interface

FormaGeometrica.mostrarInfo(); // Método estático da interface

}

No método main() do programa principal ProgramaPrincipal, instanciamos um objeto da classe Quadrado com um lado de comprimento 5.0 e calculamos a área do quadrado utilizando o método calcularArea().

Em seguida, no Java 8, aproveitamos os recursos adicionais da interface FormaGeometrica, chamando o método mostrarDescricao() diretamente pela instância do quadrado e o método mostrarInfo() diretamente pela interface, evidenciando o uso dos métodos default e estáticos.

Essa demonstração destaca a flexibilidade e facilidade de uso proporcionadas pelo Java 8 com a introdução de métodos default e estáticos em interfaces, enriquecendo a programação orientada a interfaces com funcionalidades extras e práticas para o desenvolvimento de aplicações.