implementa a palavra-chave em Java

A palavra-chave implements em Java é usada para indicar que uma classe implementará uma interface. Ao usar implements, uma classe concorda em fornecer implementações concretas para todos os métodos abstratos declarados na interface.

Uso

A palavra-chave implements é usada em uma declaração de classe para especificar uma ou mais interfaces que a classe implementará.

Sintaxe

class ClassName implements InterfaceName {
    // Class body with implementations of interface methods
}

• ClassName: O nome da classe que está implementando a interface.
• InterfaceName: O nome da interface que está sendo implementada. Você pode implementar várias interfaces separando-as por vírgulas.

Exemplos

Exemplo 1: Implementação de interface única

interface Animal {
    void makeSound();
}

public class Dog implements Animal {
    public void makeSound() {
        System.out.println("Bark");
    }

    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.makeSound();  // Outputs: Bark
    }
}

Neste exemplo, a classe Dog implementa a interface Animal. O método makeSound é definido na classe Dog para fornecer o comportamento específico de um cão.

Exemplo 2: Implementação de várias interfaces

interface Animal {
    void makeSound();
}

interface Pet {
    void play();
}

public class Cat implements Animal, Pet {
    public void makeSound() {
        System.out.println("Meow");
    }

    public void play() {
        System.out.println("Playing with a ball of yarn");
    }

    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.makeSound();  // Outputs: Meow
        cat.play();       // Outputs: Playing with a ball of yarn
    }
}

Aqui, a classe Cat implementa duas interfaces, Animal e Pet. Ele fornece implementações concretas para os métodos makeSound e play.

Exemplo 3: Implementação de interface com métodos padrão

interface Vehicle {
    void start();
    default void stop() {
        System.out.println("Vehicle stopped");
    }
}

public class Car implements Vehicle {
    public void start() {
        System.out.println("Car started");
    }

    public static void main(String[] args) {
        Car car = new Car();
        car.start();  // Outputs: Car started
        car.stop();   // Outputs: Vehicle stopped
    }
}

Neste exemplo, a interface Vehicle tem um método padrão stop. A classe Car implementa a interface Vehicle e fornece uma implementação para o método start. O método padrão stop é herdado pela classe Car.

Dicas e práticas recomendadas

• Segregação de interface: Implementar interfaces específicas para a funcionalidade da classe. Isso segue o Princípio de Segregação de Interface (ISP), tornando o código mais modular e mais fácil de manter.
• Herança múltipla: Use interfaces para obter herança múltipla em Java. Uma classe pode implementar várias interfaces, o que permite que ela herde o comportamento de várias fontes.
• Métodos padrão: Aproveite os métodos padrão nas interfaces para fornecer funcionalidade comum sem forçar todas as classes de implementação a substituí-los.
• Documentação: Documente a finalidade de cada interface e os métodos que ela declara. Isso ajuda outros desenvolvedores a entender o contrato que as classes de implementação devem cumprir.
• Consistência: Garanta convenções de nomenclatura e assinaturas de métodos consistentes entre as interfaces e suas implementações para maior clareza e facilidade de manutenção.

interface Drivable {
    void drive();
}

interface Fillable {
    void fillFuel();
}

public class Truck implements Drivable, Fillable {
    public void drive() {
        System.out.println("Truck is driving");
    }

    public void fillFuel() {
        System.out.println("Filling truck with fuel");
    }
}