Dominando Herança em Java: Subclasses, Superclasses e Princípios Fundamentais

Herança é o processo onde uma classe adquire as propriedades (métodos e campos) de outra. Com herança, a informação torna-se gerenciável em ordem hierárquica.

• Subclasse (classe derivada/filha) — Classe que herda as propriedades.
• Superclasse (classe base/pai) — Classe cujas propriedades são herdadas.

Palavra-chave extends

extends é a palavra-chave para herdar propriedades de uma classe.

Sintaxe

class Super {
    // ...
}

class Sub extends Super {
    // ...
}

Código de Exemplo

Exemplo demonstrando herança. My_Calculation herda addition() e Subtraction() de Calculation.

class Calculation {
    int z;

    public void addition(int x, int y) {
        z = x + y;
        System.out.println("A soma dos números: " + z);
    }

    public void Subtraction(int x, int y) {
        z = x - y;
        System.out.println("A diferença dos números: " + z);
    }
}

public class My_Calculation extends Calculation {
    public void multiplication(int x, int y) {
        z = x * y;
        System.out.println("O produto dos números: " + z);
    }

    public static void main(String args[]) {
        int a = 20, b = 10;
        My_Calculation demo = new My_Calculation();
        demo.addition(a, b);
        demo.Subtraction(a, b);
        demo.multiplication(a, b);
    }
}

Saída:

A soma dos números: 30
A diferença dos números: 10
O produto dos números: 200

Quando um objeto de My_Calculation é criado, uma cópia do conteúdo da superclasse é feita dentro dele. Por isso, usando o objeto da subclasse, acessa-se membros da superclasse.

Uma variável de referência da superclasse pode conter objeto da subclasse, mas com ela só se acessa membros da superclasse. Para acessar membros de ambas, recomenda-se criar referência da subclasse.

Calculation demo = new My_Calculation();
demo.addition(a, b);
demo.Subtraction(a, b);
// demo.multiplication(a, b); // ERRO: multiplication() pertence à subclasse

Nota: Subclasse herda todos os membros (campos, métodos, classes aninhadas). Construtores não são membros, logo não são herdados, mas construtor da superclasse pode ser invocado da subclasse.

A Palavra-chave super

super é semelhante a this. Usado para:

• Diferenciar membros da superclasse dos da subclasse, se tiverem mesmo nome.
• Invocar construtor da superclasse a partir da subclasse.

Diferenciando Membros

super.variable
super.method();

Exemplo

class Super_class {
    int num = 20;
    public void display() {
        System.out.println("Este é o display da superclasse");
    }
}

public class Sub_class extends Super_class {
    int num = 10;
    public void display() {
        System.out.println("Este é o display da subclasse");
    }

    public void my_method() {
        Sub_class sub = new Sub_class();
        sub.display();
        super.display();
        System.out.println("Valor de num na subclasse: " + sub.num);
        System.out.println("Valor de num na superclasse: " + super.num);
    }

    public static void main(String args[]) {
        Sub_class obj = new Sub_class();
        obj.my_method();
    }
}

Saída:

Este é o display da subclasse
Este é o display da superclasse
Valor de num na subclasse: 10
Valor de num na superclasse: 20

Invocando Construtor da Superclasse

Subclasse adquire automaticamente construtor padrão da superclasse. Para chamar construtor parametrizado, use super(valores).

Exemplo

class Superclass {
    int age;
    Superclass(int age) {
        this.age = age;
    }
    public void getAge() {
        System.out.println("Valor de age na superclasse: " + age);
    }
}

public class Subclass extends Superclass {
    Subclass(int age) {
        super(age);
    }

    public static void main(String args[]) {
        Subclass s = new Subclass(24);
        s.getAge();
    }
}

Saída:

Valor de age na superclasse: 24

Relacionamento IS-A

IS-A significa: "Este objeto é um tipo daquele objeto".

public class Animal { }
public class Mammal extends Animal { }
public class Reptile extends Animal { }
public class Dog extends Mammal { }

Verdades:

• Animal é superclasse de Mammal e Reptile.
• Mammal e Reptile são subclasses de Animal.
• Dog é subclasse de Mammal e Animal.

IS-A:

• Mammal IS-A Animal
• Reptile IS-A Animal
• Dog IS-A Mammal
• Dog IS-A Animal

Com extends, subclasses herdam todas as propriedades da superclasse, exceto as private.

Podemos verificar com operador instanceof:

class Animal { }
class Mammal extends Animal { }
class Reptile extends Animal { }
public class Dog extends Mammal {
    public static void main(String args[]) {
        Animal a = new Animal();
        Mammal m = new Mammal();
        Dog d = new Dog();
        System.out.println(m instanceof Animal); // true
        System.out.println(d instanceof Mammal); // true
        System.out.println(d instanceof Animal); // true
    }
}

Palavra-chave implements

implements é usado com classes para herdar propriedades de uma interface. Interfaces nunca podem ser estendidas por classes.

public interface Animal { }
public class Mammal implements Animal { }
public class Dog extends Mammal { }

Relacionamento HAS-A

Baseado no uso. Determina se uma classe TEM-UM certo recurso. Reduz duplicação de código e bugs.

public class Vehicle { }
public class Speed { }
public class Van extends Vehicle {
    private Speed sp;
}

Van HAS-A Speed. Classe separada para Speed permite reuso em múltiplas aplicações. Van esconde detalhes de implementação; usuário pede ação a Van, que faz ou delega.

Tipos de Herança

Java não suporta herança múltipla (uma classe não pode estender mais de uma classe):

// ILEGAL
public class extends Animal, Mammal { }

Porém, uma classe pode implementar múltiplas interfaces, resolvendo a limitação.