Herança, interfaces e polimorfismo em Java

A herança cria uma subclasse a partir de uma superclasse existente. Em class Student extends Person, todo estudante é uma pessoa. Um objeto estudante reúne seu estado de pessoa e seu estado adicional de estudante em um único objeto.

Acrescente as partes específicas do estudante

Aqui estão uma pequena superclasse e uma subclasse:

class Person {
    private String name;
    public Person(String name) { this.name = name; }
    public String getName() { return name; }
}

class Student extends Person {
    private int credits;
    public Student(String name) { super(name); }
    public void study() { credits += 5; }
    public int getCredits() { return credits; }
}

Student herda getName(). Ela acrescenta um campo de créditos e dois métodos. Após Student s = new Student("Ada Lovelace");, o campo de créditos começa em 0. Duas chamadas a s.study() elevam seu valor primeiro para 5 e depois para 10. s.getName() continua retornando “Ada Lovelace”: o método herdado lê o campo privado declarado em Person.

A instrução super(name) passa o nome ao construtor de Person. Construtores não são herdados, portanto Student declara seu próprio construtor. Uma subclasse pode acrescentar métodos e sobrescrever comportamento herdado, mas não pode remover um método público herdado de sua API pública.

Identifique quais membros são acessíveis

Membros privados não são herdados. O campo privado name ainda existe dentro de cada estudante, mas Student não pode lê-lo diretamente. Manter o campo privado e fornecer um método de acesso permite que Person controle seus próprios dados. Entre pacotes, o acesso a membros de instância protected tem uma restrição adicional: o código da subclasse acessa o membro por meio de si mesmo ou de uma referência do tipo da própria subclasse, não por meio de uma referência arbitrária da superclasse.

Teste a relação antes de estender

Java permite uma superclasse direta por classe. Uma cadeia como GraduateStudent extends Student e Student extends Person é válida; extends Student, Teacher não é. Uma classe sem superclasse explícita estende Object. A própria Object não tem superclasse.

Use o teste “é um”: todo objeto da subclasse pode ser usado onde se espera a superclasse? Um caminhão é um veículo. Um cliente tem um endereço, mas um cliente não é um endereço. Para essa segunda relação, use composição:

class Customer {
    private Address address;
}

Aqui Address é outra classe. O campo permite que um cliente use um endereço sem afirmar que é um. Estender uma classe apenas para aproveitar um método conveniente também implica herdar todo o seu contrato público. Por fim, uma classe final não pode ser estendida. Como String é final, class ShortString extends String não compila.

Um construtor de subclasse deve organizar a construção da parte da superclasse do mesmo objeto. Ele pode chamar um construtor da superclasse com super(...) ou delegar a outro construtor da própria classe com this(...).

Escolha o construtor da superclasse

class Person {
    private final String name;
    Person(String name) { this.name = name; }
}
class Student extends Person {
    private final String studentId;
    Student(String name, String studentId) {
        super(name);
        this.studentId = studentId;
    }
    Student(String name) {
        this(name, "no id yet");
    }
}

O construtor com dois argumentos passa o nome a Person e armazena o identificador. O construtor com um argumento delega a ele. Um construtor contém no máximo uma invocação explícita de construtor: this(...) ou super(...). Seguir a cadeia de this(...) leva, por fim, a um construtor que invoca super(...).

Se nenhuma das duas for escrita, Java insere super(). Aqui isso falha porque Person tem apenas um construtor que exige um nome. Declarar qualquer construtor impede que Java forneça um construtor padrão sem argumentos. Uma classe sem construtor declarado recebe um construtor padrão que chama super().

Escrever new Person(name) dentro de Student faz outra coisa: constrói um objeto separado. Isso não inicializa o estado de pessoa do estudante atual nem substitui a chamada obrigatória ao construtor da superclasse.

Acompanhe a inicialização em ordem

class Base {
    Base() { System.out.println("Base ready"); }
}
class Middle extends Base {
    Middle() { System.out.println("Middle ready"); }
}
class Top extends Middle {
    Top() { super(); System.out.println("Top ready"); }
}

new Top() entra na cadeia de construtores até Object. À medida que as chamadas retornam, a saída é “Base ready”, “Middle ready” e depois “Top ready”. Os inicializadores de campo de cada classe são executados após o retorno do construtor de sua superclasse e antes do restante do corpo do construtor dessa classe.

Um método que pode ser sobrescrito, quando chamado por um construtor da superclasse, já pode executar uma sobrescrita da subclasse. Se essa sobrescrita ler um campo de referência da subclasse cuja atribuição ainda não foi executada, ela encontrará null, mesmo que o campo tenha um inicializador na declaração. Limite o trabalho do construtor à inicialização do estado; evite chamadas a métodos que as subclasses possam sobrescrever.

Reconheça a mudança no Java 25

No Java 25, um construtor pode validar parâmetros antes de sua invocação explícita de construtor:

Student(String name, String studentId, int credits) {
    if (credits < 0) {
        throw new IllegalArgumentException("negative credits");
    }
    super(name);
    this.studentId = studentId;
}

O Java 25 também permite atribuições simples antecipadas a campos declarados na classe atual sem inicializadores na declaração. Ele ainda proíbe ler os campos do objeto atual, chamar seus métodos de instância ou passar this antes da invocação. Para níveis padrão da linguagem anteriores ao Java 25, mantenha super(...) ou this(...) em primeiro lugar. O Java 22–24 ofereceu formas anteriores como recursos de prévia.

Uma sobrescrita fornece a uma subclasse sua própria implementação de um método de instância herdado. Seu nome e seus tipos de parâmetros correspondem aos do método original, permitindo que quem o chama continue usando a mesma operação.

Amplie um método que já funciona

Suponha que a remuneração anual de um funcionário seja de doze pagamentos mensais. Um gerente também recebe um bônus anual:

class Employee {
    private final double monthlySalary;
    Employee(double monthlySalary) {
        this.monthlySalary = monthlySalary;
    }
    public double yearlyPay() { return 12 * monthlySalary; }
}
class Manager extends Employee {
    private final double bonus;
    Manager(double monthlySalary, double bonus) {
        super(monthlySalary);
        this.bonus = bonus;
    }
    @Override
    public double yearlyPay() {
        return super.yearlyPay() + bonus;
    }
}

Para new Manager(3000.0, 5000.0), a chamada à superclasse retorna 36.000,0. Somar 5000,0 resulta em 41.000,0. super.yearlyPay() seleciona deliberadamente a implementação da superclasse. O método da superclasse continua disponível dentro da subclasse, embora chamadas comuns no objeto gerente executem a sobrescrita.

Escrever return yearlyPay() + bonus; chama novamente o próprio método do gerente. Nenhuma chamada termina, portanto a execução acaba falhando com StackOverflowError. A ausência de super. muda o significado da chamada.

Deixe o compilador verificar a assinatura

Coloque @Override acima de cada método que sobrescreve outro. Um erro de digitação como yearlypay() ou um parâmetro adicional causa então um erro de compilação. Sem a anotação, Java pode aceitar um novo método que quem chama o método nunca usa.

Uma sobrescrita válida segue estas regras:

• Seus tipos de parâmetros correspondem exatamente.
• Seu tipo de retorno é o mesmo ou um subtipo quando retorna um tipo de objeto. Esse estreitamento permitido é um tipo de retorno covariante.
• Seu acesso é pelo menos tão aberto quanto o do método herdado.
• Ela não acrescenta exceções verificadas que a declaração herdada proíbe.

Por exemplo, public String toString() não pode ser substituído por String toString() com acesso de pacote. Quem já chama o método deve manter o acesso.

Distinga sobrescrita, sobrecarga e ocultação

role() e role(String language) são sobrecargas; o segundo não substitui o primeiro. A escolha da sobrecarga usa os tipos declarados dos argumentos em tempo de compilação. Métodos estáticos também são selecionados pelo tipo usado em tempo de compilação, portanto não são sobrescritos dinamicamente.

Um método privado não é herdado; um método de mesmo nome na subclasse é independente. Um método final não pode ser sobrescrito, e construtores não podem ser sobrescritos. Além de compilar, o método ainda deve cumprir seu propósito original. Uma sobrescrita de gerente que retorne a remuneração mensal prejudicaria o código que totaliza a remuneração anual, mesmo que sua assinatura estivesse correta.

Toda classe Java estende Object direta ou indiretamente. Vetores também são objetos. Essa raiz compartilhada fornece métodos como toString(), equals(Object), hashCode() e getClass(), mesmo quando uma classe não declara nenhum deles.

Substitua a descrição exibida por padrão

O Object.toString() herdado produz um nome de classe, @ e o código de dispersão do objeto em hexadecimal. Um texto como “school.Person@1b6d3586” identifica a classe, mas não explica os dados da pessoa. O número pode mudar entre execuções e não é um endereço de memória garantido por Java.

Uma sobrescrita útil mostra os campos de que os leitores precisam. Aqui um estudante herdou getName() e armazena um campo credits:

@Override
public String toString() {
    return getName() + " (" + credits + " credits)";
}

Para uma estudante chamada Ada Lovelace com 10 créditos, System.out.println(s) exibe “Ada Lovelace (10 credits)”. A chamada de impressão obtém automaticamente o texto do objeto. A concatenação de cadeias de caracteres também faz isso: "Student: " + s inclui a mesma descrição.

Para uma referência nula, a impressão e a concatenação produzem “null”. Uma chamada explícita s.toString() quando s é nulo lança NullPointerException, pois não há objeto para receber essa chamada.

Se Person.toString() já retorna o nome da pessoa, uma subclasse pode usá-lo como base:

@Override
public String toString() {
    return super.toString() + ", student id " + studentId;
}

Para o identificador “S-17”, isso produz “Ada Lovelace, student id S-17”. A utilidade de super.toString() depende do que a superclasse realmente retorna. Se ela ainda usa a versão de Object, contribui com o texto padrão de classe e código de dispersão.

Mantenha separadas a identidade e as informações de classe

Object.equals(Object) compara a identidade: retorna verdadeiro quando ambas as referências se referem ao mesmo objeto. Dois objetos separados new Person("Ada") não são iguais segundo essa implementação herdada, apesar de terem nomes iguais. Classes como String, Integer e ArrayList fornecem sobrescritas baseadas em valor.

getClass() informa a classe real em tempo de execução:

Person p = new Student("Ada Lovelace");
System.out.println(p.getClass().getSimpleName());

Isso exibe “Student” quando Student tem o construtor mostrado. O tipo declarado da variável não altera a classe do objeto. getClass() é final e não pode ser sobrescrito.

hashCode() dá suporte a coleções baseadas em hash. Outros métodos de Object incluem o método protegido clone() e os métodos de coordenação de threads wait(), notify() e notifyAll().

Verifique a grafia exata

Java distingue toString() de tostring(). Um método toString(String prefix) é uma sobrecarga, portanto a impressão não o chama. Ambos os erros são detectados por @Override. Uma representação textual também não define igualdade: dois objetos podem exibir o mesmo texto e ainda assim ser considerados diferentes.

Dois objetos podem representar o mesmo valor sem ser o mesmo objeto. Um catálogo pode considerar dois objetos de livro iguais quando seus códigos de catálogo e suas edições correspondem. Defina essa regra sobrescrevendo equals(Object) e mantenha o cálculo do código de dispersão consistente com ela.

Compare os campos que definem o valor

import java.util.Objects;

final class Book {
    private final String code;
    private final int edition;
    Book(String code, int edition) {
        this.code = code;
        this.edition = edition;
    }
    @Override
    public boolean equals(Object other) {
        if (this == other) return true;
        if (!(other instanceof Book b)) return false;
        return edition == b.edition && Objects.equals(code, b.code);
    }
    @Override
    public int hashCode() {
        return Objects.hash(code, edition);
    }
}

A verificação de identidade aceita rapidamente o mesmo objeto. A verificação de tipo rejeita um objeto sem relação com a classe ou uma referência nula e então apresenta b como um Book. Edições primitivas usam ==; Objects.equals compara códigos com segurança mesmo quando um código é nulo. Dois livros com código “B-1042” e edição 2 são considerados iguais. A edição 3 representa um valor diferente.

O parâmetro deve ser Object. Escrever equals(Book other) acrescenta uma sobrecarga; isso mantém o equals(Object) herdado. Código da biblioteca que chama essa assinatura continuaria comparando a identidade. @Override faz a declaração incorreta falhar em tempo de compilação.

Siga os compromissos da igualdade

Para referências não nulas, a igualdade deve ser:

• Reflexiva: um objeto é igual a si mesmo.
• Simétrica: inverter os dois objetos produz a mesma resposta.
• Transitiva: se um objeto é igual a um segundo e o segundo é igual a um terceiro, o primeiro é igual ao terceiro.
• Consistente: comparações repetidas concordam enquanto os dados comparados permanecem inalterados.

Um objeto também deve ser considerado diferente de null. Objetos iguais devem retornar códigos de dispersão iguais. Objetos diferentes podem compartilhar um código de dispersão: uma colisão de hash não estabelece igualdade. Derive o código de dispersão dos mesmos campos usados na igualdade, como Objects.hash(code, edition) faz aqui.

Uma coleção baseada em hash usa o código de dispersão para localizar candidatos antes de verificar a igualdade. Sobrescrever apenas equals pode fazer um conjunto manter livros iguais separados ou fazer um mapa não encontrar uma chave igual. Alterar um campo usado no cálculo do código de dispersão enquanto seu objeto está armazenado como chave pode deixar esse objeto armazenado sob o código antigo.

Proteja a simetria entre subclasses

Suponha que uma Book extensível aceite qualquer instanceof Book, enquanto Ebook acrescente o tamanho do arquivo à igualdade e aceite apenas ebooks. Um livro pode aceitar um ebook com o mesmo código e a mesma edição, mas o ebook rejeita o livro. A comparação perdeu a simetria.

Uma abordagem exige classes correspondentes em tempo de execução, verificando se a referência é nula antes de getClass(). Outra torna a igualdade da superclasse final para que as subclasses não possam ampliar a regra de igualdade. Uma classe de valor final, como acima, evita completamente a igualdade entre subclasses. Records geram igualdade e códigos de dispersão a partir de seus componentes; constantes de enumeração já têm igualdade baseada em identidade, adequada a seus valores fixos.

Uma classe abstrata é uma classe base que não pode ser instanciada diretamente. Ela pode conter campos comuns e métodos que já funcionam, deixando operações selecionadas para as subclasses completarem.

Deixe uma operação obrigatória abstrata

abstract class Shape {
    private final String name;
    Shape(String name) { this.name = name; }
    public abstract double area();
    public String describe() {
        return name + " with area " + area();
    }
}
class Rectangle extends Shape {
    private final double width;
    private final double height;
    Rectangle(double width, double height) {
        super("rectangle");
        this.width = width;
        this.height = height;
    }
    @Override
    public double area() { return width * height; }
}

area() tem uma assinatura e um ponto e vírgula, sem corpo. Ele estabelece o que toda forma concreta deve fornecer. Como Shape contém um método abstrato, a classe também deve ser abstrata. Rectangle fornece a implementação que falta e pode ser instanciada.

Para new Rectangle(3.0, 4.0), o construtor da superclasse armazena “rectangle”. O construtor da subclasse armazena as dimensões. Sua área é de 12,0 metros quadrados quando as dimensões estão em metros. Chamar describe() retorna “rectangle with area 12.0”. A chamada a area() no método herdado executa a implementação do retângulo.

Use construtores e métodos concretos normalmente

Uma classe abstrata pode ter campos, construtores e métodos com corpo, com os níveis de acesso usuais. Seu construtor é executado como parte da criação de um objeto de subclasse. new Shape() é proibido mesmo que exista um construtor correspondente; new Rectangle(3.0, 4.0) é válido.

Uma segunda subclasse pode usar a mesma descrição herdada enquanto calcula a área de outra forma. Uma implementação de círculo retorna Math.PI * radius * radius. Para um raio de 1,5 m, o cálculo é π vezes 2,25, aproximadamente 7,07 metros quadrados. O método compartilhado describe() não precisa de um ramo específico para círculos.

Uma variável ainda pode ter o tipo abstrato: Shape s = new Rectangle(3.0, 4.0);. Java proíbe construir a classe abstrata, não referenciar um objeto concreto por meio dela.

Faça o trabalho ausente causar um erro de compilação

Toda subclasse concreta deve fornecer ou herdar implementações de todos os métodos abstratos. Uma subclasse que deixa alguns incompletos também deve ser declarada abstrata. Retornar 0 de um area() provisório permitiria que uma subclasse concreta incompleta compilasse e produzisse silenciosamente resultados errados. Declarar area() abstrato torna esse trabalho ausente visível ao compilador.

Métodos abstratos não podem ser privados, estáticos ou final: cada um desses modificadores impediria a sobrescrita da subclasse que fornece a operação. Uma classe abstrata pode não conter métodos abstratos; nesse caso, o modificador apenas impede a construção direta. Use esse tipo de classe base quando suas subclasses passarem no teste “é um” e se beneficiarem de estado ou código compartilhado.

Uma interface nomeia uma capacidade que várias classes podem fornecer. Ela estabelece os métodos disponíveis por meio dessa capacidade sem exigir que as classes compartilhem os mesmos campos de instância ou a mesma superclasse.

Declare e implemente os métodos

interface Chargeable {
    int batteryPercent();
    void charge(int minutes);
}
class Phone implements Chargeable {
    private int battery;
    Phone(int battery) { this.battery = battery; }
    @Override
    public int batteryPercent() { return battery; }
    @Override
    public void charge(int minutes) {
        battery = Math.min(100, battery + 2 * minutes);
    }
}

Os métodos abstratos da interface são implicitamente públicos. Os métodos que os implementam devem ser explicitamente públicos; omitir esse modificador reduziria o acesso e causaria uma falha de compilação. Uma classe concreta deve fornecer ou herdar implementações públicas adequadas de todos os métodos abstratos. Uma classe abstrata que implementa a interface pode deixar alguns para suas subclasses.

Para um telefone com 35 por cento de carga, charge(20) acrescenta 40 pontos percentuais e deixa a carga em 75 por cento. Mais 20 minutos levariam a 115 antes da limitação, portanto Math.min armazena 100. Uma ElectricScooter pode implementar a mesma interface acrescentando apenas um ponto por minuto: começando com 50 por cento, ela chega a 70 após 20 minutos. A interface define a operação disponível, enquanto a classe fornece seu comportamento.

Use a interface como tipo

Chargeable device = new Phone(35);
device.charge(20);
System.out.println(device.batteryPercent());

Isso exibe 75. Quem faz a chamada pode usar os métodos da interface e os métodos públicos disponíveis em todos os objetos. Operações exclusivas de Phone não estão disponíveis por meio de device, a menos que a interface declarada as exponha.

Interfaces também podem ser tipos de parâmetros, de retorno e de elementos de listas. Um método que aceita Chargeable pode trabalhar com um telefone ou uma scooter sem conhecer a organização de seus campos. A biblioteca Java usa a mesma abordagem: List tem implementações como ArrayList e LinkedList; Runnable declara run(); Comparable declara uma comparação natural.

Combine mais de uma capacidade

Uma classe estende uma classe e pode implementar várias interfaces. A ordem é class Phone extends Device implements Chargeable, Connectable. Uma interface pode estender várias interfaces: interface SmartDevice extends Chargeable, Connectable. As classes que a implementam devem então fornecer todas as operações abstratas herdadas.

Uma interface não tem construtores nem campos de instância. new Chargeable() não compila. Um campo declarado como int FULL = 100; é implicitamente uma constante public static final, lida como Chargeable.FULL.

Um método abstrato de interface não fornece código funcional. Sua implementação pode vir da própria classe ou de um método público herdado da superclasse. Métodos padrão são os métodos de interface que podem fornecer comportamento de instância herdado.

Interfaces podem fornecer código funcional além de declarações de métodos abstratos. O modificador do método determina se os objetos das classes que implementam a interface o herdam, se quem o chama usa o nome da interface ou se apenas código dentro da interface pode usá-lo.

Construa comportamento padrão a partir do contrato

interface Chargeable {
    int batteryPercent();
    void charge(int minutes);
    default boolean needsCharge() {
        return batteryPercent() < 20;
    }
    static int clamp(int percent) {
        return Math.max(0, Math.min(100, percent));
    }
}

Um método padrão é um método público de instância com corpo. Um telefone que informa 15 por cento herda needsCharge() e retorna verdadeiro. Com 20 por cento, retorna falso. O método padrão chama a operação abstrata batteryPercent(); ele não lê um campo privado do telefone. Uma classe pode sobrescrever o método com sua própria implementação pública.

Um método estático de interface pertence à interface: Chargeable.clamp(130) retorna 100 e Chargeable.clamp(-5) retorna 0. As classes que implementam a interface não o herdam, portanto Phone.clamp(130) não é uma chamada válida a esse método. Métodos padrão e estáticos de interface foram introduzidos no Java 8.

Desde o Java 9, uma interface também pode declarar métodos privados para compartilhar código auxiliar entre seus próprios métodos. Um método auxiliar privado de instância dá suporte a métodos padrão; um método auxiliar privado estático também pode dar suporte a métodos estáticos. As classes que implementam a interface não podem chamar esses métodos auxiliares diretamente.

Resolva conflitos entre métodos padrão

Duas interfaces sem relação entre si podem fornecer a mesma assinatura:

interface Lamp {
    default String describe() { return "lamp"; }
}
interface Speaker {
    default String describe() { return "speaker"; }
}
class SmartLamp implements Lamp, Speaker {
    @Override
    public String describe() {
        return Lamp.super.describe() + " and "
             + Speaker.super.describe();
    }
}

Sem a sobrescrita, SmartLamp tem um conflito e não compila. As chamadas qualificadas InterfaceName.super.method() selecionam os métodos padrão individuais de suas superinterfaces diretas. Essa implementação retorna “lamp and speaker”.

Uma declaração abstrata na superclasse também pode exigir que uma subclasse concreta implemente o método; um método padrão de interface não elimina essa obrigação.

Considere as classes que já implementam a interface

Acrescentar um método abstrato exige que cada classe concreta que implementa a interface forneça ou herde uma implementação correspondente. Um método padrão muitas vezes evita essa alteração ao fornecer comportamento funcional, mas pode introduzir um conflito com outro método herdado. Métodos padrão ajudam uma interface a evoluir; as regras de herança ainda determinam se as classes resultantes compilam.

Uma classe abstrata e uma interface podem definir métodos obrigatórios. A escolha depende da relação entre os objetos e de a implementação precisar ou não de estado de instância compartilhado.

Compare o que cada uma oferece

Campos de interface são constantes public static final, não dados de cada objeto. Métodos auxiliares privados de interface dão suporte aos próprios métodos funcionais da interface; eles não criam estado privado para cada objeto que a implementa.

Coloque estado estreitamente relacionado em uma classe abstrata

Um programa de desenho tem círculos, retângulos e triângulos. Cada forma armazena um nome e uma posição, e cada uma calcula sua área de modo diferente. Uma Shape abstrata pode manter os campos comuns e o construtor, fornecer métodos funcionais de movimento ou descrição e declarar area() como abstrato.

Todas as formas concretas são tipos de Shape, portanto outro código pode pedir uma forma e receber qualquer uma delas. Da mesma forma, uma Enemy abstrata pode manter pontos de vida e um método compartilhado takeDamage(int points), deixando o movimento para classes específicas de inimigos. O estado compartilhado dá a essas classes base uma tarefa útil.

Coloque uma capacidade transversal em uma interface

O mesmo programa de desenho pode exportar formas, rótulos de texto e imagens. Exportar não torna um rótulo de texto uma forma, e esses objetos já podem precisar de superclasses diferentes. Uma interface Exportable pode declarar String exportText(). Cada classe implementa a operação usando seus próprios dados.

Uma classe pode combinar as duas funções: class Circle extends Shape implements Exportable. A superclasse fornece o estado da forma e código compartilhado; a interface permite que o círculo seja usado pelo código de exportação. Uma classe que implementa várias interfaces se compromete a oferecer várias capacidades sem herdar delas campos de instância.

Combine um contrato com uma implementação parcial

Uma classe abstrata pode implementar uma interface e completar apenas alguns métodos. As subclasses concretas completam as operações restantes. List e AbstractList do Java usam essa organização; ArrayList estende AbstractList. Quem faz as chamadas pode depender da interface enquanto quem implementa reutiliza uma classe base quando ela é adequada.

Por exemplo, List<String> names = new ArrayList<>(); permite que quem faz as chamadas acrescente, leia e remova nomes por meio de List. Substituir o inicializador por new LinkedList<>() preserva essas chamadas. Um parâmetro declarado como ArrayList<String> rejeitaria um LinkedList<String>, mesmo que precisasse apenas de operações de lista.

Uma classe abstrata que contém apenas métodos abstratos ainda ocupa a única posição de superclasse da subclasse. Ela não é intercambiável com uma interface. Escolha a interface quando apenas o contrato comum for necessário e acrescente uma classe base quando implementações relacionadas se beneficiarem de estado ou código compartilhado.

O polimorfismo permite que uma referência geral aponte para objetos de diferentes subtipos. O objeto mantém todo o seu estado e comportamento; a referência oferece a quem faz chamadas uma visão específica das operações disponíveis.

Identifique os dois tipos

Person p = new Student("Ada Lovelace", "S-17");

O tipo declarado, também chamado de tipo estático, é Person: ele aparece na declaração da variável. O tipo real, ou tipo em tempo de execução, é Student: essa é a classe instanciada por new. A classe real do objeto não muda após a construção.

Atribuir uma referência de estudante a uma referência de pessoa é uma conversão para supertipo. Ela é automática e segura porque todo estudante é uma pessoa. O mesmo estudante também pode ser referenciado por uma variável Object. Um objeto que implementa uma interface pode ser convertido para o tipo dessa interface, como em Chargeable c = new Phone(35);.

Nenhum dado do estudante é apagado pela atribuição. Continua existindo um único objeto estudante com seu identificador de estudante, dados de pessoa herdados e métodos sobrescritos. Atribuir a ele uma referência mais geral muda o que o compilador permite acessar por meio dessa referência.

Verifique as chamadas pelo tipo declarado

Se Person declara getName(), então p.getName() compila. Se apenas Student declara getStudentId(), então p.getStudentId() não compila. O compilador verifica a API de Person mesmo quando o inicializador claramente cria um estudante.

A atribuição inversa Student s = p; não é aceita sem uma conversão explícita de tipo. Uma referência de pessoa pode apontar para uma pessoa que não é estudante. Essa restrição protege o código de tratar um objeto como um subtipo ao qual ele não pertence.

Permita que parâmetros e listas aceitem vários subtipos

Um método static void printCard(Person person) pode receber um objeto Person, Student ou Teacher, supondo que os dois últimos estendam Person. Seu código pode depender do contrato de pessoa. Um tipo de retorno também pode ser geral, por exemplo, um método que retorna um Shape.

Uma lista com um tipo geral de elemento pode armazenar diferentes classes de formas:

List<Shape> shapes = new ArrayList<>();
shapes.add(new Circle(1.5));
shapes.add(new Rectangle(3.0, 4.0));
for (Shape shape : shapes) {
    System.out.println(shape.area());
}

Aqui List e ArrayList vêm de java.util, e cada forma concreta fornece area(). O laço usa apenas essa operação comum.

Uma List<Circle> não é uma List<Shape>. Se fosse, um código que a recebesse como lista de formas poderia acrescentar um retângulo a uma lista que deveria conter apenas círculos. Quando um método exige List<Shape>, crie a lista com esse tipo de elemento desde o início.

Uma chamada de método é resolvida em duas etapas. Em tempo de compilação, Java verifica os tipos declarados e escolhe uma assinatura de método. Em tempo de execução, a vinculação dinâmica escolhe a implementação sobrescrita do método de instância para a classe real do objeto.

Acompanhe uma chamada dentro de um método herdado

class A {
    String who() { return "A"; }
    String hello() { return "Hello from " + who(); }
}
class B extends A {
    @Override String who() { return "B"; }
}
class C extends B { }

Para A x = new C();, x.hello() é permitido porque A declara hello(). A classe C não tem uma sobrescrita de hello(), nem B, portanto Java executa a implementação em A.

Dentro desse método, who() significa this.who(). O objeto receptor continua sendo o objeto C. Java procura a partir de C e encontra a implementação de who() mais próxima em B. O resultado é “Hello from B”. Entrar em um método herdado não transforma o objeto receptor em um objeto da superclasse.

Escolha uma sobrecarga antes de escolher uma sobrescrita

static String kind(Object value) { return "object"; }
static String kind(String value) { return "string"; }

Dentro de uma classe que contém esses métodos, Object value = "hi"; kind(value) seleciona kind(Object) e retorna “object”. O tipo declarado da variável é Object; Java não reconsidera as sobrecargas usando a cadeia de caracteres real em tempo de execução.

Para uma chamada de instância, o despacho em tempo de execução ainda pode escolher uma sobrescrita da assinatura já selecionada. Ele não pode mudar para outra sobrecarga que apenas pareça mais específica para o argumento real. Primeiro identifique a assinatura, depois procure sua sobrescrita.

Reconheça chamadas e membros que não usam esse despacho

Se P declara String label = "P"; e Q extends P declara seu próprio String label = "Q";, então P p = new Q(); p.label lê “P”. Campos são ocultados, não sobrescritos. Ambos os campos existem no objeto. Evite reutilizar nomes de campos herdados, pois o tipo da referência pode fazer acessos aparentemente idênticos lerem estados diferentes.

super.method() seleciona a implementação da superclasse, incluindo uma que a superclasse herde. Se o próprio método selecionado fizer uma chamada comum em this, essa chamada interna ainda poderá ser despachada para uma sobrescrita da subclasse.

Uma referência geral às vezes precisa acessar uma operação que pertence apenas a um subtipo. Uma conversão para subtipo informa ao compilador que deve tratar a referência como esse subtipo. Em tempo de execução, Java verifica se o objeto já tem esse tipo.

Entenda o que uma conversão explícita muda

Suponha que Person p se refira a um estudante. Student s = (Student) p; permite s.getStudentId(). Ambas as variáveis continuam se referindo ao mesmo objeto. A conversão não o copia, não altera sua classe real nem acrescenta campos de estudante a uma pessoa comum.

Se p de fato se referir a new Person("Grace Hopper"), essa conversão lança ClassCastException. O compilador aceita a possível relação de pessoa para estudante, mas o objeto em tempo de execução ainda deve satisfazê-la. Uma conversão explícita entre classes que não podem ter relação, como uma referência Person convertida para a classe final Integer, falha em tempo de compilação.

Isso difere de uma conversão de tipo primitivo: (int) 3.9 cria o valor inteiro 3. Uma conversão explícita de referência apenas verifica e altera o tipo pelo qual uma referência existente é usada.

Combine o teste e a nova variável

Desde o Java 16, a correspondência de padrões torna o caso seguro mais conciso:

static void showStudentId(Person person) {
    if (person instanceof Student student) {
        System.out.println(student.getStudentId());
    }
}

O teste é verdadeiro para um estudante ou um objeto de uma subclasse de estudante. A variável student está disponível dentro do bloco, onde se sabe que o teste teve sucesso. Uma pessoa comum pula o bloco. Uma referência nula também torna o teste falso, portanto o bloco nunca tenta chamar um método em null.

A forma antiga testa person instanceof Student e depois declara Student student = (Student) person; dentro do ramo em que o teste teve sucesso. Ambas as formas protegem a conversão. Testar um objeto sem relação em outro ponto não protege uma conversão de person; o teste e a conversão devem envolver a mesma referência.

Uma conversão para supertipo não precisa de conversão explícita. Person person = student; já compila e não pode falhar por incompatibilidade de tipos. Uma conversão explícita de null para um tipo de referência compatível produz null; usar esse resultado para chamar um método de instância ainda falha com NullPointerException.

Decida se um teste de tipo é necessário

Testes de tipo são adequados para código que recebe um Object, como equals(Object other), ou precisa de uma operação exclusiva de um subtipo, como um identificador de estudante. Eles também podem ajudar ao trabalhar com classes que não podem ser alteradas.

Uma cadeia repetida de testes de tipo para uma operação compartilhada é um problema diferente. Se o código verifica cada classe de forma para calcular sua área, cada forma acrescentada exige outro ramo. Declarar area() em Shape e deixar que as subclasses o implementem permite que quem faz a chamada use shape.area().

Uma conversão explícita não pode tornar uma operação comum ausente disponível em todos os subtipos. Coloque o comportamento compartilhado no contrato comum e reserve um teste de subtipo para o trabalho que realmente exige esse subtipo específico.

Um método continua útil com novas classes quando seu parâmetro expõe exatamente as operações de que ele precisa. Quem faz a chamada fornece os objetos; a vinculação dinâmica fornece seu comportamento individual.

Some áreas sem ramos específicos por classe

static double totalArea(List<Shape> shapes) {
    double total = 0;
    for (Shape shape : shapes) {
        total += shape.area();
    }
    return total;
}

Com um círculo de raio 1,5 m, um retângulo de dimensões 3,0 m e 4,0 m e um triângulo de base 4,0 m e altura 2,5 m, as áreas são aproximadamente 7,06858, 12,0 e 5,0 metros quadrados. Somar a área não arredondada do círculo produz aproximadamente 24,07 metros quadrados. Cada objeto fornece seu próprio area().

Acrescentar uma classe Triangle não exige editar o laço. A nova classe implementa a operação de forma existente. Um resultado negativo violaria o contrato da área mesmo que a sobrescrita compilasse; o código geral depende tanto do significado da operação quanto de sua assinatura.

A mesma abordagem funciona com uma interface. Um método chargeAll(List<Chargeable> devices, int minutes) percorre os dispositivos e chama device.charge(minutes). Após 20 minutos, o telefone que começa com 35 por cento chega a 75 por cento e a scooter que começa com 50 por cento chega a 70 por cento. O laço nunca seleciona uma regra de carregamento por conta própria.

Deixe quem chama escolher uma implementação de lista

Um parâmetro List<Shape> aceita tanto um ArrayList<Shape> quanto um LinkedList<Shape>. Um parâmetro ArrayList<Shape> rejeita a lista encadeada, apesar de precisar apenas de operações de lista. Use o tipo mais geral que forneça os métodos necessários; declarar tudo como Object seria geral demais, pois ele não tem area() nem operações de lista.

Torne objetos ordenáveis com Comparable

Comparable<T> define a ordem natural de um objeto. O resultado de seu compareTo é negativo quando este objeto vem antes do outro, zero para um empate na ordenação e positivo quando vem depois. O sinal do resultado é o que importa; ele não precisa ser exatamente −1 ou 1.

record Runner(String name, int seconds)
        implements Comparable<Runner> {
    @Override
    public int compareTo(Runner other) {
        return Integer.compare(seconds, other.seconds);
    }
}

Uma lista modificável com Mia em 3605 s, Ken em 3490 s e Ana em 3720 s passa a ser Ken, Mia, Ana após Collections.sort(runners). list.sort(null) também usa a ordem natural. Construa uma lista modificável com new ArrayList<>(List.of(...)); tentar ordenar o resultado não modificável de List.of(...) lança UnsupportedOperationException.

Use Integer.compare em vez de subtrair os valores. A subtração pode sofrer estouro para valores grandes com sinais opostos e retornar o sinal errado. A mesma ideia se aplica a Double.compare para campos decimais. Neste exemplo de corredores, tempos iguais empatam na ordenação mesmo que os nomes sejam diferentes, portanto um empate na comparação e a igualdade de objetos não precisam significar a mesma coisa. Prefira uma ordem natural cujo resultado zero concorde com a igualdade; documente uma diferença intencional.

Um enum dá a um conjunto fixo de opções nomeadas um tipo próprio. enum Size { SMALL, MEDIUM, LARGE } permite Size size = Size.MEDIUM;. Ele impede que quem chama um método que exige Size passe a cadeia de caracteres escrita incorretamente “MEDUIM” ou o inteiro 7.

Use nomes, constantes e switch

Cada constante de enumeração é um único objeto, portanto size == Size.LARGE é uma comparação adequada. Uma variável de enum também pode ser nula. Size.values() retorna todas as constantes na ordem de declaração; Size.valueOf("LARGE") encontra o nome exato. A busca distingue maiúsculas de minúsculas: “large” causa IllegalArgumentException.

name() retorna o nome declarado. ordinal() retorna a posição a partir de zero, portanto Size.MEDIUM.ordinal() é 1. Inserir uma constante altera as posições posteriores, portanto uma posição ordinal é uma má escolha como código armazenado ou valor de negócio. Por padrão, toString() também retorna o nome.

Uma expressão switch, padrão desde o Java 14, pode retornar um valor:

String label = switch (size) {
    case SMALL -> "S";
    case MEDIUM -> "M";
    case LARGE -> "L";
};

Nomear todas as constantes torna a expressão exaustiva sem um ramo default. Esses casos pressupõem um size não nulo; listar as constantes não trata null.

Dê dados significativos a cada constante

enum CupSize {
    SMALL(250), MEDIUM(350), LARGE(500);
    private final int milliliters;
    CupSize(int milliliters) { this.milliliters = milliliters; }
    public int milliliters() { return milliliters; }
}

O ponto e vírgula separa a lista de constantes dos membros. O construtor é executado uma vez para cada constante quando o enum é inicializado. Ele é implicitamente privado, e quem usa o enum não pode criar novas constantes com new CupSize(400).

Dois copos grandes e um pequeno comportam 1250 mL, ou 1,25 L. Esse cálculo usa o campo milliliters, não as posições das constantes. Percorrer CupSize.values() e exibir cada constante e sua capacidade produz “SMALL: 250 mL”, “MEDIUM: 350 mL” e “LARGE: 500 mL”.

Dê às constantes seu próprio comportamento

Um enum pode implementar uma interface e pode dar às constantes individuais corpos de métodos diferentes:

enum Operation {
    ADD { int apply(int a, int b) { return a + b; } },
    MULTIPLY { int apply(int a, int b) { return a * b; } };
    abstract int apply(int a, int b);
}

Operation.MULTIPLY.apply(6, 7) retorna 42. Cada constante completa a operação abstrata. Enums estendem implicitamente java.lang.Enum; eles não podem estender outra classe, e classes comuns não podem estendê-los.

Use um enum para opções fixas quando o programa é escrito, como direções ou estados de pedidos. A lista de produtos de uma loja, que muda com o tempo, pertence aos dados: acrescentar produtos não deve exigir reescrever e recompilar uma declaração de enum.

Um record é uma classe de dados concisa, padrão desde o Java 16. Seu cabeçalho lista os valores, chamados componentes, que definem cada instância: record Point(int x, int y) { }.

Use os membros gerados

O compilador fornece um campo privado final para cada componente, um construtor canônico com esses componentes em ordem e métodos de acesso públicos com os nomes deles. Ele também fornece equals, hashCode e toString baseados nos componentes.

Point a = new Point(3, 4);
Point b = new Point(3, 4);
System.out.println(a.x());
System.out.println(a.equals(b));
System.out.println(a == b);

Isso exibe 3, true e false em linhas separadas. Valores de componentes correspondentes tornam os records iguais, mas as duas expressões new criam objetos separados. Records iguais têm códigos de dispersão iguais. Seu texto gerado inclui os nomes do record e dos componentes; JDKs atuais mostram “Point[x=3, y=4]”. Esse formato exato de texto não é garantido, portanto não o analise como formato de dados.

Os métodos de acesso são x() e y(), não getX() e getY(). Um método modificador que atribui this.x = x não compila porque o campo do componente é final. Um método pode retornar um novo valor: Point moveRight(int dx) { return new Point(x + dx, y); }.

Valide em um construtor compacto

record Temperature(double celsius) {
    Temperature {
        if (celsius < -273.15) {
            throw new IllegalArgumentException("below absolute zero");
        }
    }
}

Um construtor compacto repete o nome do record sem uma lista de parâmetros. Ele verifica ou normaliza os parâmetros recebidos; Java atribui valores aos campos dos componentes após seu corpo. Essa verificação rejeita −300 °C e aceita 21,5 °C. Um componente de texto poderia ser normalizado com name = name.trim(); antes da atribuição automática.

Um record público precisa de um construtor compacto público. Records também podem declarar campos estáticos, métodos estáticos e métodos de instância. Um construtor adicional delega ao construtor canônico com this(...). Campos de instância adicionais além dos componentes são proibidos.

Proteja objetos mutáveis dos componentes

Campos de componentes final tornam a imutabilidade superficial. Um record que contém uma lista mutável continua se referindo a essa lista:

record Team(String name, List<String> members) {
    Team {
        members = List.copyOf(members);
    }
}

Com java.util.List importado, isso armazena uma cópia não modificável. Acréscimos posteriores à lista original não afetam a composição da equipe, e team.members().add("Lee") lança UnsupportedOperationException. A cópia protege a estrutura da lista; ela não torna profundamente imutáveis os objetos mutáveis dos elementos.

Records estendem implicitamente java.lang.Record e são final. Eles não podem estender outra classe nem ser estendidos, mas podem implementar interfaces como Comparable. Use-os para dados definidos por seus valores; use uma classe comum para estado variável, campos de instância ocultos adicionais ou uma hierarquia de classes extensível.