extends Keyword em Java

A palavra-chave extends em Java é usada para indicar que uma classe está herdando de uma superclasse. Esse é um aspecto fundamental da programação orientada a objetos em Java, permitindo que uma nova classe herde campos e métodos de uma classe existente.

Uso

A palavra-chave extends é usada em declarações de classe para estabelecer uma relação de herança entre duas classes.

Sintaxe

class SubclassName extends SuperclassName {
    // class body
}

• SubclassName: O nome da nova classe que você está herdando.
• SuperclassName: O nome da classe existente da qual você está herdando.

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 Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat();  // Inherited method
        dog.bark(); // Method of Dog class
    }
}

Neste exemplo, a classe Dog estende a classe Animal, herdando seu método eat. A classe Dog também tem seu próprio método bark. Quando uma instância de Dog é criada, tanto o método herdado eat quanto o método bark podem ser chamados.

Exemplo 2: Substituição de métodos

class Animal {
    void sound() {
        System.out.println("This animal makes a sound.");
    }
}

class Cat extends Animal {
    @Override
    void sound() {
        System.out.println("The cat meows.");
    }
}

public class Main {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.sound(); // Overridden method
    }
}

Aqui, a classe Cat estende a classe Animal e substitui o método sound para fornecer sua própria implementação. A anotação @Override é usada para indicar que o método está sendo substituído.

Exemplo 3: Herdando campos

class Person {
    String name;
}

class Employee extends Person {
    int employeeId;
}

public class Main {
    public static void main(String[] args) {
        Employee emp = new Employee();
        emp.name = "John Doe"; // Inherited field
        emp.employeeId = 12345;
        System.out.println("Name: " + emp.name + ", Employee ID: " + emp.employeeId);
    }
}

Neste exemplo, a classe Employee estende a classe Person e herda o campo name. A classe Employee também tem seu próprio campo employeeId.

Dicas e práticas recomendadas

• Use a herança de forma criteriosa: A herança deve ser usada quando houver uma relação clara de "é uma" entre a subclasse e a superclasse.
• Substituir métodos adequadamente: Use a anotação @Override ao substituir métodos para garantir que você esteja substituindo corretamente um método da superclasse.
• Evite hierarquias de herança profunda: Hierarquias de herança profundas podem dificultar a compreensão e a manutenção do código. Prefira a composição à herança quando for apropriado.
• Acesso aos métodos da superclasse: Use super para chamar métodos da superclasse a partir da subclasse, se necessário.

  class Animal {
      void eat() {
          System.out.println("This animal eats food.");
      }
  }
  
  class Dog extends Animal {
      void eat() {
          super.eat(); // Call superclass method
          System.out.println("The dog eats dog food.");
      }
  }

• Encadeamento de construtores: Use super() para chamar o construtor da superclasse a partir do construtor da subclasse.

  class Person {
      Person(String name) {
          System.out.println("Person's name is " + name);
      }
  }
  
  class Employee extends Person {
      Employee(String name, int employeeId) {
          super(name); // Call superclass constructor
          System.out.println("Employee ID is " + employeeId);
      }
  }

Entendendo a herança

A herança é um conceito fundamental na programação orientada a objetos (OOP) que estabelece uma relação entre uma superclasse mais geral e uma subclasse mais específica. Essa relação permite que a subclasse herde atributos e métodos da superclasse, promovendo a reutilização do código e a estruturação lógica.

• Relacionamento Is-A: A palavra-chave extends significa uma relação "is-a". Por exemplo, um Dog é um Animal, e um Employee é um Person.
• Herança única: O Java oferece suporte à herança única, o que significa que uma classe só pode estender uma outra classe para evitar ambiguidade e complexidade.
• Combinação de extensões e suplementos: Uma classe pode estender outra classe e implementar várias interfaces simultaneamente. Essa combinação permite que uma classe herde de uma superclasse e adira a vários contratos definidos por interfaces.

class Animal {
    void move() {
        System.out.println("This animal moves.");
    }
}

interface Pet {
    void play();
}

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

    public void play() {
        System.out.println("The dog plays.");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.move();  // Inherited method from Animal
        dog.bark();  // Method of Dog class
        dog.play();  // Implemented method from Pet interface
    }
}

Neste exemplo, a classe Dog estende a classe Animal e implementa a interface Pet, demonstrando a combinação de herança e implementação de interface.