Java Inheritance

Java A herança é um conceito fundamental da programação orientada a objetos que permite que uma nova classe herde propriedades e comportamentos (campos e métodos) de uma classe existente. Isso promove a reutilização do código e estabelece uma relação hierárquica entre as classes.

Conceitos-chave

• Superclasse (classe pai): A classe cujas propriedades e métodos são herdados.
• Subclasse (classe filha): A classe que herda da superclasse.

Uso

A herança é usada para criar uma nova classe que é um tipo de uma classe existente. Ele ajuda a ampliar a funcionalidade de uma classe sem modificá-la, aderindo assim ao princípio aberto/fechado do design de software.

Sintaxe

class Superclass {
    // fields and methods
}

class Subclass extends Superclass {
    // additional fields and methods
}

Exemplos

Exemplo 1: Herança básica

class Animal {
    void eat() {
        System.out.println("This animal eats food.");
    }
}

class Dog extends Animal {
    void bark() {
        System.out.println("The dog barks.");
    }
}

public class InheritanceExample {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat();  // Inherited method
        dog.bark(); // Subclass method
    }
}

Neste exemplo, Dog é uma subclasse que herda o método eat da superclasse Animal. A classe Dog também tem seu próprio método, bark.

Exemplo 2: Substituição de métodos

class Vehicle {
    void run() {
        System.out.println("The vehicle is running.");
    }
}

class Car extends Vehicle {
    @Override
    void run() {
        System.out.println("The car is running safely.");
    }
}

public class MethodOverridingExample {
    public static void main(String[] args) {
        Car car = new Car();
        car.run(); // Overridden method
    }
}

Aqui, a classe Car substitui o método run da classe Vehicle para fornecer uma implementação específica.

Exemplo 3: Usando super Keyword

class Person {
    String name = "John";

    void display() {
        System.out.println("Person's name: " + name);
    }
}

class Employee extends Person {
    String name = "Doe";

    void display() {
        System.out.println("Employee's name: " + name);
        super.display(); // Call superclass method
    }
}

public class SuperKeywordExample {
    public static void main(String[] args) {
        Employee emp = new Employee();
        emp.display();
    }
}

Neste exemplo, a palavra-chave super é usada para chamar o método display da superclasse Person a partir da subclasse Employee.

Dicas e práticas recomendadas

• Use a herança de forma criteriosa: Use a herança somente quando houver uma verdadeira relação "é um". Por exemplo, um Dog é um Animal.
• Evite hierarquias de herança profunda: Mantenha as hierarquias de herança rasas para manter a simplicidade e reduzir a complexidade.
• Prefira a composição à herança: Considere o uso de composição (relação has-a) em vez de herança quando apropriado, pois ela oferece mais flexibilidade.
• Use @Override Annotation: Sempre use a anotação @Override ao substituir métodos para melhorar a legibilidade do código e evitar erros.
• Controle de acesso: Use o modificador de acesso protected para membros da superclasse que devem ser acessíveis nas subclasses, mas não para o mundo externo.