Skip to content

4. Classes, records, interfaces

4.1. Objetos por meio de exemplos

4.1.1. Visão geral

Vamos agora explorar a programação orientada a objetos por meio de exemplos. Um objeto é uma entidade que contém dados que definem seu estado (chamados de campos, atributos etc.) e funções (chamadas de métodos). Um objeto é criado a partir de um modelo chamado classe. Por exemplo, uma classe chamada [C1] declara dois campos, [Type1 p1;] e [Type2 p2;], e dois métodos, [Type3 m3(...) { ... }] e [Type4 m4(...) { ... }], todos delimitados pelas chaves da declaração [public class C1 { ... }].

A partir da classe [C1], é possível criar muitos objetos, como [o1], [o2], … Todos terão os campos [p1], [p2], … e os métodos [m3], [m4], … No entanto, terão valores diferentes para seus campos [pi], cada um tendo assim seu próprio estado. Se [o1] é um objeto do tipo [C1], [o1.p1] designa o campo [p1] de [o1], e [o1.m3(...)] designa a chamada ao método [m3] de [o1].

Consideremos um primeiro modelo de objeto: a classe [Person].

4.1.2. Um programa composto de vários arquivos

Nos exemplos do capítulo anterior, um programa cabia em um único arquivo-fonte. A partir de agora, um programa pode ser composto de vários arquivos-fonte: uma classe por arquivo, mais o programa principal. Em Java, uma classe pública deve ser colocada em um arquivo que tenha o seu nome: a classe pública [Person] fica no arquivo [Person.java]. Guardamos os arquivos de um mesmo programa em uma pasta, neste caso a pasta [Persons] dentro da pasta [04-classes]:

1
2
3
Persons/
  Person.java       the Person class
  Main.java         the main program

A partir do Java 22, o launcher de código-fonte, que já usamos no capítulo anterior, pode executar um programa composto de vários arquivos: o comando [java Main.java], digitado na pasta [Persons], compila o arquivo [Main.java] em memória, depois, sob demanda, os demais arquivos da pasta de que ele precisa, neste caso [Person.java], e executa o programa. Nenhum arquivo compilado é gravado em disco. Também é possível compilar os arquivos explicitamente com o compilador [javac], que grava um arquivo [.class] (código intermediário, ou "bytecode") por classe, e depois executar o programa com o comando [java], indicando onde encontrar as classes compiladas (opção [-cp], o "classpath"):

1
2
3
4
5
6
> javac -d classes *.java
> ls classes
Main.class
Person.class
> java -cp classes Main
[Jean, Dupont, 30]

O launcher de vários arquivos basta para os programas deste capítulo, que usam apenas as classes do JDK. Quando um programa precisar de bibliotecas externas, usaremos um projeto Maven, como introduzido no capítulo 2: o Maven baixa as bibliotecas, compila o projeto e o executa. Os arquivos deste capítulo podem ser abertos como estão no IntelliJ IDEA ou no VS Code.

4.1.3. Definição da classe Person

A definição da classe [Person] no arquivo-fonte [Person.java] será a seguinte:

public class Person {
    // atributos (campos)
    private String firstName = "";
    private String lastName = "";
    private int age;

    // método
    public void initialize(String p, String n, int age) {
        this.firstName = p;
        this.lastName = n;
        this.age = age;
    }

    // método
    public void identify() {
        IO.println("[" + firstName + ", " + lastName + ", " + age + "]");
    }
}
  • Linha 1: a classe é pública ([public]): ela pode ser usada por todas as outras classes. Ela não pertence a nenhum pacote ou, mais precisamente, pertence ao pacote sem nome; os pacotes são tratados no fim do capítulo;
  • Linhas 3–5: os três campos da classe. As duas strings são inicializadas com a string vazia: caso contrário, valeriam [null] na criação do objeto (um campo de objeto não inicializado vale [null], um campo numérico vale 0 e um campo booleano vale [false]);
  • linhas 8–12: um método que define o estado do objeto;
  • linhas 15–17: um método que exibe o estado do objeto. [IO] é a classe de E/S de console do Java 25 que usamos no capítulo anterior.

Aqui temos a definição de uma classe, isto é, de um tipo de dados. Quando criamos variáveis desse tipo, chamamo-las de objetos ou instâncias da classe. Uma classe é, portanto, um modelo a partir do qual objetos são construídos. Por convenção, o nome de uma classe começa com letra maiúscula ([Person]), enquanto o nome de um campo ou de um método começa com letra minúscula ([firstName], [initialize]).

Os membros de uma classe podem ser dados (campos) ou métodos (funções). Esses membros podem ser acompanhados de uma das seguintes palavras-chave:

Palavra-chave
Acesso
[private]
Um membro privado só é acessível pelos métodos internos da classe
(nenhuma)
Se nenhuma palavra-chave for especificada, o membro é acessível por qualquer método de uma classe do mesmo pacote. Este é o acesso padrão, conhecido como "acesso de pacote"
[protected]
Um membro protegido é acessível pelos métodos das classes do mesmo pacote e pelos métodos das classes derivadas (veja o conceito de herança adiante)
[public]
Um membro público é acessível por qualquer método, seja ele definido ou não dentro da classe

Em geral, os dados de uma classe são declarados privados, enquanto seus métodos são declarados públicos. Isso significa que o usuário de um objeto (o programador):

  • não terá acesso direto aos dados privados do objeto;
  • poderá chamar os métodos públicos do objeto, inclusive aqueles que dão acesso a seus dados privados.

A ordem em que os membros [private], [protected] e [public] são declarados é arbitrária. Observe que o acesso padrão não é privado: um campo declarado sem palavra-chave é visível para todas as classes do pacote. Portanto, é preciso lembrar-se de escrever [private].

4.1.4. O método initialize

Qual é o papel do método [initialize]? Como [lastName], [firstName], e [age] são membros privados da classe [Person], uma instrução como [p1.firstName = "Jean";], escrita no programa principal, é inválida. O compilador a rejeita:

1
2
3
4
5
6
> java Main.java
Main.java:4: error: firstName has private access in Person
    p1.firstName = "Jean";
      ^
1 error
error: compilation failed

A mensagem do compilador está em inglês: o JDK não tem tradução francesa para suas mensagens. Ela indica o arquivo e o número da linha do erro e, em seguida, o marca com um acento circunflexo. Precisamos inicializar um objeto do tipo [Person] por meio de um método público. Esse é o papel do método [initialize]. Escreveremos [p1.initialize("Jean", "Dupont", 30);]. Essa sintaxe é válida porque [initialize] é de acesso público.

4.1.5. O operador new

No entanto, ainda falta algo. A declaração [Person p1;] declara [p1] como uma referência a um objeto do tipo [Person]. Esse objeto ainda não existe e, portanto, [p1] não está inicializada. Quando escrevemos então [p1.initialize("Jean", "Dupont", 30);], chamamos o método [initialize] do objeto referenciado por [p1]. No entanto, esse objeto não existe, e o compilador informa o erro: a variável local [p1] não recebeu um valor.

1
2
3
4
5
6
> java Main.java
Main.java:4: error: variable p1 might not have been initialized
    p1.initialize("Jean", "Dupont", 30);
    ^
1 error
error: compilation failed

Se escrevermos [Person p1 = null;] seguido de [p1.initialize("Jean", "Dupont", 30);], indicamos explicitamente, com a palavra-chave [null] , que a variável [p1] ainda não referencia nenhum objeto. O compilador aceita o programa, mas, em tempo de execução, a chamada do método provoca uma exceção [NullPointerException]:

1
2
3
> java Main.java
Exception in thread "main" java.lang.NullPointerException: Cannot invoke "Person.initialize(String, String, int)" because "<local1>" is null
    at Main.main(Main.java:4)

A partir do Java 14, a mensagem da exceção especifica qual operação falhou; [<local1>] designa a variável local [p1], cujo nome não foi preservado pela compilação em memória. Para que [p1] referencie um objeto, é preciso escrever [Person p1 = new Person();].

Isso cria um objeto do tipo [Person] que ainda não foi inicializado: seus campos têm os valores padrão, neste caso a string vazia para [lastName] e [firstName], e 0 para [age]. Agora que [p1] referencia um objeto, a instrução de inicialização desse objeto, [p1.initialize("Jean", "Dupont", 30);], é válida.

4.1.6. A palavra-chave this

Vejamos o código do método [initialize]:

    public void initialize(String p, String n, int age) {
        this.firstName = p;
        this.lastName = n;
        this.age = age;
    }

A instrução [this.firstName = p;] significa que o campo [firstName] do objeto atual ([this]) recebe o valor [p]. A palavra-chave [this] designa o objeto atual: aquele sobre o qual o método é executado. Como sabemos disso? Vejamos como o objeto referenciado por [p1] é inicializado no programa chamador: [p1.initialize("Jean", "Dupont", 30);]. É o método [initialize] do objeto [p1] que é chamado. Quando, dentro desse método, o objeto [this] é referenciado, trata-se na verdade do objeto [p1].

Quando um método de um objeto referencia um campo [a] desse objeto, a notação [this.a] fica implícita: o método [initialize] poderia ter escrito [firstName = p;] e [lastName = n;]. É obrigatório usar [this] explicitamente quando há conflito de identificadores. É o caso da instrução [this.age = age;] (linha 11), em que [age] designa ao mesmo tempo um campo do objeto atual e o parâmetro [age] recebido pelo método. No método, o nome [age] sozinho designa o parâmetro; o campo deve ser designado como [this.age].

4.1.7. Um programa de teste

Eis um pequeno programa de teste. Ele é escrito no arquivo-fonte [Main.java]:

1
2
3
4
5
6
7
// o programa principal
void main() {
    // um objeto Person
    Person p1 = new Person();
    p1.initialize("Jean", "Dupont", 30);
    p1.identify();
}
  • Linha 2: o método [main] é o ponto de entrada do programa. Como no capítulo anterior, ele é escrito sem uma classe envolvente: o arquivo [Main.java] é um arquivo-fonte compacto (veja o parágrafo seguinte);
  • linha 4: criação de um objeto [Person] referenciado por [p1]. Como a classe [Person] pertence ao mesmo pacote (o pacote sem nome), ela é reconhecida sem uma instrução import;
  • Linha 5: inicialização do objeto;
  • linha 6: exibição de seu estado.

Resultados:

> java Main.java
[Jean, Dupont, 30]

4.1.8. Arquivos-fonte compactos

Para um exemplo curto, uma pasta contendo vários arquivos é desnecessariamente pesada. Como no capítulo anterior, escreveremos portanto um arquivo-fonte compacto (Java 25): um arquivo que contém o método [void main()], possivelmente outros métodos e campos, e as classes de que o programa precisa. Nós o executamos com o launcher de código-fonte: [java Classes01.java].

É importante entender como o compilador processa esse arquivo. Ele o envolve em uma classe implícita, que leva o nome do arquivo ([Classes01]): os métodos e campos do arquivo tornam-se membros dessa classe, e as classes declaradas no arquivo tornam-se classes aninhadas dessa classe implícita. A compilação explícita do arquivo demonstra isso:

1
2
3
4
> javac -d classes Classes01.java
> ls classes
Classes01$Person.class
Classes01.class

O nome completo da classe [Person] no arquivo [Classes01.java] é, portanto, [Classes01$Person]. Isso tem duas consequências que encontraremos nos exemplos:

  • uma classe e as classes que ela contém compartilham seus membros privados: o método [main] de um arquivo compacto tem acesso aos campos privados das classes desse arquivo. Para garantir que um campo privado seja inacessível fora de sua classe, é preciso, como na pasta [Persons], colocar a classe em seu próprio arquivo;
  • Uma classe aninhada comum é uma classe interna: seus objetos estão vinculados a um objeto da classe envolvente. Isso não aparece enquanto os objetos são criados por métodos do arquivo, mas um método estático (veja a seção sobre membros de classe) não pode criá-los. Declaramos então a classe aninhada como [static]. Records e interfaces, tratados mais adiante, são sempre estáticos.

Por fim, um arquivo compacto importa automaticamente todas as classes públicas do módulo [java.base]: [List], [ArrayList], [BigDecimal], [Objects]… podem ser usadas nele sem a cláusula [import]. Isso não vale para um arquivo comum como [Person.java], como veremos.

4.1.9. Outro método initialize: a sobrecarga

Continuemos a considerar a classe [Person] e adicionemos a ela um segundo método: [initialize]. O programa [Classes01.java] é o seguinte:

// sobrecarga do método initialize
void main() {
    Person p1 = new Person();
    p1.initialize("Jean", "Dupont", 30);
    p1.identify();
    Person p2 = new Person();
    p2.initialize(p1);
    p2.identify();
}

// a classe Person é declarada depois do método main
class Person {
    // atributos
    private String firstName = "";
    private String lastName = "";
    private int age;

    // inicialização a partir de três valores
    public void initialize(String p, String n, int age) {
        firstName = p;
        lastName = n;
        this.age = age;
    }

    // inicialização a partir de outra pessoa
    public void initialize(Person p) {
        firstName = p.firstName;
        lastName = p.lastName;
        age = p.age;
    }

    // identidade da pessoa
    public void identify() {
        IO.println("[" + firstName + ", " + lastName + ", " + age + "]");
    }
}
  • linhas 2–9: o programa principal;
  • linha 12: a classe [Person] é declarada depois do método [main]. Ela não é pública: em um arquivo compacto, isso é desnecessário;
  • linhas 19–23: o método [initialize] do parágrafo anterior;
  • linhas 26–30: um segundo método, [initialize].

Agora temos dois métodos chamados [initialize]: isso é válido desde que eles aceitem parâmetros diferentes (em número ou em tipo). Diz-se que o método [initialize] é sobrecarregado. O compilador escolhe qual método chamar com base nos parâmetros reais: [p1.initialize("Jean", "Dupont", 30)] (linha 4) chama o primeiro, e [p2.initialize(p1)] (linha 7) chama o segundo. O tipo de retorno sozinho não basta para distinguir dois métodos: dois métodos com o mesmo nome e os mesmos parâmetros que diferissem apenas no tipo de retorno seriam rejeitados.

O parâmetro do segundo método é uma referência ([p]) a uma pessoa. Os campos da pessoa ([p]) são então atribuídos ao objeto atual ([this]). Observe que o método [initialize] tem acesso direto aos campos do objeto [p] mesmo que eles sejam privados (linhas 27–29). Isso sempre vale: um método de uma classe [C] tem acesso aos membros privados de todos os objetos da mesma classe [C].

Resultados:

1
2
3
> java Classes01.java
[Jean, Dupont, 30]
[Jean, Dupont, 30]

4.1.10. Construtores da classe Person

Um construtor é um método que leva o nome da classe e é chamado quando o objeto é criado. Ele geralmente serve para inicializar o objeto. É um método que pode receber parâmetros, mas não devolve valor. Sua declaração não é precedida por nenhum tipo (nem mesmo [void]).

Se uma classe [C] tem um construtor que aceita n parâmetros, a declaração e a inicialização de um objeto dessa classe podem ser feitas na forma [C object = new C(arg1, arg2, ... argn);], ou em duas etapas: [C object;], seguido, mais tarde, de [object = new C(arg1, arg2, ... argn);].

Quando uma classe [C] tem um ou mais construtores, um deles deve ser usado para criar um objeto dessa classe. Se uma classe [C] não tem construtores, ela tem um construtor padrão sem parâmetros que não faz nada. Os campos do objeto conservam então seus valores iniciais. Foi o que aconteceu nos programas anteriores, em que havíamos escrito [new Person()].

O programa [Classes02.java] apresenta três construtores para a classe [Person]:

// construtores da classe Person
void main() {
    Person p1 = new Person("Jean", "Dupont", 30);
    p1.identify();
    Person p2 = new Person(p1);
    p2.identify();
    Person p3 = new Person();
    p3.identify();
}

class Person {
    // atributos
    private String firstName;
    private String lastName;
    private int age;

    // construtor principal
    public Person(String firstName, String lastName, int age) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }

    // construtor de cópia: ele chama o construtor principal
    public Person(Person p) {
        this(p.firstName, p.lastName, p.age);
    }

    // construtor sem parâmetros: ele também chama o construtor principal
    public Person() {
        this("?", "?", 0);
    }

    // identidade da pessoa
    public void identify() {
        IO.println("[" + firstName + ", " + lastName + ", " + age + "]");
    }
}
  • linhas 18–22: o construtor "principal" inicializa os três campos. Como seus parâmetros têm os mesmos nomes que os campos, os campos são distinguidos com [this];
  • linhas 25–27: o construtor de cópia. A instrução [this(p.firstName, p.lastName, p.age);] chama o construtor da mesma classe que aceita três parâmetros: [String], [String] e [int]. Isso é chamado de construtores encadeados. Assim, o código de inicialização é escrito uma única vez;
  • linhas 30–32: o construtor sem parâmetros, também encadeado ao construtor principal. Como a classe declarou construtores, ela deixa de ter um construtor padrão: se quisermos poder escrever [new Person()], é preciso declará-lo;
  • linhas 13–15: os campos não são mais inicializados no momento de sua declaração; todos os construtores, diretamente ou por encadeamento, atribuem-lhes um valor.

A chamada [this(...)] a outro construtor só pode ser feita dentro de um construtor. Até o Java 24, ela tinha de ser a primeira instrução; desde o Java 25, instruções que não usam o objeto em construção (para verificar ou preparar parâmetros, por exemplo) podem precedê-la. Também poderíamos fazer os construtores chamarem um método como [initialize]; no entanto, o encadeamento é preferível: o código de inicialização fica em um único lugar, e um construtor não deve chamar um método que uma classe derivada possa sobrescrever; veremos por quê.

Resultados:

1
2
3
4
> java Classes02.java
[Jean, Dupont, 30]
[Jean, Dupont, 30]
[?, ?, 0]

4.1.11. Referências a objetos

Usamos a classe [Person] do programa anterior, omitindo seu construtor sem parâmetros, mas incluindo o método [initialize(String, String, int)] do início do capítulo. O programa de teste passa a ser o seguinte [Classes03.java]:

// referências a objetos
void main() {
    // p1
    Person p1 = new Person("Jean", "Dupont", 30);
    IO.print("p1="); p1.identify();
    // p2 referencia o mesmo objeto que p1
    Person p2 = p1;
    IO.print("p2="); p2.identify();
    // p3 referencia um objeto que é uma cópia do objeto referenciado por p1
    Person p3 = new Person(p1);
    IO.print("p3="); p3.identify();
    // mudamos o estado do objeto referenciado por p1
    p1.initialize("Micheline", "Benoît", 67);
    IO.print("p1="); p1.identify();
    // como p2 = p1, o objeto referenciado por p2 mudou de estado
    IO.print("p2="); p2.identify();
    // p3 não referencia o mesmo objeto que p1: o objeto referenciado por p3 não mudou
    IO.print("p3="); p3.identify();
    // p1 e p2 são a mesma referência? e p1 e p3?
    IO.println("p1 == p2 : " + (p1 == p2) + ", p1 == p3 : " + (p1 == p3));
}

class Person {
    // atributos
    private String firstName;
    private String lastName;
    private int age;

    // construtores
    public Person(String firstName, String lastName, int age) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }

    public Person(Person p) {
        this(p.firstName, p.lastName, p.age);
    }

    // inicialização
    public void initialize(String p, String n, int age) {
        firstName = p;
        lastName = n;
        this.age = age;
    }

    // identidade da pessoa
    public void identify() {
        IO.println("[" + firstName + ", " + lastName + ", " + age + "]");
    }
}

O método [IO.print] (linhas 5, 8, …) escreve seu parâmetro sem quebrar a linha. Resultados:

1
2
3
4
5
6
7
8
> java Classes03.java
p1=[Jean, Dupont, 30]
p2=[Jean, Dupont, 30]
p3=[Jean, Dupont, 30]
p1=[Micheline, Benoît, 67]
p2=[Micheline, Benoît, 67]
p3=[Jean, Dupont, 30]
p1 == p2 : true, p1 == p3 : false

Quando a variável [p1] é declarada com [Person p1 = new Person("Jean", "Dupont", 30);] (linha 4), [p1] referencia o objeto [Person("Jean", "Dupont", 30)], mas não é o próprio objeto. Em C, isso seria chamado de ponteiro, isto é, o endereço do objeto criado. Se escrevermos em seguida [p1 = null;], não é o objeto [Person("Jean", "Dupont", 30)] que é modificado; é a referência [p1] que muda de valor. O objeto será "perdido" se não for referenciado por nenhuma outra variável: a memória que ele ocupa será posteriormente recuperada pelo coletor de lixo da máquina virtual Java.

Quando escrevemos [Person p2 = p1;] (linha 7), inicializamos a referência [p2]: ela "aponta" para o mesmo objeto (refere-se ao mesmo objeto) que a referência [p1]. Assim, se o objeto "apontado" (ou referenciado) por [p1] for modificado, o objeto referenciado por [p2] também o será (linhas 5–6 dos resultados).

Quando se escreve [Person p3 = new Person(p1);] (linha 10), um novo objeto, [Person], é criado. Esse novo objeto será referenciado por [p3]. Se você modificar o objeto referenciado por [p1], não modifica o referenciado por [p3] (linha 7 dos resultados).

Por fim, na linha 20, o operador [==], aplicado a duas referências de objetos, indica se elas se referem ao mesmo objeto: [p1] e [p2] referem-se ao mesmo objeto, enquanto [p1] e [p3] referem-se a dois objetos diferentes, embora tenham o mesmo conteúdo (linha 8 dos resultados). Veremos mais adiante como comparar o conteúdo de dois objetos com o método [equals].

4.1.12. Passagem de referências a objetos como parâmetros

No capítulo anterior, vimos que o Java passa os parâmetros dos métodos por valor: o método recebe uma cópia do valor do parâmetro real. Vejamos o que isso significa quando o parâmetro é uma referência a um objeto. Para isso, usaremos a classe [StringBuilder] do JDK. Um objeto [String] não pode ser modificado: uma operação como [s.toUpperCase()] devolve um novo objeto [String]. Um objeto [StringBuilder], por outro lado, é uma string mutável: seu método [append] acrescenta caracteres à string sem criar um novo objeto.

O programa [Classes04.java] é o seguinte:

// passagem de parâmetros do tipo referência a objeto
void main() {
    StringBuilder sb0 = new StringBuilder("test0"), sb1 = new StringBuilder("test1");
    IO.println("In calling function before call: sb0=" + sb0 + ", sb1=" + sb1);
    StringBuilder sb2 = changeStringBuilder(sb0, sb1);
    IO.println("In calling function after call: sb0=" + sb0 + ", sb1=" + sb1 + ", sb2=" + sb2);
}

// a função chamada
StringBuilder changeStringBuilder(StringBuilder sbf0, StringBuilder sbf1) {
    IO.println("Start of called function: sbf0=" + sbf0 + ", sbf1=" + sbf1);
    // modificamos o objeto referenciado por sbf0
    sbf0.append("*****");
    // sbf1 agora referencia um novo objeto
    sbf1 = new StringBuilder("test1*****");
    // um novo objeto é retornado ao chamador
    StringBuilder sbf2 = new StringBuilder("test2*****");
    IO.println("End of called function: sbf0=" + sbf0 + ", sbf1=" + sbf1 + ", sbf2=" + sbf2);
    return sbf2;
}
  • linha 3: duas referências, [sb0] e [sb1], a objetos do tipo [StringBuilder];
  • linha 5: elas são passadas ao método [changeStringBuilder], cujo resultado, uma terceira referência, é atribuído a [sb2];
  • linhas 10–20: um método do arquivo compacto, que tem os parâmetros formais [sbf0] e [sbf1]. Quando o método começa, [sbf0] e [sb0] são duas referências distintas que apontam para o mesmo objeto: a referência [sb0] foi copiada para [sbf0] (as referências são passadas por valor). O mesmo vale para [sbf1] e [sb1].

Resultados:

1
2
3
4
5
> java Classes04.java
In calling function before call: sb0=test0, sb1=test1
Start of called function: sbf0=test0, sbf1=test1
End of called function: sbf0=test0*****, sbf1=test1*****, sbf2=test2*****
In calling function after call: sb0=test0*****, sb1=test1, sb2=test2*****

Explicações:

  • [sb0] e [sbf0] são duas referências distintas ao mesmo objeto. Esse objeto foi modificado por meio de [sbf0] (linha 13). Essa modificação é visível por meio de [sb0] (linha 5 dos resultados);
  • [sb1] e [sbf1] são duas referências distintas ao mesmo objeto. [sbf1] recebe um novo valor no método e passa a apontar para um novo objeto (linha 15). Isso não altera o valor de [sb1], que continua apontando para o objeto original, não modificado;
  • um método Java não pode, portanto, alterar o valor de uma variável do chamador. Para devolver um novo objeto ao chamador, ele o retorna como resultado (linhas 17 e 19). Quando há vários resultados, eles são agrupados em um objeto, como um record (veja adiante).

Lembre-se de que um método pode modificar o objeto referenciado por um parâmetro, mas não a variável do chamador que contém a referência. Ao contrário de outras linguagens, como C#, o Java não oferece passagem de parâmetros por referência.

4.1.13. Objetos temporários

Em uma expressão, é possível chamar explicitamente o construtor de um objeto: o objeto é criado, mas não há variável para acessá-lo depois (para modificá-lo, por exemplo). Esse objeto temporário é criado para a avaliação da expressão e depois descartado. O espaço de memória que ele ocupava será recuperado automaticamente mais tarde pelo coletor de lixo, cuja função é recuperar o espaço de memória ocupado por objetos que não são mais referenciados pelos dados do programa.

Considere o seguinte programa, [Classes05.java], em que os construtores da classe [Person] exibem uma mensagem:

// objetos temporários
void main() {
    new Person(new Person("Jean", "Dupont", 30)).identify();
}

class Person {
    // atributos
    private String firstName;
    private String lastName;
    private int age;

    // construtores
    public Person(String firstName, String lastName, int age) {
        IO.println("Constructor Person(String, String, int)");
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }

    public Person(Person p) {
        IO.println("Constructor Person(Person)");
        firstName = p.firstName;
        lastName = p.lastName;
        age = p.age;
    }

    // identidade da pessoa
    public void identify() {
        IO.println("[" + firstName + ", " + lastName + ", " + age + "]");
    }
}
  • Linha 3: o objeto [Person("Jean", *"Dupont", 30)]* é construído e depois passado ao construtor de cópia, que constrói um segundo objeto, cujo método [identify] é chamado. Nenhum dos dois objetos é referenciado por uma variável.

Resultados:

1
2
3
4
> java Classes05.java
Constructor Person(String, String, int)
Constructor Person(Person)
[Jean, Dupont, 30]

Os resultados mostram a criação sucessiva dos dois objetos temporários.

4.1.14. Métodos de acesso e de modificação

Adicionamos à classe [Person] os métodos necessários para ler ou modificar o estado dos campos dos objetos em [Classes06.java]:

// métodos de leitura (getters) e escrita (setters) de atributos privados
void main() {
    Person p = new Person("Jean", "Michelin", 34);
    IO.println("p=(" + p.getFirstName() + "," + p.getLastName() + "," + p.getAge() + ")");
    p.setAge(56);
    IO.println("p=(" + p.getFirstName() + "," + p.getLastName() + "," + p.getAge() + ")");
}

class Person {
    // atributos
    private String firstName;
    private String lastName;
    private int age;

    // construtor
    public Person(String firstName, String lastName, int age) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }

    // getters
    public String getFirstName() {
        return firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public int getAge() {
        return age;
    }

    // setters
    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public void setAge(int age) {
        this.age = age;
    }
}
  • linhas 23–33: os métodos de leitura, chamados getters;
  • Linhas 36–46: os métodos de escrita, chamados "setters".

Resultados:

1
2
3
> java Classes06.java
p=(Jean,Michelin,34)
p=(Jean,Michelin,56)

Os nomes desses métodos seguem uma convenção estabelecida desde os primórdios do Java, a dos "JavaBeans": o getter do campo [age] chama-se [getAge], e seu setter chama-se [setAge]; o getter de um campo booleano chamado [active] chama-se, em vez disso, [isActive]. Muitas bibliotecas (como o Jackson para JSON e o Hibernate para bancos de dados, que usaremos mais adiante) baseiam-se nessa convenção para obter os dados de um objeto. Ao contrário de outras linguagens, como C#, o Java não tem "propriedades": acessar o estado de um objeto sempre passa por métodos ou, no caso de objetos imutáveis, por records, que veremos mais adiante. Os ambientes de desenvolvimento podem gerar getters e setters a partir dos campos (no IntelliJ IDEA, pelo menu "Code / Generate…").

4.1.15. Setters que validam os valores recebidos

A vantagem dos modificadores sobre os campos públicos é a possibilidade de controlar os valores atribuídos aos campos: um modificador pode verificar a validade do valor recebido e lançar uma exceção se ele for inválido. Considere o programa [Classes07.java]:

// setters que verificam a validade dos valores recebidos
void main() {
    Person p = new Person("Jean", "Michelin", 34);
    IO.println("p=(" + p.getFirstName() + "," + p.getLastName() + "," + p.getAge() + ")");
    p.setAge(56);
    IO.println("p=(" + p.getFirstName() + "," + p.getLastName() + "," + p.getAge() + ")");
    try {
        p.setAge(-4);
    } catch (IllegalArgumentException ex) {
        IO.println(ex.getMessage());
    }
    // construtor sem parâmetros, depois chamadas aos setters
    Person p2 = new Person();
    p2.setAge(7);
    p2.setFirstName("Arthur");
    p2.setLastName("Martin");
    IO.println("p2=(" + p2.getFirstName() + "," + p2.getLastName() + "," + p2.getAge() + ")");
    try {
        Person p3 = new Person();
        p3.setFirstName("Paul");
        p3.setLastName(" ");
    } catch (IllegalArgumentException ex) {
        IO.println(ex.getMessage());
    }
}

class Person {
    // atributos
    private String firstName = "";
    private String lastName = "";
    private int age;

    // construtores
    public Person(String firstName, String lastName, int age) {
        // passamos pelos setters para aproveitar suas verificações
        setFirstName(firstName);
        setLastName(lastName);
        setAge(age);
    }

    public Person() {
    }

    // getters
    public String getFirstName() {
        return firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public int getAge() {
        return age;
    }

    // setters: são declarados final porque o construtor os chama
    public final void setFirstName(String firstName) {
        // nome próprio válido?
        if (firstName == null || firstName.isBlank()) {
            throw new IllegalArgumentException("first name (" + firstName + ") invalid");
        }
        this.firstName = firstName;
    }

    public final void setLastName(String lastName) {
        // sobrenome válido?
        if (lastName == null || lastName.isBlank()) {
            throw new IllegalArgumentException("last name (" + lastName + ") invalid");
        }
        this.lastName = lastName;
    }

    public final void setAge(int age) {
        // idade válida?
        if (age < 0) {
            throw new IllegalArgumentException("age (" + age + ") invalid");
        }
        this.age = age;
    }
}

Os três modificadores validam o valor recebido (linhas 60–62, 68–70, 76–78).

  • Linhas 60–62: o método [isBlank] (Java 11) devolve [true] se a string estiver vazia ou contiver apenas espaços. O teste [firstName == null] é feito primeiro: se [firstName] for igual a [null], o operador [||] não avalia seu segundo operando, o que causaria uma exceção [NullPointerException]. A exceção lançada é do tipo [IllegalArgumentException], a exceção fornecida pelo Java para sinalizar um parâmetro inválido. Trata-se de uma exceção não verificada: o método não precisa declará-la com [throws];
  • linhas 34–39: o construtor inicializa o objeto usando os métodos de acesso em vez dos campos. Isso lhe permite aproveitar as validações feitas pelos métodos de acesso, que são escritas em um único lugar;
  • linhas 58, 66, 74: os modificadores são declarados como [final]. Veremos com a herança que uma classe derivada pode sobrescrever os métodos de sua classe pai; a palavra-chave [final] impede isso. Sem ela, uma classe derivada poderia redefinir [setAge], e o construtor de [Person] chamaria essa nova versão antes mesmo de o construtor da classe derivada ter sido executado. O compilador, com a opção [-Xlint:all], sinaliza esse risco (aviso [this-escape]) para uma classe pública escrita em seu próprio arquivo;
  • linhas 41–42: um construtor sem parâmetros, que deixa os campos com seus valores iniciais.

Resultados:

1
2
3
4
5
6
> java Classes07.java
p=(Jean,Michelin,34)
p=(Jean,Michelin,56)
age (-4) invalid
p2=(Arthur,Martin,7)
last name ( ) invalid

A linha 4 dos resultados mostra que a chamada a [p.setAge(-4)] (linha 8) foi rejeitada pelo modificador. Linhas 13–16: uma instância é criada com o construtor sem parâmetros e depois inicializada por seus setters. Linhas 19–21: o nome que contém um espaço é rejeitado (linha 6 dos resultados).

Ao contrário de outras linguagens, o Java não tem um inicializador de objeto, uma sintaxe que permitiria definir vários campos na própria expressão [new]: em vez disso, como mostrado aqui, encadeamos as chamadas ao construtor e aos setters, ou escrevemos um construtor que recebe todos os valores. Veremos duas outras soluções: os modificadores "fluentes" e os records.

4.1.16. Campos final e parâmetros obrigatórios

Um campo declarado como [final] deve receber um valor exatamente uma vez, seja na declaração, seja dentro de cada construtor, e não pode ser modificado depois. O compilador impõe essa regra. Combinado com a ausência de modificadores, isso permite criar dados somente de leitura. O programa [Classes08.java] demonstra vários casos:

// campos final, somente leitura, parâmetros obrigatórios
void main() {
    Person p = new Person("Jean", "Dupont", 30, "Angers");
    IO.println(p.getIdentity());
    // o nome próprio é de leitura / escrita
    p.setFirstName("Jacques");
    // a idade só pode ser modificada dentro da classe
    p.growOlder();
    IO.println(p.getIdentity());
    // as linhas seguintes são rejeitadas pelo compilador
    // p.setLastName("Durand"); // não há setter para o sobrenome
    // p.setAge(40);         // não há setter para a idade
    // p.city = "Paris";     // o campo city é final

    // um parâmetro obrigatório
    Contact c = new Contact("jean.dupont@example.com");
    IO.println("Contact: " + c.getEmail() + ", " + c.getPhone());
    try {
        Contact c2 = new Contact(null);
        IO.println("Contact: " + c2.getEmail());
    } catch (NullPointerException ex) {
        IO.println("Error: " + ex.getMessage());
    }
}

class Person {
    // campos
    private String firstName;
    // campos final: eles recebem seu valor de uma vez por todas no construtor
    private final String lastName;
    private final String city;
    private int age;

    // construtor
    public Person(String firstName, String lastName, int age, String city) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
        this.city = city;
    }

    // nome próprio de leitura / escrita
    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    // sobrenome, idade e cidade somente leitura
    public String getLastName() {
        return lastName;
    }

    public int getAge() {
        return age;
    }

    public String getCity() {
        return city;
    }

    // um valor calculado
    public String getIdentity() {
        return "[" + firstName + ", " + lastName + ", " + age + ", " + city + "]";
    }

    // a idade só é modificada pelos métodos da classe
    public void growOlder() {
        age++;
    }
}

class Contact {
    // o e-mail é obrigatório, o telefone é opcional
    private final String email;
    private final String phone;

    // construtor com os dois valores
    public Contact(String email, String phone) {
        this.email = Objects.requireNonNull(email, "the email is mandatory");
        this.phone = phone;
    }

    // construtor sem o telefone: valor padrão
    public Contact(String email) {
        this(email, "unknown");
    }

    public String getEmail() {
        return email;
    }

    public String getPhone() {
        return phone;
    }
}
  • linhas 28 e 43–49: o nome é ao mesmo tempo somente leitura e gravável; ele tem um getter e um setter;
  • linhas 30–31: o sobrenome e a cidade são campos [final]. O construtor atribui-lhes um valor (linhas 37 e 39), que não pode ser alterado depois;
  • linha 32 e linhas 56–58: a idade pode ser lida por todos, mas não tem um setter público; ela só pode ser modificada pelos métodos da classe, como [growOlder] (linhas 70–72);
  • linhas 65–67: o método [getIdentity] devolve um valor calculado a partir dos campos. Para o usuário da classe, ele é indistinguível de um método de acesso;
  • linhas 11–13: três instruções que o compilador rejeita, pelos motivos indicados nos comentários. Para a terceira, a mensagem do compilador é: [cannot assign a value to final variable city];
  • Linhas 75–98: a classe [Contact] tem um campo obrigatório, o e-mail, e um campo opcional, o telefone. O campo obrigatório é imposto pelo construtor: um objeto [Contact] não pode ser criado sem um endereço de e-mail. O método [Objects.requireNonNull(value, message)] (linha 82) devolve seu primeiro parâmetro se ele não for [null] e, caso contrário, lança uma exceção [NullPointerException] com a mensagem especificada: um endereço de e-mail da forma [null] é rejeitado (linhas 18–23);
  • linhas 87–89: o caráter opcional do número de telefone é expresso por um segundo construtor, que fornece um valor padrão. O Java não tem parâmetros opcionais: sobrecarregamos o construtor.

Observe que, em um arquivo compacto, o método [main] tem acesso aos campos privados das classes do arquivo: é por isso que os comentários das linhas 11–13 não se baseiam no caráter privado dos campos, mas na ausência de um modificador e na palavra-chave [final].

Resultados:

1
2
3
4
5
> java Classes08.java
[Jean, Dupont, 30, Angers]
[Jacques, Dupont, 31, Angers]
Contact: jean.dupont@example.com, unknown
Error: the email is mandatory

4.1.17. Modificadores fluentes

Quando um objeto tem muitos campos opcionais, o número de construtores aumenta e as chamadas aos modificadores ficam mais longas. Uma técnica comum é fazer cada modificador devolver o objeto atual ([this]): as chamadas podem então ser encadeadas; fala-se de métodos "fluentes". O programa [Classes09.java] ilustra isso:

// setters "fluentes": eles retornam o objeto atual
void main() {
    Person p = new Person().setFirstName("  jean ").setLastName("Dupont").setAge(30);
    IO.println(p.getIdentity());
    try {
        p.setLastName("");
    } catch (IllegalArgumentException ex) {
        IO.println(ex.getMessage());
    }
    try {
        p.setAge(-4);
    } catch (IllegalArgumentException ex) {
        IO.println(ex.getMessage());
    }
    IO.println(p.getIdentity());
}

class Person {
    // campos
    private String firstName = "";
    private String lastName = "";
    private int age;

    // setters fluentes: cada um retorna o objeto atual (this)
    public Person setFirstName(String firstName) {
        this.firstName = check(firstName, "first name");
        return this;
    }

    public Person setLastName(String lastName) {
        this.lastName = check(lastName, "last name");
        return this;
    }

    public Person setAge(int age) {
        if (age < 0) {
            throw new IllegalArgumentException("age (" + age + ") invalid");
        }
        this.age = age;
        return this;
    }

    // identidade
    public String getIdentity() {
        return "[" + firstName + ", " + lastName + ", " + age + "]";
    }

    // verificando uma string obrigatória: ela é retornada sem espaços no início e no fim
    private static String check(String value, String label) {
        if (value == null || value.isBlank()) {
            throw new IllegalArgumentException(label + " (" + value + ") invalid");
        }
        return value.strip();
    }
}
  • linhas 25–28: o modificador [setFirstName] verifica o valor recebido, atribui-o ao campo e devolve o objeto atual. Seu tipo de retorno é, portanto, [Person];
  • linha 3: as chamadas são encadeadas: [new Person()] devolve uma pessoa, sobre a qual [setFirstName] é chamado, devolvendo a mesma pessoa, sobre a qual [setLastName] é chamado, e assim por diante. A sintaxe lembra um inicializador de objeto;
  • Linhas 49–54: as verificações do nome e do sobrenome, que são idênticas, foram extraídas para o método privado [check]. Ele é declarado como [static] porque não usa nenhum campo do objeto (os membros estáticos são tratados no parágrafo seguinte). O método [strip] (Java 11) remove os espaços iniciais e finais da string.

Resultados:

1
2
3
4
5
> java Classes09.java
[jean, Dupont, 30]
last name () invalid
age (-4) invalid
[jean, Dupont, 30]

O nome "jean", fornecido com espaços de cada lado (linha 3), foi armazenado sem eles (linha 2 dos resultados). Os modificadores fluentes não seguem a convenção JavaBeans, segundo a qual um modificador não devolve nada ([void]): algumas bibliotecas não os reconhecem. Para construir objetos complexos, usa-se também o padrão de projeto "Builder": uma classe auxiliar, dotada de métodos fluentes, coleta os valores e depois constrói o objeto final, que pode então ser imutável.

4.1.18. Métodos e atributos de classe

Suponha que queiramos contar o número de objetos [Person] criados em uma aplicação. Poderíamos gerenciar um contador por conta própria, mas corremos o risco de esquecer objetos temporários criados aqui e ali. Parece mais seguro incluir uma instrução nos construtores da classe [Person] que incremente um contador. Esse contador não pode ser um campo comum, já que cada objeto tem seus próprios campos: é um campo da própria classe, e não de uma instância específica dessa classe. Ele é declarado com a palavra-chave [static]: [private static long nbPersons;].

Para nos referirmos a ele, escrevemos [Person.nbPersons] para indicar que se trata de um campo da classe [Person] em si. Aqui, criamos um campo privado que não pode ser acessado diretamente de fora da classe. Criamos, portanto, um acessor público para dar acesso ao campo da classe [nbPersons]. Para obter o valor de [nbPersons], esse acessor não precisa de um objeto [Person] específico; por isso, também o declaramos como *[static]. Do lado de fora, ele será chamado com a sintaxe [Person.getNbPersons()]. Eis um exemplo de [Classes10.java]*:

// membros de classe (static)
void main() {
    Person p1 = new Person("Jean", "Dupont", 30);
    Person p2 = new Person(p1);
    new Person(p1);
    IO.println("Number of persons created: " + Person.getNbPersons());
    // um método de classe
    Person p3 = Person.unknown();
    p3.identify();
    IO.println("Number of persons created: " + Person.getNbPersons());
}

// classe aninhada estática: veja as explicações
static class Person {
    // atributo de classe
    private static long nbPersons;

    // getter de classe
    public static long getNbPersons() {
        return nbPersons;
    }

    // método de classe
    public static Person unknown() {
        return new Person("?", "?", 0);
    }

    // atributos de instância
    private String firstName;
    private String lastName;
    private int age;

    // construtores
    public Person(String firstName, String lastName, int age) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
        nbPersons++;
    }

    public Person(Person p) {
        this(p.firstName, p.lastName, p.age);
    }

    // identidade da pessoa
    public void identify() {
        IO.println("[" + firstName + ", " + lastName + ", " + age + "]");
    }
}
  • linha 16: o campo de classe. Como qualquer campo numérico, é inicializado com 0;
  • linhas 19 a 21: o acessor da classe;
  • linhas 24 a 26: um método de classe. Ele é chamado com o nome da classe: [Person.unknown()] (linha 8). Um método de classe não tem objeto corrente: a palavra-chave [this] não tem significado nele, e ele só pode usar diretamente os membros [static] da classe. Um método estático que cria e retorna um objeto da própria classe, como este, é chamado de fábrica estática (static factory);
  • linha 38: o construtor primário incrementa o contador. O construtor de cópia, que é encadeado ao construtor primário, também o incrementa;
  • Linha 14: a classe [Person] é declarada como [static]. Como explicado na seção sobre arquivos compactos: uma classe declarada em um arquivo compacto é uma classe aninhada da classe implícita. Sem a palavra-chave [static], ela é uma classe interna, em que cada objeto está vinculado a um objeto da classe envolvente; o método estático [unknown], que não tem objeto corrente, não conseguiria criar um, e o compilador relataria o erro [non-static variable this cannot be referenced from a static context]. Uma classe escrita em seu próprio arquivo não tem esse problema.

Resultados:

1
2
3
4
> java Classes10.java
Number of persons created: 3
[?, ?, 0]
Number of persons created: 4

O programa contou corretamente o objeto temporário criado na linha 5. Desde o início usamos membros de classe: [IO.println], [Integer.parseInt], [Math.sqrt] são métodos [static], e [Math.PI] é um campo [static]. A classe [Math] contém apenas membros estáticos: ela é declarada como [final], e seu único construtor é privado, o que impede a criação de instâncias. Essa é a maneira de escrever, em Java, uma classe utilitária.

4.1.19. Um array de pessoas

Um objeto é um dado como qualquer outro e, como tal, vários objetos podem ser agrupados em um array [Classes11.java]:

// um array de pessoas
void main() {
    Person[] friends = new Person[3];
    friends[0] = new Person("Jean", "Dupont", 30);
    friends[1] = new Person("Sylvie", "Vartan", 52);
    friends[2] = new Person("Neil", "Armstrong", 66);
    // exibição
    for (Person friend : friends) {
        friend.identify();
    }
}

class Person {
    // atributos
    private String firstName;
    private String lastName;
    private int age;

    // construtor
    public Person(String firstName, String lastName, int age) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }

    // identidade da pessoa
    public void identify() {
        IO.println("[" + firstName + ", " + lastName + ", " + age + "]");
    }
}
  • Linha 3: cria um array de 3 elementos do tipo [Person]. Esses 3 elementos são inicializados aqui com o valor [null], ou seja, não referenciam nenhum objeto. Tecnicamente, fala-se em “array de objetos”, embora se trate apenas de um array de referências a objetos. A criação do array, que é ele próprio um objeto (como indica o [new]), não cria nenhum objeto do mesmo tipo de seus elementos; isso deve ser feito em seguida;
  • linhas 4 a 6: criação dos 3 objetos do tipo [Person];
  • linhas 8 a 10: exibição do conteúdo do array [friends].

Resultados:

1
2
3
4
> java Classes11.java
[Jean, Dupont, 30]
[Sylvie, Vartan, 52]
[Neil, Armstrong, 66]

4.1.20. Inferência de tipo e inicialização de arrays

O programa [Classes12.java] apresenta duas construções que simplificam a criação de objetos e arrays:

// inferência de tipo com var e inicialização de array
void main() {
    // o tipo da variável é deduzido da expressão que a inicializa
    var p1 = new Person("Jean", "Dupont", 30);
    var p2 = new Person();
    p2.setFirstName("Arthur");
    p2.setLastName("Martin");
    p2.setAge(7);
    // um array criado e inicializado por uma lista de valores entre chaves
    Person[] friends = {
        p1,
        p2,
        new Person("Sylvie", "Vartan", 52),
        new Person("Neil", "Armstrong", 66),
    };
    for (var friend : friends) {
        IO.println(friend.getIdentity());
    }
    // um array anônimo passado como parâmetro
    display(new Person[] { new Person("Pauline", "Leduc", 12), p1 });
}

// um método que recebe um array de pessoas
void display(Person[] persons) {
    for (Person p : persons) {
        IO.println("Display: " + p.getIdentity());
    }
}

class Person {
    // campos
    private String firstName = "";
    private String lastName = "";
    private int age;

    // construtores
    public Person(String firstName, String lastName, int age) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }

    public Person() {
    }

    // setters
    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public void setAge(int age) {
        this.age = age;
    }

    // identidade
    public String getIdentity() {
        return "[" + firstName + ", " + lastName + ", " + age + "]";
    }
}
  • Linha 4: com a palavra-chave [var] (Java 10), o tipo da variável local é inferido a partir da expressão que a inicializa, neste caso [Person]. A variável continua tendo tipo: [p1] é do tipo [Person] e só pode referenciar uma única pessoa. [var] só pode ser usada em variáveis locais inicializadas na declaração, não em campos nem em parâmetros;
  • linhas 10 a 15: um array criado e preenchido com uma lista de valores entre chaves e separados por vírgulas. O tamanho do array é o número de valores. Uma vírgula final (linha 14) é permitida: ela facilita a adição de um elemento. Essa sintaxe só é permitida na declaração do array;
  • linha 16: [var] dentro de um laço [for];
  • linha 20: fora de uma declaração de array, um array inicializado é criado especificando-se seu tipo: [new Person[] { ... }]. Chama-se isso de array anônimo: ele não é referenciado por nenhuma variável no método [main];
  • Linhas 24 a 28: um método do arquivo compacto que recebe um array de pessoas.

Resultados:

1
2
3
4
5
6
7
> java Classes12.java
[Jean, Dupont, 30]
[Arthur, Martin, 7]
[Sylvie, Vartan, 52]
[Neil, Armstrong, 66]
Display: [Pauline, Leduc, 12]
Display: [Jean, Dupont, 30]

4.2. Herança por meio de exemplos

4.2.1. Visão geral

Aqui apresentamos o conceito de herança. O objetivo da herança é “personalizar” uma classe existente para que ela atenda às nossas necessidades. Suponha que queiramos criar uma classe [Teacher]: um professor é um tipo específico de pessoa. Ele tem atributos que as outras pessoas não têm: a disciplina que ensina, por exemplo. Mas também tem os atributos comuns a todas as pessoas: nome, sobrenome e idade. Um professor é, portanto, um membro pleno da classe [Person], mas tem atributos adicionais. Em vez de criar uma classe [Teacher] do zero, preferimos aproveitar a classe existente [Person] e adaptá-la às características específicas dos professores. Isso é possível graças ao conceito de herança.

Para indicar que a classe [Teacher] herda da classe [Person], escrevemos [public class Teacher extends Person].

[Person] é chamada de classe pai (ou classe base, ou superclasse), e [Teacher] é chamada de classe derivada (ou classe filha, ou subclasse). Um objeto [Teacher] tem todas as propriedades de um objeto [Person]: tem os mesmos campos e métodos. Esses campos e métodos da classe pai não são repetidos na definição da classe filha; basta especificar os campos e métodos acrescentados pela classe filha. Uma classe Java só pode herdar de uma única classe pai.

Os exemplos deste parágrafo são dois programas de vários arquivos, localizados nas pastas [Inheritance1] e [Inheritance2] . Na pasta [Inheritance1], a classe [Person] é definida assim: [Person.java]:

public class Person {
    // campo de classe: o número de pessoas criadas
    private static long nbPersons;

    // campos de instância
    private String firstName;
    private String lastName;
    private int age;

    // construtor
    public Person(String firstName, String lastName, int age) {
        setFirstName(firstName);
        setLastName(lastName);
        setAge(age);
        nbPersons++;
        IO.println("Constructor Person(String, String, int)");
    }

    // número de pessoas criadas
    public static long getNbPersons() {
        return nbPersons;
    }

    // getters
    public String getFirstName() {
        return firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public int getAge() {
        return age;
    }

    // setters
    public final void setFirstName(String firstName) {
        this.firstName = check(firstName, "first name");
    }

    public final void setLastName(String lastName) {
        this.lastName = check(lastName, "last name");
    }

    public final void setAge(int age) {
        if (age < 0) {
            throw new IllegalArgumentException("age (" + age + ") invalid");
        }
        this.age = age;
    }

    // identidade da pessoa
    public String getIdentity() {
        return "[" + firstName + ", " + lastName + ", " + age + "]";
    }

    // verificando uma string obrigatória
    private static String check(String value, String label) {
        if (value == null || value.isBlank()) {
            throw new IllegalArgumentException(label + " (" + value + ") invalid");
        }
        return value;
    }
}
  • linha 3: o contador de pessoas do parágrafo anterior;
  • linhas 11 a 17: o construtor inicializa o objeto por meio de seus modificadores, incrementa o contador e exibe uma mensagem de acompanhamento;
  • linhas 38 a 51: três modificadores que validam seus valores. As validações do nome e do sobrenome, que são idênticas, foram fatoradas no método de classe privado [check] (linhas 59 a 64). Os modificadores são declarados como [final] porque o construtor os chama (veja o programa [Classes07.java]);
  • linhas 54 a 56: o método [identify] dos exemplos anteriores foi substituído pelo método [getIdentity], que retorna a identidade da pessoa em vez de exibi-la.

Criamos uma classe chamada [Teacher] que herda da classe [Person]: [Teacher.java]:

public class Teacher extends Person {
    // campo específico da classe Teacher
    private int section;

    // construtor
    public Teacher(String firstName, String lastName, int age, int section) {
        // construção da parte Person do objeto
        super(firstName, lastName, age);
        // armazenamos a seção
        this.section = section;
        // rastreamento
        IO.println("Constructor Teacher(String, String, int, int)");
    }

    // getter e setter da seção
    public int getSection() {
        return section;
    }

    public void setSection(int section) {
        this.section = section;
    }
}

A classe [Teacher] acrescenta aos campos e métodos da classe [Person] o seguinte:

  • linha 1: a classe [Teacher] deriva da classe [Person];
  • linha 3: um campo [section], que é o número da seção à qual o professor pertence dentro do corpo docente (aproximadamente uma seção por disciplina);
  • linhas 6 a 13: um construtor usado para inicializar todos os campos de um professor;
  • linhas 16 a 22: o getter e o setter do campo [section].

4.2.2. Criação de um objeto Teacher

Uma classe filha não herda os construtores da classe pai. Ela precisa definir seus próprios construtores. O construtor da classe [Teacher] é o seguinte:

1
2
3
4
5
6
7
8
    public Teacher(String firstName, String lastName, int age, int section) {
        // construção da parte Person do objeto
        super(firstName, lastName, age);
        // armazenamos a seção
        this.section = section;
        // rastreamento
        IO.println("Constructor Teacher(String, String, int, int)");
    }

O construtor recebe quatro parâmetros ([firstName], [lastName], [age], [section]) e repassa três ([firstName], [lastName], [age]) à classe pai, neste caso a classe [Person], com a instrução [super(firstName, lastName, age);] (linha 3). Sabemos que essa classe tem um construtor, [Person(String, String, int)], que será usado para criar uma pessoa com os parâmetros recebidos. Concluída a construção da parte [Person], a construção do objeto [Teacher] prossegue com a execução do restante do construtor (linhas 5 a 7).

Em resumo, o construtor de uma classe derivada:

  • repassa à classe pai, por meio de [super(...)], os parâmetros de que ela precisa para se construir;
  • usa os demais parâmetros para inicializar seus próprios campos.

Poderíamos ter optado por inicializar os campos [firstName], [lastName] e [age] diretamente no construtor da classe [Teacher], com instruções como [this.firstName = firstName;]. Isso é impossível por dois motivos. Primeiro, os campos privados [firstName], [lastName] e [age] são acessíveis apenas aos métodos da classe [Person]. Todos os demais objetos, inclusive os de classes derivadas, como neste caso, devem acessá-los por meio de membros públicos (ou protegidos). Seria diferente se a classe [Person] tivesse declarado esses campos como protegidos (*[protected]*): ela permitiria então que as classes derivadas os acessassem diretamente. Além disso, a parte [Person] do objeto precisa, de qualquer forma, ser construída por um construtor da classe [Person]: na ausência de uma chamada a [super(...)], o compilador insere uma chamada a [super()]—o construtor sem parâmetros da classe pai. Ocorre que a classe [Person] não tem um. Se a instrução [super(firstName, lastName, age);] for removida, o compilador relata o seguinte erro:

1
2
3
4
5
6
7
8
9
> java Main.java
.../Inheritance1/Teacher.java:6: error: constructor Person in class Person cannot be applied to given types;
    public Teacher(String firstName, String lastName, int age, int section) {
                                                                            ^
  required: String,String,int
  found:    no arguments
  reason: actual and formal argument lists differ in length
1 error
error: compilation failed

Usar o construtor da classe pai é, portanto, a solução correta e a abordagem padrão: ao construir um objeto filho, primeiro chama-se o construtor do objeto pai e, em seguida, completam-se as inicializações específicas do objeto filho ([section] em nosso exemplo). Como acontece com [this(...)], somente instruções que não usam o objeto em construção podem preceder a chamada a [super(...)] (desde o Java 25; antes, [super(...)] tinha de ser a primeira instrução).

4.2.3. Métodos herdados

A classe [Teacher] não define um método chamado [getIdentity]. A expressão [e.getIdentity()], em que [e] é um professor, refere-se, portanto, ao método [getIdentity] herdado da classe [Person]: ele é público e, por herança, torna-se um método público da classe [Teacher]. O programa de teste [Main.java] da pasta [Inheritance1] é o seguinte:

void main() {
    // um professor
    Teacher e = new Teacher("Lucile", "Dumas", 56, 61);
    // o método getIdentity herdado da classe Person
    IO.println(e.getIdentity());
    // o método getSection específico da classe Teacher
    IO.println("section=" + e.getSection());
    // uma pessoa
    Person p = new Person("Jean", "Dupont", 30);
    // o método display recebe uma Person ou um objeto de uma classe derivada
    display(e);
    display(p);
    // o método toString herdado da classe Object
    IO.println(e.toString());
    IO.println(p.toString());
    IO.println("Number of persons created: " + Person.getNbPersons());
}

// exibe a identidade de p
void display(Person p) {
    IO.println(p.getIdentity());
}
  • linha 3: cria um professor;
  • linha 5: exibe a identidade do professor, obtida por meio do método [getIdentity] herdado da classe [Person];
  • linha 7: o método [getSection], específico da classe [Teacher];
  • linhas 11 e 12: chamada ao método [display] (linhas 20 a 22) com um professor e depois com uma pessoa. Voltaremos a isso no próximo parágrafo;
  • linhas 14 e 15: chamada ao método [toString] para os dois objetos. Também voltaremos a isso.

Resultados:

> java Main.java
Constructor Person(String, String, int)
Constructor Teacher(String, String, int, int)
[Lucile, Dumas, 56]
section=61
Constructor Person(String, String, int)
[Lucile, Dumas, 56]
[Jean, Dupont, 30]
Teacher@70325e14
Person@37ceb1df
Number of persons created: 2

Podemos observar que:

  • um objeto [Person] (linha 2 dos resultados) foi construído antes do objeto [Teacher] (linha 3);
  • [e.getIdentity()] forneceu a identidade da parte [Person] do professor, sem a seção (linha 4);
  • o contador de pessoas também conta o professor (linha 11): um professor é uma pessoa.

Para obter a identidade completa de um professor, a classe [Teacher] deve definir seu próprio método [getIdentity]. É o que faz a pasta [Inheritance2].

4.2.4. Polimorfismo

Considere uma hierarquia de classes: C0 ← C1 ← C2 ← … ← Cn, em que Ci ← Cj indica que a classe Cj deriva da classe Ci. Isso implica que a classe Cj tem todas as características da classe Ci, além de outras. Sejam Oi objetos do tipo Ci. É válido escrever [Oi = Oj] com j > i. De fato, por herança, a classe Cj tem todas as características da classe Ci, além de outras. Logo, um objeto Oj do tipo Cj contém um objeto do tipo Ci. A operação [Oi = Oj] faz a variável Oi, do tipo Ci, referenciar o objeto Oj: por meio dela, só é possível acessar os membros definidos na classe Ci.

O fato de uma variável Oi da classe Ci poder referenciar não apenas um objeto da classe Ci, mas qualquer objeto derivado da classe Ci, chama-se polimorfismo: a capacidade de uma variável referenciar diferentes tipos de objetos.

Vejamos um exemplo e consideremos o método [display] do programa anterior:

1
2
3
void display(Person p) {
    IO.println(p.getIdentity());
}

Podemos passar a ele tanto uma [Person] quanto um [Teacher]: neste último caso, o parâmetro formal [p], que é do tipo [Person], recebe um valor do tipo [Teacher]. Como o tipo [Teacher] é derivado do tipo [Person], isso é válido. A instrução [p.getIdentity()] executou aqui o método [getIdentity] da classe [Person], o único que existe no programa: para o professor (linha 7 dos resultados), obtemos apenas a identidade de sua parte “Person”. Vejamos o que acontece quando a classe [Teacher] tem seu próprio método [getIdentity].

4.2.5. Redefinição de métodos e vinculação dinâmica

Na pasta [Inheritance2], a classe [Person] é igual à da pasta [Inheritance1], com um acréscimo:

    // identidade da pessoa: método sobrescrito na classe Teacher
    public String getIdentity() {
        return "[" + firstName + ", " + lastName + ", " + age + "]";
    }

    // sobrescrevendo o método toString da classe Object
    @Override
    public String toString() {
        return getIdentity();
    }
  • linhas 6 a 10: uma redefinição do método [toString], discutida no parágrafo seguinte.

Na classe [Teacher], o método [getIdentity] é redefinido da seguinte forma:

// uma classe final: não é possível derivar dela
public final class Teacher extends Person {
    // campo específico da classe Teacher
    private int section;

    // construtor
    public Teacher(String firstName, String lastName, int age, int section) {
        super(firstName, lastName, age);
        this.section = section;
        IO.println("Constructor Teacher(String, String, int, int)");
    }

    // getter e setter da seção
    public int getSection() {
        return section;
    }

    public void setSection(int section) {
        this.section = section;
    }

    // o método getIdentity sobrescreve o da classe pai
    @Override
    public String getIdentity() {
        return "Teacher[" + super.getIdentity() + "," + section + "]";
    }
}
  • Linhas 23 a 26: o método [getIdentity] redefine o da classe pai; tem o mesmo nome, os mesmos parâmetros e o mesmo tipo de retorno. Ele se apoia no método [getIdentity] da classe pai, referenciado como [super.getIdentity()], para obter a parte “Person” e depois a complementa com a seção específica da classe [Teacher];
  • Linha 23: a anotação [@Override] informa ao compilador que o método pretende redefinir um método da classe pai. Ela não é obrigatória, mas é fortemente recomendada: se o método não redefinisse nada (por um erro de digitação no nome ou por parâmetros diferentes), o compilador relataria o erro em vez de criar silenciosamente um novo método;
  • Linha 2: a classe é final ([final]), o que explicaremos em mais detalhes adiante.

Considere um objeto professor [E]. Esse objeto contém em si um objeto [Person]:

Image

O método [getIdentity] é definido tanto na classe [Teacher] quanto em sua classe pai [Person]. Em Java, todos os métodos de instância que não são privados nem finais podem ser redefinidos, e a escolha do método executado por [p.getIdentity()] é feita em tempo de execução, com base no tipo real do objeto referenciado por [p], e não em tempo de compilação com base no tipo declarado da variável. Isso é conhecido como vinculação dinâmica (dynamic binding). Para executar [o.m()], a máquina virtual procura um método chamado [m] na seguinte ordem:

  • na classe do objeto [o];
  • na classe pai, se houver;
  • na classe pai da classe pai, se existir;
  • e assim por diante.

A herança permite, portanto, redefinir na classe filha métodos que têm a mesma assinatura que os da classe pai. É isso que permite adaptar a classe filha às suas próprias necessidades. O programa [Main.java] da pasta [Inheritance2] é o seguinte:

void main() {
    // um professor
    Teacher e = new Teacher("Lucile", "Dumas", 56, 61);
    display(e);
    // uma pessoa
    Person p = new Person("Jean", "Dupont", 30);
    display(p);
    // visto como uma Person, o professor continua sendo um professor
    Person pe = e;
    IO.println(pe.getIdentity());
    IO.println(((Person) e).getIdentity());
    // IO.println(Object) exibe o resultado do método toString do objeto
    IO.println(e);
    IO.println(p);
    // um array de pessoas de tipos diferentes
    Person[] persons = { p, e };
    for (Person person : persons) {
        IO.println(person.getClass().getSimpleName() + " : " + person);
    }
}

// exibe a identidade de p
void display(Person p) {
    IO.println(p.getIdentity());
}

Resultados:

> java Main.java
Constructor Person(String, String, int)
Constructor Teacher(String, String, int, int)
Teacher[[Lucile, Dumas, 56],61]
Constructor Person(String, String, int)
[Jean, Dupont, 30]
Teacher[[Lucile, Dumas, 56],61]
Teacher[[Lucile, Dumas, 56],61]
Teacher[[Lucile, Dumas, 56],61]
[Jean, Dupont, 30]
Person : [Jean, Dupont, 30]
Teacher : Teacher[[Lucile, Dumas, 56],61]

Desta vez, na linha 4 dos resultados, o método [display] exibiu corretamente o nome completo do professor. As linhas 9 a 11 do programa mostram que, seja visto por meio de uma variável do tipo [Person] ou convertido em [Person] pelo operador [(Person)], o professor continua sendo um professor: é sempre o método [getIdentity] da classe [Teacher] que é executado (linhas 7 e 8 dos resultados). A conversão altera o tipo da referência, não o do objeto. Ao contrário de outras linguagens, como C#, em que um método só pode ser redefinido se for declarado virtual, os métodos Java são “virtuais” por padrão; não existe redefinição de um método de instância sem virtualidade.

4.2.6. A classe Object e o método toString

A classe [java.lang.Object] é a classe “pai” de todas as classes Java. Assim, quando você escreve [public class Person], está escrevendo implicitamente [public class Person extends Object].

A classe [Object] define vários métodos que todos os objetos herdam:

  • [String toString()]: retorna uma representação textual do objeto. Por padrão, é o nome da classe do objeto, seguido do caractere [@] e de um código hash escrito em hexadecimal;
  • [boolean equals(Object o)]: indica se o objeto é “igual” ao objeto [o]. Por padrão, ele só é igual a si mesmo: o método compara referências, como o operador [==];
  • [int hashCode()]: retorna um código hash do objeto, usado por dicionários e conjuntos (veja o próximo capítulo). Os métodos [equals] e [hashCode] são discutidos adiante;
  • [Class<?> getClass()]: retorna a descrição da classe real do objeto. O método [getSimpleName] dessa descrição retorna o nome da classe, enquanto [getName] retorna seu nome completo.

É o método [toString] da classe [Object] que foi usado pelas chamadas [e.toString()] e [p.toString()] na pasta [Inheritance1]: [Teacher@70325e14] e [Person@37ceb1df] (linhas 9 e 10 dos resultados; os números variam de uma execução para outra). Embora não tenhamos redefinido o método [toString] nas classes [Person] e [Teacher], o método [toString] da classe [Object] conseguiu exibir o nome real da classe do objeto.

Na pasta [Inheritance2], a classe [Person] redefine o método [toString] (veja acima). Voltemos ao programa [Main.java] da pasta [Inheritance2]:

1
2
3
4
5
6
7
8
    // IO.println(Object) exibe o resultado do método toString do objeto
    IO.println(e);
    IO.println(p);
    // um array de pessoas de tipos diferentes
    Person[] persons = { p, e };
    for (Person person : persons) {
        IO.println(person.getClass().getSimpleName() + " : " + person);
    }

Linha 2: o método [IO.println(Object)] aceita um parâmetro do tipo [Object]; portanto, como [Object] é a superclasse de todas as classes, qualquer objeto, neste caso um [Teacher], pode ser passado. Ele imprime no console o resultado do método [toString] do objeto. Como a vinculação é dinâmica, o método [toString] do objeto real é usado, neste caso o herdado da classe [Person]. Esse método retorna [getIdentity()], um método redefinido: para o professor [e], é executado, portanto, o método [getIdentity] da classe [Teacher], como mostra a linha 9 dos resultados. Portanto, não é necessário redefinir [toString] na classe [Teacher].

O mesmo mecanismo se aplica à concatenação de uma string com um objeto: em [" : " + person] (linha 7), o objeto [person] é convertido em string por seu método [toString]. O laço das linhas 6 a 8 percorre um array de referências [Person] que apontam, na verdade, para objetos de tipos diferentes: [getClass().getSimpleName()] retorna o nome real da classe de cada objeto (linhas 11 e 12 dos resultados).

4.2.7. Classes finais e classes seladas

A classe [Teacher] do pacote [Inheritance2] é declarada como [public final class Teacher extends Person]. A palavra-chave [final] impede que sejam derivadas classes da classe [Teacher]: a declaração [class TeacherResearcher extends Teacher] seria rejeitada pelo compilador. Uma classe é marcada como final quando não se pretende derivar dela. Vimos que a palavra-chave também se aplica a métodos: um método [final] não pode ser redefinido pelas classes derivadas, sem com isso proibir a derivação da classe. Por exemplo, a classe [String], derivada do JDK, é final.

Entre uma classe aberta a todas as derivações e uma classe final, o Java 17 acrescentou uma opção intermediária: a classe selada (sealed) ([sealed]), que fornece uma lista exaustiva de suas classes derivadas diretas. O programa [Classes13.java] ilustra isso:

// classes final e classes seladas (Java 17)
void main() {
    Person[] persons = {
        new Teacher("Lucile", "Dumas", 61),
        new Student("Paul", "Martin", "computer science"),
        new Adjunct("Marc", "Petit"),
        new Consultant("Lise", "Morel", "Airbus"),
    };
    for (Person p : persons) {
        IO.println(p.getClass().getSimpleName() + " : " + p.getIdentity());
    }
    // as subclasses diretas permitidas da classe selada Person
    IO.println("Person is sealed: " + Person.class.isSealed());
    for (Class<?> c : Person.class.getPermittedSubclasses()) {
        IO.println("permitted subclass: " + c.getSimpleName());
    }
}

// uma classe selada: somente as classes listadas após permits podem derivar dela
abstract sealed class Person permits Teacher, Student, Adjunct {
    private final String firstName;
    private final String lastName;

    protected Person(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }

    public String getIdentity() {
        return "[" + firstName + ", " + lastName + "]";
    }
}

// uma classe derivada de uma classe selada deve ser final, sealed ou non-sealed
final class Teacher extends Person {
    private final int section;

    public Teacher(String firstName, String lastName, int section) {
        super(firstName, lastName);
        this.section = section;
    }

    @Override
    public String getIdentity() {
        return super.getIdentity() + ", section " + section;
    }
}

final class Student extends Person {
    private final String major;

    public Student(String firstName, String lastName, String major) {
        super(firstName, lastName);
        this.major = major;
    }

    @Override
    public String getIdentity() {
        return super.getIdentity() + ", major " + major;
    }
}

// non-sealed: a hierarquia volta a ser aberta a partir desta classe
non-sealed class Adjunct extends Person {
    public Adjunct(String firstName, String lastName) {
        super(firstName, lastName);
    }
}

// uma classe derivada de Adjunct: permitida, pois Adjunct não é selada
class Consultant extends Adjunct {
    private final String company;

    public Consultant(String firstName, String lastName, String company) {
        super(firstName, lastName);
        this.company = company;
    }

    @Override
    public String getIdentity() {
        return super.getIdentity() + ", company " + company;
    }
}

// rejeitado pelo compilador: Artist não está listada na cláusula permits de Person
// final class Artist extends Person { ... }
  • Linha 20: a classe abstrata (veja adiante: não é possível criar objetos dessa classe, apenas de suas classes derivadas) [Person] é selada. Somente as classes [Teacher], [Student], e [Adjunct], listadas após a palavra-chave [permits], podem derivar dela. Quando as classes derivadas são declaradas no mesmo arquivo, como aqui, a cláusula [permits] pode ser omitida: as classes autorizadas são então as do arquivo que derivam diretamente dela. Em um programa maior, as classes autorizadas devem pertencer ao mesmo pacote que a classe selada (ou ao mesmo módulo, se a classe selada pertencer a um módulo nomeado);
  • linha 24: o construtor é protegido ([protected]): destina-se apenas às classes derivadas;
  • Linhas 35 e 49: uma classe derivada de uma classe selada deve especificar como ela própria pode ser derivada. As classes [Teacher] e [Student] são finais;
  • linha 64: a classe [Adjunct] é declarada como [non-sealed]: isso reabre a hierarquia, permitindo que qualquer classe derive dela. Uma terceira opção é declará-la ela mesma como [sealed], com sua própria lista de classes permitidas;
  • linhas 71 a 83: a classe [Consultant] deriva de [Adjunct], o que é permitido;
  • linhas 85 e 86: uma classe [Artist] derivada de [Person] seria rejeitada;
  • Linhas 13 a 16: a descrição de uma classe ([Person.class]) indica se ela é selada ([isSealed]) e lista suas classes derivadas diretas autorizadas ([getPermittedSubclasses]).

Resultados:

1
2
3
4
5
6
7
8
9
> java Classes13.java
Teacher : [Lucile, Dumas], section 61
Student : [Paul, Martin], major computer science
Adjunct : [Marc, Petit]
Consultant : [Lise, Morel], company Airbus
Person is sealed: true
permitted subclass: Teacher
permitted subclass: Student
permitted subclass: Adjunct

Se você remover o comentário da classe [Artist] (dotando-a de um construtor), o compilador relata:

1
2
3
4
5
6
> java Classes13.java
Classes13.java:86: error: class is not allowed to extend sealed class: Classes13.Person (as it is not listed in its 'permits' clause)
final class Artist extends Person { Artist() { super("a", "b"); } }
      ^
1 error
error: compilation failed

Para que serve uma classe selada? Ela permite que o autor de uma hierarquia de classes mantenha o controle sobre ela: o autor sabe que toda [Person] é um [Teacher], um [Student], ou um [Adjunct]. O compilador também sabe disso e o utiliza na filtragem por padrões, discutida no final do capítulo: um [switch] que trata os três casos é completo. O mecanismo também se aplica às interfaces ([sealed interface]), discutidas adiante.

4.3. Sem sobrecarga de operadores: equals, compareTo…

Algumas linguagens, como C# ou C++, permitem redefinir o significado dos operadores ([+], [==], [<]…) para uma classe. Java não permite isso: os operadores sempre têm o significado atribuído a eles pela linguagem. A única exceção é o operador [+] aplicado a uma string, que realiza a concatenação e, para isso, usa o método [toString] do objeto concatenado. Em vez de operadores, escrevemos métodos que seguem convenções bem estabelecidas:

Operação
Método Java
Exemplo
Igualdade de conteúdo ([==] compara referências)
[boolean equals(Object o)], herdado de [Object]
[s1.equals(s2)]
Comparação ([<], [>]…)
[int compareTo(T other)] da interface [Comparable<T>]: resultado negativo, nulo ou positivo
[s1.compareTo(s2) < 0]
operações aritméticas
métodos com nomes explícitos
[a.add(b)], [a.multiply(b)] para [BigDecimal]
Adição a uma coleção ([+=])
[add]
[list.add(p)]

4.3.1. Um exemplo

A pasta [Lists] contém uma classe [ListOfPersons], uma lista de pessoas, cujos métodos funcionam como os operadores [+] e [+=]. As classes [Person] e [Teacher] desta pasta são versões simplificadas das da pasta [Inheritance2]: os campos são [final] e não têm modificadores; não há mais mensagens de acompanhamento nem contadores. As pessoas são organizadas em uma lista genérica [List<Person>] (as classes genéricas são discutidas mais adiante neste capítulo; as listas são abordadas no próximo capítulo). Em vez de fazer a classe [ListOfPersons] herdar de uma classe de lista derivada do JDK, colocamos a lista em um campo privado da classe. Chama-se a isso usar composição em vez de herança: a classe [ListOfPersons] expõe, assim, somente as operações que ela escolheu. Da interface [List<Person>], usamos apenas os seguintes elementos:

  • o método [l.add(p)], que adiciona a pessoa [p] à lista [l], e o método [l.addAll(l2)], que adiciona a ela todos os elementos da lista [l2];
  • o método [l.size()], que retorna o número de elementos da lista [l];
  • os métodos [l.get(i)] e [l.set(i, p)], que leem e modificam o elemento de número i da lista [l].

A definição da classe [ListOfPersons] é a seguinte: [ListOfPersons.java]:

import java.util.ArrayList;
import java.util.List;
import java.util.StringJoiner;

public class ListOfPersons {
    // as pessoas da lista
    private final List<Person> persons = new ArrayList<>();

    // número de pessoas na lista
    public int size() {
        return persons.size();
    }

    // o equivalente a um operador +: retorna uma nova lista contendo as pessoas
    // da lista atual e a pessoa p
    public ListOfPersons plus(Person p) {
        ListOfPersons result = new ListOfPersons();
        result.persons.addAll(persons);
        result.persons.add(p);
        return result;
    }

    // o equivalente a um operador +=: adiciona p à lista atual, que é retornada
    public ListOfPersons add(Person p) {
        persons.add(p);
        return this;
    }

    // o equivalente a um indexador: leitura e escrita do elemento nº i
    public Person get(int i) {
        return persons.get(i);
    }

    public void set(int i, Person p) {
        persons.set(i, p);
    }

    // posição da pessoa com o sobrenome dado, -1 se ela não existir
    public int indexOf(String lastName) {
        for (int i = 0; i < persons.size(); i++) {
            if (persons.get(i).getLastName().equals(lastName)) {
                return i;
            }
        }
        return -1;
    }

    // toString: retorna (pessoa1,pessoa2,...)
    @Override
    public String toString() {
        StringJoiner joiner = new StringJoiner(",", "(", ")");
        for (Person p : persons) {
            joiner.add(p.toString());
        }
        return joiner.toString();
    }
}
  • linhas 1 a 3: diferentemente do arquivo compacto [Main.java], um arquivo comum não importa automaticamente as classes do módulo [java.base]: ele deve importar as que usa (exceto as do pacote [java.lang], como [String], que são sempre conhecidas). As cláusulas [import] são fornecidas com os pacotes;
  • linha 7: a lista de pessoas. A palavra-chave [final] indica que o campo sempre se referirá à mesma lista; o conteúdo da lista pode mudar. [new ArrayList<>()] cria uma lista vazia; o operador “diamante” [<>] permite que o compilador infira o tipo dos elementos, [Person], a partir do tipo do campo;
  • linhas 10 a 12: o número de pessoas;
  • linhas 16 a 21: o método [plus] funciona como um operador [+] na operação [l.plus(p)], em que [l] é do tipo [ListOfPersons] e [p] é do tipo [Person] ou de um tipo derivado dele. O método cria uma nova lista (linha 17), copia para ela as pessoas da lista atual (linha 18) e, em seguida, adiciona a pessoa [p] (linha 19). Como acontece com o [+] para números ou strings, os operandos não são modificados. Como a lista [result] é da mesma classe, o método tem acesso ao seu campo privado [result.persons]. A lista retornada é do tipo [ListOfPersons], o que permite chamadas encadeadas, como em [l.plus(p1).plus(p2)];
  • linhas 24 a 27: o método [add] funciona como um operador [+=]: ele modifica a lista atual adicionando-lhe a pessoa [p] e retorna essa mesma lista, o que também permite chamadas encadeadas;
  • Linhas 49 a 56: redefinimos o método [toString] para exibir uma lista de pessoas na forma (pessoa1, pessoa2, ...), em que pessoai é o resultado do método [toString] da própria pessoa. Um objeto [StringJoiner] (linha 51) constrói uma string a partir de elementos sucessivos ([add], linha 53), separando-os com o separador especificado (neste caso, uma vírgula) e envolvendo-os com um prefixo e um sufixo (neste caso, parênteses).

Observe que a classe [ListOfPersons] não tem construtor. Ela usa, portanto, o construtor padrão, que não recebe parâmetros e não faz nada além de inicializar o campo [persons] com o valor especificado em sua declaração. As linhas 29 a 46 são discutidas na próxima seção.

O programa de teste [Main.java] começa assim:

void main() {
    // — métodos em vez de operadores
    String s1 = "jean";
    String s2 = new StringBuilder("je").append("an").toString();
    IO.println("s1 == s2 : " + (s1 == s2) + ", s1.equals(s2) : " + s1.equals(s2));
    IO.println("s1.compareTo(\"paul\") : " + s1.compareTo("paul"));
    BigDecimal a = new BigDecimal("0.10"), b = new BigDecimal("0.20");
    IO.println("a + b = " + a.add(b) + ", a < b : " + (a.compareTo(b) < 0));

    // — o método plus
    // uma lista de pessoas
    ListOfPersons l = new ListOfPersons();
    // adicionando pessoas
    l = l.plus(new Person("jean", "martin", 10)).plus(new Person("pauline", "leduc", 12));
    // exibição
    IO.println("l=" + l);
    // l.plus(p) retorna uma nova lista: l não é modificada
    ListOfPersons l2 = l.plus(new Person("louis", "durand", 8));
    IO.println("l=" + l);
    IO.println("l2=" + l2);

    // — o método add
    ListOfPersons l3 = l;
    // add modifica a lista referenciada por l, sem criar uma nova lista
    l.add(new Teacher("camille", "germain", 27, 60));
    IO.println("l=" + l);
    // l e l3 ainda referenciam o mesmo objeto
    IO.println("l3 == l : " + (l3 == l));
  • Linhas 3 a 5: duas strings com o mesmo conteúdo, mas distintas: a string [s2] é construída em tempo de execução. O operador [==] compara as referências, enquanto o método [equals] compara os conteúdos. Para comparar duas strings, deve-se sempre usar [equals];
  • linha 6: o método [compareTo] retorna um número negativo porque “jean” vem antes de “paul” na ordem dos códigos de caracteres;
  • Linhas 7 e 8: a classe [BigDecimal] (números decimais exatos, que usaremos para os valores monetários) substitui os operadores [+] e [<] pelos métodos [add] e [compareTo];
  • linha 12: criação de uma lista vazia de pessoas [l];
  • linha 14: adição de duas pessoas com o método [plus];
  • linha 18: [l.plus(p)] cria uma nova lista, [l2]; a lista [l] permanece inalterada;
  • linha 25: adiciona um professor com o método [add];
  • linhas 16 a 20: a concatenação de uma string com um objeto usa o método [toString], que é redefinido na classe [ListOfPersons].

Resultados (início):

1
2
3
4
5
6
7
8
9
> java Main.java
s1 == s2 : false, s1.equals(s2) : true
s1.compareTo("paul") : -6
a + b = 0.30, a < b : true
l=([jean, martin, 10],[pauline, leduc, 12])
l=([jean, martin, 10],[pauline, leduc, 12])
l2=([jean, martin, 10],[pauline, leduc, 12],[louis, durand, 8])
l=([jean, martin, 10],[pauline, leduc, 12],Teacher[[camille, germain, 27],60])
l3 == l : true

Por que há dois métodos, se [l = l.plus(p)] produz o mesmo resultado que [l.add(p)]? O método [plus] cria uma nova lista, copia para ela todas as pessoas de [l] e, depois, [l] passa a referenciar essa nova lista, enquanto a antiga é descartada pelo coletor de lixo. O método [add] adiciona a pessoa à lista existente, sem copiá-la. A linha 23 armazena uma segunda referência, [l3], à lista [l]; após a chamada a [l.add(...)], as duas referências continuam apontando para o mesmo objeto (linha 9 dos resultados), o que prova que a lista não foi recriada. Para uma lista grande, ou dentro de um laço, a diferença de desempenho é significativa. A escolha entre os dois estilos fica evidente no JDK: os objetos imutáveis [String] e [BigDecimal] retornam novos objetos; as listas e o [StringBuilder] são modificados.

4.4. Sem indexadores: métodos get e set

Aqui, continuamos a usar a classe [ListOfPersons]. Se [l] é um objeto [ListOfPersons], queremos poder referenciar a pessoa de índice i da lista [l], tanto para leitura quanto para escrita. Algumas linguagens permitem definir um “indexador” para isso, o que possibilita usar a notação [l[i]] em um objeto. Java não permite: a notação [[i]] é reservada aos arrays. Por convenção, escrevemos métodos [get(int i)] e [set(int i, value)], exatamente como fazem as listas do JDK:

    // o equivalente a um indexador: leitura e escrita do elemento nº i
    public Person get(int i) {
        return persons.get(i);
    }

    public void set(int i, Person p) {
        persons.set(i, p);
    }

    // posição da pessoa com o sobrenome dado, -1 se ela não existir
    public int indexOf(String lastName) {
        for (int i = 0; i < persons.size(); i++) {
            if (persons.get(i).getLastName().equals(lastName)) {
                return i;
            }
        }
        return -1;
    }
  • linhas 2 a 4: o método [get] retorna a pessoa de número i da lista privada [persons];
  • linhas 6 a 8: o método [set] atribui a ela a pessoa [p];
  • linhas 11 a 18: queremos também poder obter a posição, na lista, da pessoa com determinado nome, ou -1 se essa pessoa não estiver na lista. O nome [indexOf] é o do método equivalente das listas e das strings do JDK. Os nomes são comparados com [equals] (linha 13).

O programa de teste continua da seguinte forma:

    // — os métodos get, set e indexOf em vez de indexadores
    // alterando o elemento nº 1
    l.set(1, new Person("franck", "gallon", 5));
    // exibindo o elemento nº 1
    IO.println("l.get(1)=" + l.get(1));
    // exibindo a lista l
    IO.println("l=" + l);
    // procurando pessoas pelo sobrenome
    String[] lastNames = { "martin", "germain", "xx" };
    for (String lastName : lastNames) {
        int index = l.indexOf(lastName);
        if (index != -1) {
            IO.println("Person(" + lastName + ")=" + l.get(index));
        } else {
            IO.println("Person(" + lastName + ") does not exist");
        }
    }
  • linha 3: chamada ao método [set];
  • linha 5: chamada ao método [get];
  • linha 11: chamada ao método [indexOf];
  • linha 13: chamada ao método [get].

Resultados (final):

1
2
3
4
5
6
...
l.get(1)=[franck, gallon, 5]
l=([jean, martin, 10],[franck, gallon, 5],Teacher[[camille, germain, 27],60])
Person(martin)=[jean, martin, 10]
Person(germain)=Teacher[[camille, germain, 27],60]
Person(xx) does not exist

4.5. Sem estruturas: tipos primitivos e records

4.5.1. Valor e referência

Outras linguagens, como C ou C#, oferecem estruturas além das classes: tipos cujas variáveis contêm diretamente os dados, e não uma referência a um objeto. Java não as tem. Ele distingue duas famílias de tipos:

  • os oito tipos primitivos ([byte], [short], [int], [long], [float], [double], [char], [boolean]): uma variável de tipo primitivo contém o próprio valor;
  • os tipos de referência: classes (inclusive [String]), interfaces, arrays, records etc. Uma variável de tipo de referência contém uma referência a um objeto, ou o valor [null].

O programa [Classes14.java] ilustra a diferença:

// tipos primitivos e tipos de referência: cópia de valor, cópia de referência
void main() {
    // duas variáveis de tipo primitivo
    int age1 = 10;
    int age2 = age1;
    IO.println("age1=" + age1 + ", age2=" + age2);
    // age2 é modificada
    age2 = 30;
    // verificando age1 e age2
    IO.println("age1=" + age1 + ", age2=" + age2);

    // um objeto op1
    CPerson op1 = new CPerson();
    op1.name = "paul";
    op1.age = 10;
    IO.println("op1=CPerson(" + op1.name + "," + op1.age + ")");
    // um objeto op2
    CPerson op2 = op1;
    IO.println("op2=CPerson(" + op2.name + "," + op2.age + ")");
    // op2 é modificado
    op2.name = "nicole";
    op2.age = 30;
    // verificando op1 e op2
    IO.println("op1=CPerson(" + op1.name + "," + op1.age + ")");
    IO.println("op2=CPerson(" + op2.name + "," + op2.age + ")");

    // uma cópia explícita do objeto
    CPerson op3 = new CPerson();
    op3.name = op1.name;
    op3.age = op1.age;
    op3.age = 50;
    IO.println("op1=CPerson(" + op1.name + "," + op1.age + ")");
    IO.println("op3=CPerson(" + op3.name + "," + op3.age + ")");
}

// classe CPerson
class CPerson {
    String name = "";
    int age;
}
  • Linhas 37 a 40: uma classe com dois campos acessíveis a partir do pacote: [name], [age]. Os campos não privados, que em geral são desaconselhados, tornam o exemplo mais fácil de ler aqui.

Resultados:

1
2
3
4
5
6
7
8
9
> java Classes14.java
age1=10, age2=10
age1=10, age2=30
op1=CPerson(paul,10)
op2=CPerson(paul,10)
op1=CPerson(nicole,30)
op2=CPerson(nicole,30)
op1=CPerson(nicole,30)
op3=CPerson(nicole,50)

A declaração [int age1 = 10;] (linha 4) reserva uma posição de memória que contém o inteiro 10: o valor de [age1] é o próprio inteiro. No caso da classe, o objeto ([name], [age]) é criado explicitamente com o operador [new] (linha 13). O objeto é colocado em uma área de memória gerenciada pelo coletor de lixo, o heap, e o valor de [op1] é o endereço (a referência) desse objeto.

Quando se escreve [int age2 = age1;] no programa (linha 5), o valor de [age1], o inteiro 10, é copiado para [age2]: trata-se de uma cópia de valor. Modificar [age2] não modifica [age1] (linha 3 dos resultados). Considere agora a instrução [CPerson op2 = op1;] (linha 18). O valor de [op1] é copiado para [op2], mas, como esse valor é o endereço do objeto, o próprio objeto não é duplicado: [op1] e [op2] referem-se ao mesmo objeto. Se o objeto apontado por [op2] for modificado, o objeto apontado por [op1] também será modificado, já que são o mesmo (linhas 6 e 7 dos resultados). Para obter um segundo objeto, é preciso criá-lo e copiar para ele os campos do primeiro (linhas 28 a 30): modificar a cópia não modifica o original (linhas 8 e 9 dos resultados).

Image

Dessas explicações, podemos concluir que:

  • o valor de uma variável de tipo primitivo é o próprio dado;
  • o valor de uma variável de tipo de referência é o endereço do objeto para o qual ela aponta;
  • a atribuição e a passagem de parâmetros sempre copiam o valor da variável: o próprio dado, no caso de um tipo primitivo, e a referência, no caso de um objeto.

Cada tipo primitivo corresponde a uma classe chamada “wrapper” (invólucro) no pacote [java.lang]: [Integer] para [int], [Double] para [double], [Boolean] para [boolean] e assim por diante. O compilador converte automaticamente um valor primitivo em um objeto wrapper e vice-versa (“autoboxing” e “unboxing”): precisaremos disso com os genéricos, que só aceitam tipos de referência. Uma variável [Integer] pode ser igual a [null], mas uma variável [int] nunca pode.

Para representar um pequeno dado composto (um ponto, uma cor, uma data, um valor monetário) tratado como um valor, Java usa classes imutáveis: seus objetos não podem ser modificados depois de criados. Compartilhar uma referência a um objeto imutável é seguro: ninguém pode modificá-lo, e o objeto passa a se comportar como um valor. Duas ferramentas completam esse sistema: o método *[equals]*, que compara dois objetos com base em seu conteúdo, e os records, que declaram uma classe imutável em uma única linha. Esse é o assunto dos dois parágrafos seguintes.

4.5.2. Igualdade de dois objetos: equals e hashCode

Como vimos, o operador [==] aplicado a duas referências indica se elas se referem ao mesmo objeto, e o método [equals], herdado de [Object], faz o mesmo. Para que dois objetos distintos com o mesmo conteúdo sejam considerados iguais, uma classe deve redefinir o método [equals] e, necessariamente junto com ele, o método [hashCode]. O programa [Classes15.java] demonstra isso:

// igualdade de dois objetos: equals e hashCode
void main() {
    Person p1 = new Person("paul", 10);
    Person p2 = new Person("paul", 10);
    Person p3 = new Person("nicole", 30);
    // == compara as referências, equals compara os valores
    IO.println("p1 == p2 : " + (p1 == p2) + ", p1.equals(p2) : " + p1.equals(p2)
            + ", p1.equals(p3) : " + p1.equals(p3));
    // dois objetos iguais têm o mesmo código hash
    IO.println("p1.hashCode() == p2.hashCode() : " + (p1.hashCode() == p2.hashCode()));
    // um conjunto (Set) não contém dois objetos iguais
    Set<Person> persons = new HashSet<>();
    persons.add(p1);
    persons.add(p2);
    persons.add(p3);
    IO.println("size of the set: " + persons.size());
    IO.println("the set contains (paul,10): " + persons.contains(new Person("paul", 10)));
}

class Person {
    // campos
    private final String name;
    private final int age;

    // construtor
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // duas pessoas são iguais se tiverem o mesmo nome e a mesma idade
    @Override
    public boolean equals(Object o) {
        // mesmo objeto?
        if (this == o) {
            return true;
        }
        // o é uma Person (e não null)?
        if (!(o instanceof Person other)) {
            return false;
        }
        // comparação dos campos
        return age == other.age && Objects.equals(name, other.name);
    }

    // código hash consistente com equals
    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

    @Override
    public String toString() {
        return "Person(" + name + "," + age + ")";
    }
}
  • linhas 32 a 44: o método [equals] redefine o da classe [Object]. Seu parâmetro é do tipo [Object]: uma pessoa pode ser comparada a qualquer objeto. O método segue um padrão conhecido:
    • linhas 35 a 37: um objeto é igual a si mesmo;
    • linhas 39 a 41: a expressão [o instanceof Person other] (Java 16) é verdadeira se [o] referencia um objeto do tipo [Person] (ou de uma classe derivada) e falsa caso contrário, em particular se [o] for igual a [null]. Quando é verdadeira, a variável [other], do tipo [Person], referencia o objeto [o]: seus campos podem ser usados. Esse “padrão de tipo” é explicado em detalhes no final do capítulo;
    • linha 43: os campos são comparados. O método [Objects.equals(a, b)] compara dois objetos com [equals] tratando o caso em que um deles é [null];
  • linhas 47 a 50: o método [hashCode] retorna um inteiro calculado a partir dos mesmos campos, neste caso pelo método [Objects.hash]. A regra é obrigatória: dois objetos iguais no sentido de [equals] devem ter o mesmo código hash. Os dicionários e conjuntos do JDK (próximo capítulo) organizam os objetos com base nesse código e deixariam de funcionar se a regra não fosse respeitada;
  • linhas 12 a 17: um conjunto [HashSet] nunca contém dois objetos iguais: adicionar [p2], que é igual a [p1], não tem efeito, e a busca por uma nova pessoa ([paul, 10]) é bem-sucedida.

Resultados:

1
2
3
4
5
> java Classes15.java
p1 == p2 : false, p1.equals(p2) : true, p1.equals(p3) : false
p1.hashCode() == p2.hashCode() : true
size of the set: 2
the set contains (paul,10): true

Digitar [equals] e [hashCode] manualmente é trabalhoso e propenso a erros; os ambientes de desenvolvimento podem gerá-los. Os records, por sua vez, fornecem-nos automaticamente.

4.5.3. Objetos imutáveis

O programa [Classes16.java] demonstra duas maneiras de definir dados imutáveis:

// objetos imutáveis: uma classe imutável e um record
void main() {
    Point a = new Point(1, 2);
    // a.x = 5;   // rejeitado: o campo x é final
    Point b = a.move(3, 4);
    IO.println("a=" + a + ", b=" + b);

    // um record: construtor, acessores, toString, equals e hashCode são gerados
    Color red = new Color(255, 0, 0);
    Color red2 = new Color(255, 0, 0);
    IO.println("red=" + red + ", r=" + red.r());
    IO.println("red.equals(red2) : " + red.equals(red2) + ", red == red2 : " + (red == red2));
    // uma cópia modificada, criada por métodos escritos à mão
    Color pink = red.withG(128).withB(128);
    IO.println("red=" + red + ", pink=" + pink);
}

// uma classe imutável: final, campos privados e final, sem setter
final class Point {
    private final int x;
    private final int y;

    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public int getX() {
        return x;
    }

    public int getY() {
        return y;
    }

    // não modificamos o ponto: retornamos um novo
    public Point move(int dx, int dy) {
        return new Point(x + dx, y + dy);
    }

    @Override
    public String toString() {
        return "(" + x + "," + y + ")";
    }
}

// um record: uma classe imutável declarada em uma linha... ou quase
record Color(int r, int g, int b) {
    // métodos que retornam uma cópia modificada do record
    public Color withG(int g) {
        return new Color(r, g, b);
    }

    public Color withB(int b) {
        return new Color(r, g, b);
    }
}
  • linhas 19 a 45: uma classe imutável escrita manualmente. Ela é final, para que nenhuma classe derivada possa lhe acrescentar estado mutável; seus campos são privados e [final]; ela não tem modificadores. Para “mover” um ponto, o método [move] retorna um novo ponto (linhas 37 a 39);
  • Linha 48: um record (Java 16). O cabeçalho [record Color(int r, int g, int b)] declara uma classe final com três campos privados ([final]), conhecidos como componentes do record, um construtor de três parâmetros e três acessores: [r()], [g()], [b()], além dos métodos [toString], [equals] e [hashCode], todos os quais usam os componentes;
  • Linhas 50 a 56: é possível adicionar métodos a um record. Como um record é imutável, ele não pode ser modificado: em vez disso, cria-se uma cópia em que um componente foi alterado. Esses métodos são chamados de “withers” (do inglês “with”); outras linguagens oferecem uma expressão para essa finalidade, [with], que não existe no Java 25;
  • linha 11: o acessor de um componente tem o nome do componente, sem o prefixo [get];
  • linha 12: dois records com os mesmos componentes são iguais no sentido de [equals], embora sejam distintos;
  • linha 14: os métodos “wither” são encadeados.

Resultados:

1
2
3
4
5
> java Classes16.java
a=(1,2), b=(4,6)
red=Color[r=255, g=0, b=0], r=255
red.equals(red2) : true, red == red2 : false
red=Color[r=255, g=0, b=0], pink=Color[r=255, g=128, b=128]

O [toString] gerado exibe o nome do record e seus componentes (linha 3 dos resultados). Note que um record é a maneira mais concisa de declarar um pequeno dado imutável: é o tipo que usaremos para as faixas da tabela de imposto na aplicação de exemplo deste capítulo. Os records são discutidos em detalhes mais adiante.

4.6. Interfaces

4.6.1. Um primeiro exemplo

Uma interface é um conjunto de declarações de métodos que forma um contrato. Uma classe que opta por implementar uma interface se compromete a fornecer uma implementação de todos os métodos abstratos definidos na interface. O compilador verifica essa implementação.

Por exemplo, eis a definição (simplificada) da interface [java.util.Iterator<E>] do JDK, que permite percorrer os elementos de uma coleção: [public interface Iterator<E> { boolean hasNext(); E next(); }]. Os métodos da interface são definidos apenas por suas assinaturas, seguidas de ponto e vírgula: não têm código e são implicitamente públicos e abstratos. São as classes que implementam a interface que fornecem o código de seus métodos. Uma classe chamada [C] declara que implementa a interface com a palavra-chave [implements]: [public class C implements Iterator<String>], e deve então definir os dois métodos públicos [public boolean hasNext() { ... }] e [public String next() { ... }].

Uma convenção comum (embora não universal; o JDK não a segue) é iniciar o nome de uma interface com a letra I. Os exemplos a seguir compõem a pasta [Statistics]. Considere a seguinte interface, [IStats.java]:

1
2
3
4
5
6
7
public interface IStats {
    // média de uma série de valores
    double average();

    // desvio padrão da série
    double standardDeviation();
}

A interface [IStats] contém:

  • um método [average]: para calcular a média de uma série de valores;
  • um método [standardDeviation]: para calcular o desvio padrão.

Observe que não se especifica em lugar nenhum a qual conjunto de valores nos referimos. Pode ser a média das notas de uma turma, a média mensal de vendas de determinado produto, a temperatura média em um determinado local… Esse é o princípio das interfaces: supomos a existência de métodos no objeto, mas não a de dados específicos. Os métodos não têm o prefixo [get]: são cálculos, e não acessos a campos, e essa escolha permitirá que um record implemente a interface.

Uma primeira classe que implementa a interface [IStats] poderia ser uma classe usada para armazenar as notas dos alunos de uma turma em determinada disciplina. Um aluno é caracterizado pelo seguinte record [Student], [Student.java]:

1
2
3
// um aluno
public record Student(String firstName, String lastName) {
}

O aluno é identificado por seu nome e sobrenome. O record apresentado no parágrafo anterior faz isso em uma única linha. Uma nota é representada pelo seguinte record, [Grade], que segue [Grade.java]:

1
2
3
4
5
6
7
// a nota de um aluno
public record Grade(Student student, double value) {
    @Override
    public String toString() {
        return "[" + student.firstName() + "," + student.lastName() + "," + value + "]";
    }
}

A nota é definida pelo aluno avaliado e pela nota em si. O record redefine o método [toString] gerado pelo compilador para exibir uma nota na forma [firstName,lastName,value].

As notas de todos os alunos em determinada disciplina são agrupadas na seguinte classe [ArrayOfGrades]: [ArrayOfGrades.java]:

import java.util.Arrays;

public class ArrayOfGrades implements IStats {
    // campos
    private final String subject;
    private final Grade[] grades;
    private final double average;
    private final double standardDeviation;

    // construtor
    public ArrayOfGrades(String subject, Grade[] grades) {
        // armazenando os dados
        this.subject = subject;
        this.grades = grades;
        // calculando a média das notas
        double sum = 0;
        for (Grade grade : grades) {
            sum += grade.value();
        }
        average = grades.length != 0 ? sum / grades.length : -1;
        // calculando o desvio padrão
        double squares = 0;
        for (Grade grade : grades) {
            squares += Math.pow(grade.value() - average, 2);
        }
        standardDeviation = grades.length != 0 ? Math.sqrt(squares / grades.length) : -1;
    }

    // getters
    public String getSubject() {
        return subject;
    }

    public Grade[] getGrades() {
        return grades;
    }

    // implementação dos métodos da interface IStats
    @Override
    public double average() {
        return average;
    }

    @Override
    public double standardDeviation() {
        return standardDeviation;
    }

    // toString
    @Override
    public String toString() {
        return "subject=" + subject + ", grades=" + Arrays.toString(grades);
    }
}
  • Linha 3: a classe [ArrayOfGrades] implementa a interface [IStats]. Ela deve, portanto, implementar os métodos [average] e [standardDeviation]. Eles são implementados nas linhas 39 a 47. A anotação [@Override] também é usada para implementar um método de interface;
  • linhas 5 a 8: quatro campos [final]: a disciplina para a qual o objeto armazena notas, o array de notas, a média e o desvio padrão das notas;
  • linhas 11 a 27: o construtor. Aqui, supomos que as notas passadas ao construtor não mudarão depois. Por isso, usamos o construtor para calcular imediatamente a média e o desvio padrão dessas notas e armazená-los. Um campo [final], como [average], pode receber um valor no construtor (linha 20); não pode receber valor depois. As expressões [condition ? value1 : value2] definem como -1 a média e o desvio padrão de um array vazio. [Math.pow(x, 2)] calcula x², e [Math.sqrt] calcula a raiz quadrada;
  • linhas 50 a 53: o método [toString] usa o método estático [Arrays.toString], que retorna os elementos de um array entre colchetes, separados por vírgulas, cada um convertido em string por seu método [toString], neste caso, o do record [Grade].

Na classe anterior, as notas eram armazenadas em um array. Não era possível adicionar uma nova nota depois que o objeto [ArrayOfGrades] era criado. Propomos agora uma segunda implementação da interface [IStats], chamada [ListOfGrades], em que, desta vez, as notas são armazenadas em uma lista [List<Grade>], com a possibilidade de adicionar notas depois da criação inicial do objeto [ListOfGrades]: [ListOfGrades.java]:

import java.util.List;

public class ListOfGrades implements IStats {
    // campos
    private final String subject;
    private final List<Grade> grades;
    // média e desvio padrão armazenados (null: ainda não calculados)
    private Double average;
    private Double standardDeviation;

    // construtor
    public ListOfGrades(String subject, List<Grade> grades) {
        this.subject = subject;
        this.grades = grades;
    }

    // getters
    public String getSubject() {
        return subject;
    }

    public List<Grade> getGrades() {
        return grades;
    }

    // adicionando uma nota
    public void add(Grade grade) {
        grades.add(grade);
        // a média e o desvio padrão precisarão ser recalculados
        average = null;
        standardDeviation = null;
    }

    // média das notas: calculada na primeira solicitação
    @Override
    public double average() {
        if (average == null) {
            average = computeAverage();
        }
        return average;
    }

    // desvio padrão das notas: calculado na primeira solicitação
    @Override
    public double standardDeviation() {
        if (standardDeviation == null) {
            standardDeviation = computeStandardDeviation();
        }
        return standardDeviation;
    }

    private double computeAverage() {
        if (grades.isEmpty()) {
            return -1;
        }
        double sum = 0;
        for (Grade grade : grades) {
            sum += grade.value();
        }
        return sum / grades.size();
    }

    private double computeStandardDeviation() {
        if (grades.isEmpty()) {
            return -1;
        }
        double m = average();
        double squares = 0;
        for (Grade grade : grades) {
            squares += Math.pow(grade.value() - m, 2);
        }
        return Math.sqrt(squares / grades.size());
    }

    // toString
    @Override
    public String toString() {
        return "subject=" + subject + ", grades=" + grades;
    }
}
  • linha 3: a classe [ListOfGrades] implementa a interface [IStats];
  • linha 6: as notas agora são armazenadas em uma lista, e não em um array;
  • linhas 27 a 32: agora é possível adicionar uma nota às já armazenadas. A média e o desvio padrão não são mais calculados no construtor, mas sob demanda, dentro dos próprios métodos da interface: [average] (linhas 35 a 41) e [standardDeviation] (linhas 44 a 50). Depois de calculados, esses valores são armazenados para que não sejam recalculados a cada solicitação: diz-se que estão em cache. Adicionar uma nota invalida o cache;
  • linhas 8 e 9: o cache. O tipo [Double] é a classe wrapper do tipo primitivo [double]: diferentemente de uma variável [double], uma variável [Double] pode ter o valor [null], que aqui significa “ainda não calculado”. Os campos não inicializados recebem o valor [null] quando o objeto é construído;
  • linhas 38 e 40: o compilador converte automaticamente o [double] retornado por [computeAverage] no objeto [Double] (“autoboxing”) e o objeto [Double] em [double] para o valor de retorno do método (“unboxing”).

Um programa de teste poderia ser o seguinte [Main.java]:

void main() {
    // alguns alunos e suas notas de inglês
    Student[] students = {
        new Student("Paul", "Martin"), new Student("Maxime", "Germain"), new Student("Berthine", "Samin")
    };
    Grade[] grades = { new Grade(students[0], 14), new Grade(students[1], 16), new Grade(students[2], 18) };
    // que são armazenadas em um objeto ArrayOfGrades
    ArrayOfGrades english = new ArrayOfGrades("english", grades);
    // exibição da média e do desvio padrão
    displayStats(english);
    // as mesmas notas em um objeto ListOfGrades
    ListOfGrades french = new ListOfGrades("french", new ArrayList<>(List.of(grades)));
    displayStats(french);
    // adicionamos uma nota
    french.add(new Grade(new Student("Jérôme", "Jaric"), 10));
    displayStats(french);
    // uma variável pode ter uma interface como tipo
    IStats stats = english;
    IO.println("English average: " + stats.average());
    stats = french;
    IO.println("French average: " + stats.average());
}

// exibição da média e do desvio padrão de um objeto que implementa IStats
void displayStats(IStats values) {
    IO.println(values + ", Average=" + values.average() + ", Standard deviation=" + values.standardDeviation());
}
  • linhas 3 a 5: criação de um array de alunos;
  • linha 6: criação de um array de notas;
  • linha 8: um objeto [ArrayOfGrades] cuja média e cujo desvio padrão são exibidos na linha 10;
  • linha 12: um objeto [ListOfGrades], cuja média e cujo desvio padrão são exibidos na linha 13. [List.of(grades)] retorna uma lista somente de leitura com os elementos do array; o construtor da classe [ArrayList] a transforma em uma lista modificável à qual é possível adicionar notas;
  • linha 15: uma nova nota é adicionada, seguida de uma atualização da exibição;
  • Linhas 25 a 27: o método [displayStats] recebe como parâmetro um tipo *[IStats] , que é um tipo de interface. Isso significa que o parâmetro real pode ser qualquer objeto que implemente a interface *[IStats] . Ao usar um objeto de dados de um tipo de interface, somente são usados os métodos da interface implementados pelo objeto. Os demais são ignorados. Essa propriedade é semelhante ao polimorfismo discutido para as classes. Se um conjunto de classes Ci que não estão relacionadas entre si por herança (e, portanto, não podem usar o polimorfismo baseado em herança) compartilha um conjunto de métodos com a mesma assinatura, pode ser útil agrupar esses métodos em uma interface I que todas as classes em questão implementariam. As instâncias dessas classes Ci podem então ser usadas como parâmetros reais de métodos que aceitam um parâmetro formal do tipo I, isto é, métodos que usam apenas os métodos dos objetos Ci definidos na interface I, e não os campos e métodos específicos das diversas classes Ci;
  • linhas 18 a 21: uma variável pode ser do tipo de uma interface. Ela pode então referenciar qualquer objeto de uma classe que implemente a interface. O compilador permite o acesso apenas aos métodos da interface (e aos da classe [Object], como [toString]).

Resultados:

1
2
3
4
5
6
> java Main.java
subject=english, grades=[[Paul,Martin,14.0], [Maxime,Germain,16.0], [Berthine,Samin,18.0]], Average=16.0, Standard deviation=1.632993161855452
subject=french, grades=[[Paul,Martin,14.0], [Maxime,Germain,16.0], [Berthine,Samin,18.0]], Average=16.0, Standard deviation=1.632993161855452
subject=french, grades=[[Paul,Martin,14.0], [Maxime,Germain,16.0], [Berthine,Samin,18.0], [Jérôme,Jaric,10.0]], Average=14.5, Standard deviation=2.958039891549808
English average: 16.0
French average: 14.5

A concatenação de um número ([double]) com uma string usa o método [Double.toString], que sempre escreve o número com um ponto decimal e pelo menos uma casa decimal (16.0), independentemente da configuração de idioma da estação de trabalho. Para uma exibição no estilo francês, use [String.format("%.2f", x)], como no exemplo a seguir.

Por fim, observe que as interfaces podem ser implementadas várias vezes, isto é, é possível escrever [public class DerivedClass extends BaseClass implements I1, I2, ..., In], em que as Ij são interfaces: uma classe herda de uma única classe, mas pode implementar quantas interfaces quiser. Uma interface pode, ela própria, estender uma ou mais interfaces: [interface I3 extends I1, I2].

4.6.2. Métodos default, estáticos e privados de interfaces

Desde o Java 8, uma interface pode fornecer uma implementação padrão para alguns de seus métodos, declarada com a palavra-chave [default]. Uma classe que implementa a interface pode então usar essa implementação ou fornecer a sua própria. Isso permite, em particular, acrescentar um método a uma interface já publicada sem exigir que todas as classes que a implementam sejam modificadas: foi assim que as coleções do JDK foram ampliadas ao longo das versões. Uma interface também pode conter métodos estáticos (Java 8) e métodos privados (Java 9). O programa [Classes17.java] fornece um exemplo:

// métodos de interface default (Java 8), static (Java 8) e private (Java 9)
void main() {
    IShape[] shapes = { new Square(2), new Circle(1), IShape.unitSquare() };
    for (IShape shape : shapes) {
        IO.println(shape.description());
    }
    // o método default é herdado pela classe Square
    Square square = new Square(3);
    IO.println(square.description());
}

interface IShape {
    // método abstrato: a ser implementado
    double area();

    // método com uma implementação padrão
    default String description() {
        return getClass().getSimpleName() + " with area " + format(area());
    }

    // método estático: é chamado com o nome da interface
    static IShape unitSquare() {
        return new Square(1);
    }

    // método privado: utilizável somente pelos métodos da interface
    private String format(double value) {
        return String.format("%.2f", value);
    }
}

// Square usa a implementação padrão de description
// (classe estática porque a interface cria quadrados: veja Classes10)
static class Square implements IShape {
    private final double side;

    public Square(double side) {
        this.side = side;
    }

    @Override
    public double area() {
        return side * side;
    }
}

// Circle fornece sua própria implementação de description
class Circle implements IShape {
    private final double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    @Override
    public double area() {
        return Math.PI * radius * radius;
    }

    @Override
    public String description() {
        return String.format("Circle with radius %s and area %.2f", radius, area());
    }
}
  • linhas 12 a 30: a interface [IShape]:
    • linha 14: um método abstrato [area], a ser implementado;
    • linhas 17 a 19: um método [description] com implementação padrão. Esse método pode usar os outros métodos da interface ([area], [format]) e os de [Object] ([getClass]);
    • linhas 22 a 24: um método estático, que é chamado com o nome da interface: [IShape.unitSquare()] (linha 3). É um método de fábrica estático;
    • linhas 27 a 29: um método privado, acessível apenas aos métodos da interface. [String.format("%.2f", value)] formata o número com duas casas decimais, seguindo as convenções da localidade do sistema, neste caso a vírgula decimal francesa;
  • linhas 34 a 45: a classe [Square] implementa apenas [area]; ela usa o método [description] por padrão. Ela é declarada como [static] porque o método estático [unitSquare] da interface cria quadrados (veja [Classes10.java]);
  • linhas 48 a 64: a classe [Circle] fornece seu próprio método, [description]. O formato [%s] insere o raio convertido em string por [Double.toString] (“1.0”), e o formato [%.2f] insere a área com duas casas decimais;
  • Linha 9: o método default é herdado pela classe [Square] como qualquer outro método: ele pode ser chamado em uma variável do tipo [Square].

Resultados:

1
2
3
4
5
> java Classes17.java
Square with area 4,00
Circle with radius 1.0 and area 3,14
Square with area 1,00
Square with area 9,00

Uma classe pode implementar duas interfaces, cada uma com um método default de mesma assinatura: o compilador exige então que a classe redefina o método, ainda que seja para chamar uma das duas versões por meio de [I1.super.method()]. Diferentemente de uma classe abstrata, uma interface não tem estado: ela não pode declarar campos de instância, apenas constantes ([static final], implicitamente).

4.7. Classes abstratas

Uma classe abstrata é uma classe que não pode ser instanciada. É preciso criar classes derivadas, que podem ser instanciadas. As classes abstratas permitem fatorar o código de uma hierarquia de classes. Examinemos o exemplo a seguir, que forma a pasta [Users] [User.java]:

public abstract class User {
    // campos
    private final String login;
    private final String password;
    private final String role;

    // construtor
    @SuppressWarnings("this-escape")
    protected User(String login, String password) throws UnknownUserException {
        // armazenamos as informações
        this.login = login;
        this.password = password;
        // identificamos o usuário
        String role = identify();
        // identificado?
        if (role == null) {
            throw new UnknownUserException("[" + login + "," + password + "]");
        }
        this.role = role;
    }

    // toString
    @Override
    public String toString() {
        return "User[" + login + "," + password + "," + role + "]";
    }

    // identificação: retorna o papel do usuário ou null se ele não for reconhecido
    protected abstract String identify();
}
  • linha 1: a classe é declarada abstrata com a palavra-chave [abstract];
  • Linhas 9 a 20: o construtor da classe [User]. Essa classe armazena informações sobre um usuário de uma aplicação web. A aplicação tem vários tipos de usuários autenticados por um nome de usuário e uma senha (linhas 3 e 4). Essas duas informações são verificadas em um diretório (LDAP) para alguns usuários, em um banco de dados para outros, e assim por diante. O construtor é [protected]: destina-se aos construtores das classes derivadas;
  • linhas 11 e 12: as informações de autenticação são armazenadas;
  • linha 14: elas são verificadas por um método [identify]. Como o método de identificação não é conhecido neste nível, ele é declarado abstrato (linha 29) com a palavra-chave [abstract]. Um método abstrato não tem corpo: as classes derivadas fornecerão um. Uma classe que tem um método abstrato deve ela própria ser declarada abstrata. O método [identify] retorna uma string que especifica o papel do usuário (basicamente, o que ele está autorizado a fazer), ou [null] se o usuário não for reconhecido;
  • linhas 16 a 18: se o usuário não for reconhecido, uma exceção é lançada. A exceção [UnknownUserException] é uma exceção verificada (veja adiante): o construtor deve declará-la com a cláusula [throws UnknownUserException] (linha 9);
  • linhas 23 a 26: o método [toString], que identifica uma instância da classe.

Aqui, supomos que o desenvolvedor queira controlar a criação de instâncias da classe [User] e de suas classes derivadas, talvez porque queira garantir que uma exceção de determinado tipo seja lançada se o usuário não for reconhecido. As classes derivadas podem se apoiar nesse construtor. Para isso, devem fornecer o método [identify]. Observe que o construtor aqui chama um método redefinido pelas classes derivadas, embora essas classes ainda não tenham executado seus próprios construtores: o método [identify] não deve, portanto, usar nenhum campo da classe derivada, pois eles ainda não foram inicializados. Essa é uma prática que deve ser usada com cautela, e o compilador a sinaliza quando se compila com a opção [-Xlint:all], que ativa todos os avisos (aqui sem a anotação da linha 8, daí o número de linha 13 na mensagem):

1
2
3
4
5
> javac -Xlint:all -d classes *.java
User.java:13: warning: [this-escape] possible 'this' escape before subclass is fully initialized
        String role = identify();
                              ^
1 warning

O aviso [this-escape] (Java 21) indica que o objeto em construção ([this]) “escapa” do construtor antes de estar totalmente inicializado. Neste caso, isso é intencional e inofensivo, pois os métodos [identify] das classes derivadas não usam nenhum campo. Depois dessa verificação, o aviso é suprimido, apenas para este construtor, com a anotação [@SuppressWarnings("this-escape")] (linha 8). O inicializador de código-fonte (source code launcher, [java Main.java]) não ativa esses avisos: convém compilar regularmente seus programas com [javac -Xlint:all], que foi o que fizemos para todos os programas deste curso.

A classe [UnknownUserException] é a seguinte:

1
2
3
4
5
6
7
8
public class UnknownUserException extends Exception {
    // número de versão da classe (veja as explicações)
    private static final long serialVersionUID = 1L;

    public UnknownUserException(String message) {
        super(message);
    }
}
  • Linha 1: ela deriva da classe [Exception]. É, portanto, uma exceção verificada (checked): o compilador verifica se todo método que pode lançá-la a declara com uma cláusula [throws] e se todo código que chama esse método a captura ou, por sua vez, a declara. Uma exceção derivada de [RuntimeException], como [IllegalArgumentException], não é uma exceção verificada;
  • linha 3: as exceções são objetos “serializáveis” (conversíveis em uma sequência de bytes); o compilador, com a opção [-Xlint:all], exige que uma classe serializável declare um número de versão [serialVersionUID]. Usamos simplesmente o valor 1;
  • Linhas 5 a 7: ela tem apenas um construtor, que recebe uma mensagem de erro como parâmetro. Essa mensagem é repassada à classe pai, que tem o mesmo construtor.

Derivamos agora a classe filha [Administrator] da classe [User]:

public class Administrator extends User {
    // construtor
    public Administrator(String login, String password) throws UnknownUserException {
        super(login, password);
    }

    // identificação
    @Override
    protected String identify() {
        // identificação por LDAP
        // ...
        return "admin";
    }
}
  • linhas 3 a 5: o construtor simplesmente repassa à classe pai os parâmetros que recebe. Ele também declara a exceção que o construtor pai pode lançar;
  • linhas 8 a 13: o método [identify] da classe [Administrator]. Supomos que um administrador seja identificado por um diretório LDAP. Esse método implementa o método abstrato [identify] da classe pai. Ele mantém o nível de acesso [protected] do método que redefine (um método redefinido pode ampliar o acesso, mas não restringi-lo).

As classes [Observer] e [Unknown] também derivam da classe [User]. Elas diferem da classe [Administrator] apenas pelo método [identify]. O método da classe [Observer] supõe que um observador seja identificado por um banco de dados e retorna o papel “observer”:

1
2
3
4
5
6
7
    // identificação
    @Override
    protected String identify() {
        // identificação por meio de um banco de dados
        // ...
        return "observer";
    }

O método da classe [Unknown] retorna a referência [null] para indicar que o usuário não foi reconhecido:

1
2
3
4
5
6
7
    // identificação
    @Override
    protected String identify() {
        // usuário desconhecido
        // ...
        return null;
    }

No fim das contas, os objetos [Administrator], [Observer], e [Unknown] são inicializados pelo mesmo construtor, o da classe pai [User]. Esse construtor usa o método [identify] fornecido por essas classes. Um programa de teste do [Main.java] poderia ser assim:

void main() {
    try {
        IO.println(new Observer("observer", "pwd1"));
        IO.println(new Administrator("admin", "pwd2"));
        IO.println(new Unknown("xx", "yy"));
    } catch (UnknownUserException e) {
        IO.println("Unknown user: " + e.getMessage());
    }
    // User u = new User("x", "y");   // rejeitado: a classe User é abstrata
}

Observe que, nas linhas 3 e 4, o método [User.toString()] é usado pelo método *[println]. Na linha 5, o construtor lança uma exceção [UnknownUserException], que é capturada na linha 6: o objeto não é criado, e nada é exibido por [println]. As três criações de objetos são colocadas em um bloco [try], porque o compilador exige que a exceção verificada seja capturada. A linha 9, se descomentada, é rejeitada pelo compilador ([User is abstract; cannot be instantiated]*): não é possível criar um objeto de uma classe abstrata.

Resultados:

1
2
3
4
> java Main.java
User[observer,pwd1,observer]
User[admin,pwd2,admin]
Unknown user: [xx,yy]

Uma classe abstrata se assemelha a uma interface: ambas declaram métodos que outras classes devem implementar. No entanto, uma classe abstrata pode ter campos, construtores e código comum às suas classes derivadas; em contrapartida, uma classe só pode derivar de uma única classe abstrata, ao passo que pode implementar várias interfaces. Os dois recursos costumam ser combinados: uma interface define o contrato, e uma classe abstrata que a implementa fatora o código comum a várias implementações. É o que fará a aplicação de exemplo deste capítulo.

4.8. Classes, interfaces e métodos genéricos

4.8.1. Classes e métodos genéricos

Suponha que queiramos escrever uma classe [IntPair] que armazene dois inteiros e possa trocá-los: dois campos, [int first] e [int second], e um método, [swap()], que troque seus valores usando uma variável temporária, [int temp]. Se quiséssemos depois um par de strings e, em seguida, um par de pessoas, escreveríamos mais duas classes, [StringPair] e [PersonPair], idênticas à anterior, exceto pelo tipo: [String] ou [Person] no lugar de [int].

As classes, interfaces e métodos genéricos atendem à necessidade de código que difere apenas no tipo de determinados dados. Foram introduzidos com o Java 5 (2004): antes disso, usava-se o tipo [Object], que aceitava qualquer coisa, ao custo de conversões de tipo explícitas e de erros detectados apenas em tempo de execução. Observe que Java não aceita passagem de parâmetros por referência: um método não consegue trocar os valores de duas variáveis do chamador, mas pode trocar dois elementos de um objeto, de um par ou de um array.

O programa [Classes18.java] apresenta uma classe genérica, um método genérico e uma segunda classe genérica:

// classes e métodos genéricos
void main() {
    // — uma classe genérica Pair<T>
    // Integer
    Pair<Integer> pi = new Pair<>(1, 2);
    pi.swap();
    IO.println("pi=" + pi);
    // String
    Pair<String> ps = new Pair<>("s1", "s2");
    ps.swap();
    IO.println("ps=" + ps);
    // Person
    Person p1 = new Person("jean", "clu", 20), p2 = new Person("pauline", "dard", 55);
    Pair<Person> pp = new Pair<>(p1, p2);
    pp.swap();
    IO.println("pp=" + pp);
    // o primeiro elemento é do tipo Person: sem conversão
    Person first = pp.getFirst();
    IO.println("first element: " + first);

    // — um método genérico Generic2.swap<T>
    Integer[] integers = { 1, 2, 3 };
    Generic2.<Integer>swap(integers, 0, 2);
    IO.println("integers=" + Arrays.toString(integers));
    // o compilador deduz T a partir do tipo dos parâmetros reais
    Person[] persons = { p1, p2 };
    Generic2.swap(persons, 0, 1);
    IO.println("persons=" + Arrays.toString(persons));

    // — uma classe genérica com estado: uma pilha de elementos do tipo T
    MyStack<Person> stack = new MyStack<>();
    stack.push(p1);
    stack.push(p2);
    IO.println("The stack contains " + stack.size() + " persons");
    Person top = stack.pop();
    IO.println("Popped person: " + top + ", " + stack.size() + " left");
    // stack.push("x");   // rejeitado: a pilha só aceita objetos Person
}

// uma classe genérica: um par de dois elementos do tipo T
class Pair<T> {
    private T first;
    private T second;

    public Pair(T first, T second) {
        this.first = first;
        this.second = second;
    }

    public T getFirst() {
        return first;
    }

    public T getSecond() {
        return second;
    }

    // os dois elementos são trocados
    public void swap() {
        T temp = first;
        first = second;
        second = temp;
    }

    @Override
    public String toString() {
        return "(" + first + "," + second + ")";
    }
}

// uma classe não genérica com um método genérico
class Generic2 {
    // troca os elementos nº i e j de um array de elementos do tipo T
    public static <T> void swap(T[] array, int i, int j) {
        T temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
}

// uma pilha de elementos do tipo T
class MyStack<T> {
    // os elementos da pilha
    private final List<T> elements = new ArrayList<>();

    // número de elementos
    public int size() {
        return elements.size();
    }

    // adicionando um elemento no topo da pilha
    public void push(T element) {
        elements.add(element);
    }

    // removendo o elemento do topo da pilha
    public T pop() {
        if (elements.isEmpty()) {
            throw new IllegalStateException("empty stack");
        }
        return elements.removeLast();
    }
}

// uma pessoa
record Person(String firstName, String lastName, int age) {
    @Override
    public String toString() {
        return "[" + firstName + ", " + lastName + ", " + age + "]";
    }
}
  • linhas 41 a 69: a classe [Pair] é parametrizada por um tipo denotado *[T], entre sinais de menor e maior após o nome da classe. Você pode dar a ele o nome que quiser; por convenção, é uma letra maiúscula ([T] para tipo, [E] para elemento, [K] e [V] para chave e valor). Esse tipo, [T], é então usado na classe como qualquer outro tipo: nos dois campos, nos parâmetros do construtor, nos resultados dos acessores e na variável temporária [temp]* (linha 60). Diz-se que a classe [Pair] é uma classe genérica;
  • Linha 5: ao usar uma classe genérica parametrizada pelos tipos T1, T2, …, esses tipos devem ser especificados. Aqui, [Pair<Integer>] é um par de objetos [Integer]. Um parâmetro genérico só pode ser um tipo de referência: escrevemos [Pair<Integer>], e não [Pair<int>]. Os inteiros 1 e 2 são convertidos automaticamente em objetos [Integer] (“autoboxing”). À direita, o operador “diamante” [new Pair<>(...)] permite que o compilador infira o tipo [Integer] a partir do da variável. Linhas 9 e 14: o mesmo vale para os tipos [String] e [Person];
  • Linha 18: o método [getFirst] de um [Pair<Person>] retorna um objeto do tipo [Person], sem conversão;
  • linhas 72 a 79: a classe [Generic2] não é genérica, mas seu método estático [swap] é: o parâmetro de tipo [<T>] é declarado antes do tipo de retorno (linha 74). O método troca os elementos i e j de um array de elementos do tipo [T];
  • linha 23: o método [swap] é chamado especificando-se o tipo *[T] entre ***[<>]. Na verdade, o compilador consegue inferir [T] a partir do tipo dos parâmetros reais. Portanto, a notação da linha 27 é válida, e é a que se usa na prática;
  • linhas 82 a 103: uma classe genérica com estado: uma pilha de elementos do tipo [T]. Os elementos são empilhados no topo da pilha e desempilhados do topo. Os elementos são armazenados em uma lista genérica do tipo [List<T>] (linha 84), que por sua vez é parametrizada pelo tipo [T] da pilha. O método [removeLast] (Java 21) obtém e retorna o último elemento da lista. Uma pilha vazia lança uma exceção [IllegalStateException], a exceção definida pelo Java para uma operação solicitada a um objeto que não está no estado esperado;
  • linha 31: uma pilha de pessoas. O compilador garante que ela conterá apenas pessoas: a instrução da linha 37 seria rejeitada. O método [pop] retorna um objeto do tipo [Person], sem conversão;
  • linhas 106–111: Person é um record cujo método [toString] foi redefinido.

Resultados:

1
2
3
4
5
6
7
8
9
> java Classes18.java
pi=(2,1)
ps=(s2,s1)
pp=([pauline, dard, 55],[jean, clu, 20])
first element: [pauline, dard, 55]
integers=[3, 2, 1]
persons=[[pauline, dard, 55], [jean, clu, 20]]
The stack contains 2 persons
Popped person: [pauline, dard, 55], 1 left

4.8.2. Limites de parâmetros genéricos

Na classe [Pair<T>], o compilador não sabe nada sobre o tipo [T]: ele permite chamar, em objetos do tipo [T], apenas os métodos da classe [Object]. Para poder usar outros métodos, restringimos o parâmetro genérico com a palavra-chave [extends]:

Restrição
Significado
[<T extends BaseClass>]
T deve ser a classe especificada ou uma classe derivada
[<T extends Interface>]
T deve implementar a interface especificada (escreve-se [extends], e não [implements])
[<T extends BaseClass & I1 & I2>]
Várias restrições: no máximo uma classe, listada primeiro, seguida de interfaces
[<T extends Comparable<T>>]
Um limite que usa o próprio T: T deve ser comparável a T

Não há restrição que exija que T seja um tipo de referência (ele sempre é) nem que tenha um construtor sem parâmetros: não é possível escrever [new T()] em uma classe genérica (veja o apagamento de tipos adiante). O programa [Classes19.java] usa uma restrição:

// os limites dos parâmetros genéricos
void main() {
    // — T é sempre um tipo de objeto: int é substituído por Integer
    Pair<Integer> pi = new Pair<>(1, 2);
    // Pair<int> pe = new Pair<>(1, 2);   // erro: int é um tipo primitivo
    IO.println("pi=" + pi);

    // — o limite T extends IValue
    // ordenando pares de objetos do tipo RandomValue
    for (int i = 0; i < 5; i++) {
        Pair<RandomValue> pair = new Pair<>(new RandomValue(), new RandomValue());
        IO.print("Before --> " + pair);
        Generic4.order(pair);
        IO.println("   After --> " + pair);
    }
    // ordenando um par de objetos do tipo StringValue
    Pair<StringValue> strings = new Pair<>(new StringValue("xxxxxxxxxxxxxx"), new StringValue("xx"));
    IO.println("Before --> " + strings);
    Generic4.order(strings);
    IO.println("After --> " + strings);
    // Generic4.order(pi);   // erro: Integer não implementa IValue
}

// um par de dois elementos do tipo T
class Pair<T> {
    private T first;
    private T second;

    public Pair(T first, T second) {
        this.first = first;
        this.second = second;
    }

    public T getFirst() {
        return first;
    }

    public T getSecond() {
        return second;
    }

    public void swap() {
        T temp = first;
        first = second;
        second = temp;
    }

    @Override
    public String toString() {
        return "(" + first + "," + second + ")";
    }
}

// o tipo T deve implementar IValue
class Generic4 {
    public static <T extends IValue> void order(Pair<T> pair) {
        // se o 1º elemento for maior que o 2º, os elementos são trocados
        if (pair.getFirst().value() > pair.getSecond().value()) {
            pair.swap();
        }
    }
}

// um objeto com um valor inteiro
interface IValue {
    int value();
}

// um objeto com um valor aleatório
class RandomValue implements IValue {
    // gerador de números aleatórios compartilhado por todas as instâncias
    // (inicializado com uma semente fixa para que os resultados sejam reproduzíveis)
    private static final Random generator = new Random(2026);
    // valor do objeto
    private final int value = generator.nextInt(100);

    @Override
    public int value() {
        return value;
    }

    @Override
    public String toString() {
        return String.valueOf(value);
    }
}

// um objeto cujo valor é o tamanho de uma string
class StringValue implements IValue {
    private final String s;

    public StringValue(String s) {
        this.s = s;
    }

    @Override
    public int value() {
        return s.length();
    }

    @Override
    public String toString() {
        return s;
    }
}
  • linha 5: se você descomentar esta linha, o compilador relata um erro porque o tipo *[int]* é um tipo primitivo;
  • Linhas 55–62: o método genérico [order] exige que o tipo [T] implemente a interface [IValue] (linhas 65–67). Essa interface tem um método chamado [value], usado na linha 58, que retorna o valor do objeto do tipo [T]. Sem o limite, o compilador rejeitaria a chamada a [pair.getFirst().value()]: um tipo [T] qualquer não tem um método [value]. Os dois elementos do par só são trocados se o valor do primeiro for maior que o do segundo: o método [order] ordena os dois elementos em ordem crescente de valor;
  • linhas 70–86: a classe [RandomValue] implementa a interface [IValue]. O valor de uma instância é um número aleatório entre 0 e 99 (linha 75), fornecido por um gerador de números aleatórios da classe [Random] compartilhado por todas as instâncias (linha 73). Esse gerador é inicializado com uma “semente” fixa: ele produz, portanto, sempre a mesma sequência de números, o que torna os resultados reproduzíveis. Se a reprodutibilidade não for necessária, usa-se o gerador criado por [new Random()]; para fins de segurança, usa-se em vez disso a classe [SecureRandom];
  • linhas 89–105: a classe [StringValue] também implementa a interface [IValue]: o valor de uma instância é o comprimento da cadeia de caracteres passada ao construtor;
  • linhas 10–15: pares de objetos do tipo [RandomValue] são ordenados;
  • linhas 17–20: um par de objetos do tipo [StringValue] é ordenado;
  • linha 21: se esta linha for descomentada, o compilador relata que o tipo [Integer] não satisfaz o limite.

Resultados:

1
2
3
4
5
6
7
8
9
> java Classes19.java
pi=(1,2)
Before --> (99,50)   After --> (50,99)
Before --> (97,30)   After --> (30,97)
Before --> (49,38)   After --> (38,49)
Before --> (73,36)   After --> (36,73)
Before --> (34,78)   After --> (34,78)
Before --> (xxxxxxxxxxxxxx,xx)
After --> (xx,xxxxxxxxxxxxxx)

Estes são os erros obtidos ao executar o programa depois de descomentar as linhas 5 e 21:

> java Classes19.java
Classes19.java:5: error: unexpected type
    Pair<int> pe = new Pair<>(1, 2);   // error: int is a primitive type
         ^
  required: reference
  found:    int
Classes19.java:21: error: method order in class Classes19.Generic4 cannot be applied to given types;
    Generic4.order(pi);   // error: Integer does not implement IValue
            ^
  required: Classes19.Pair<T>
  found:    Classes19.Pair<Integer>
  reason: inference variable T has incompatible bounds
    equality constraints: Integer
    upper bounds: IValue
  where T is a type-variable:
    T extends IValue declared in method <T>order(Classes19.Pair<T>)
2 errors
error: compilation failed

A segunda mensagem é típica de erros envolvendo genéricos: o compilador tentou inferir o tipo [T]; a restrição do par exige que [T] = [Integer] (“restrições de igualdade”), a restrição do limite exige que [T] implemente [IValue] (“limites superiores”); as duas restrições são incompatíveis.

4.8.3. Interfaces genéricas: Comparable<T> e Comparator<T>

Para ilustrar o conceito de interface genérica, vamos ordenar um array de pessoas segundo diferentes critérios. O método que permite ordenar um array é o método estático [sort] da classe [java.util.Arrays]. Ele é sobrecarregado; usaremos duas variantes:

  • [Arrays.sort(Object[] array)] ordena o array segundo a ordem natural de seus elementos: esses elementos devem implementar a interface [Comparable<T>], cujo único método, [int compareTo(T other)], compara o objeto atual com o objeto [other];
  • [Arrays.sort(T[] array, Comparator<? super T> comparator)] ordena o array segundo a ordem definida por um objeto comparador, que implementa a interface [Comparator<T>], cujo método [int compare(T x, T y)] compara dois objetos (o tipo [? super T] é explicado no parágrafo seguinte).

Os métodos [compareTo] e [compare] seguem a mesma regra: retornam um número positivo se x > y, 0 se x == y e um número negativo se x < y. Cabe ao desenvolvedor definir o significado dos operadores <, == e >. Por exemplo, se [p1] e [p2] são dois objetos [Person], podemos dizer que p1 > p2 se o nome de [p1] vem depois do nome de [p2] em ordem alfabética. Isso resultará em uma ordenação crescente pelos nomes das pessoas. Se quisermos ordenar por idade, diremos que p1 > p2 se a idade de [p1] for maior que a idade de [p2]. Para ordenar em ordem decrescente, basta inverter os sinais dos resultados.

Já sabemos o suficiente para ordenar uma tabela de pessoas. O programa [Classes20.java] é o seguinte:

// as interfaces genéricas Comparable<T> e Comparator<T>: ordenando um array de pessoas
void main() {
    Person[] persons = {
        new Person("claude", "pollon", 25),
        new Person("valentine", "germain", 35),
        new Person("paul", "germain", 32),
    };
    // exibição
    display("Array to sort", persons);
    // ordenação segundo a ordem natural das pessoas (Comparable): a idade
    Arrays.sort(persons);
    display("Array after sorting by age", persons);
    // ordenação por sobrenome e nome próprio (Comparator)
    Arrays.sort(persons, new CompareNames());
    display("Array after sorting by last and first names", persons);
    // ordenação por idade decrescente, com uma classe anônima
    Arrays.sort(persons, new Comparator<Person>() {
        @Override
        public int compare(Person p1, Person p2) {
            return Integer.compare(p2.getAge(), p1.getAge());
        }
    });
    display("Array after sorting by descending age", persons);
}

// exibição de um array de pessoas
void display(String text, Person[] persons) {
    IO.println(text + "-".repeat(50 - text.length()));
    for (Person p : persons) {
        IO.println(p);
    }
}

// uma pessoa, comparável a outra pessoa
class Person implements Comparable<Person> {
    private final String firstName;
    private final String lastName;
    private final int age;

    public Person(String firstName, String lastName, int age) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }

    public String getFirstName() {
        return firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public int getAge() {
        return age;
    }

    // a ordem natural das pessoas: a ordem das idades
    @Override
    public int compareTo(Person other) {
        return Integer.compare(age, other.age);
    }

    @Override
    public String toString() {
        return "[" + firstName + ", " + lastName + ", " + age + "]";
    }
}

// comparação dos sobrenomes e nomes próprios de duas pessoas
class CompareNames implements Comparator<Person> {
    // comparação de strings segundo as regras da língua francesa
    private final Collator collator = Collator.getInstance(Locale.FRENCH);

    @Override
    public int compare(Person p1, Person p2) {
        // comparamos os sobrenomes
        int i = collator.compare(p1.getLastName(), p2.getLastName());
        if (i != 0) {
            return i;
        }
        // sobrenomes iguais: comparamos os nomes próprios
        return collator.compare(p1.getFirstName(), p2.getFirstName());
    }
}
  • linhas 3–7: o array de pessoas;
  • linhas 35–68: a classe [Person] implementa a interface genérica [Comparable<Person>]: seus objetos são comparáveis a outras pessoas. Seu método [compareTo] (linhas 59–62) define a ordem natural das pessoas, neste caso por idade. O método estático [Integer.compare(a, b)] retorna um número negativo, zero ou positivo conforme [a] seja menor que, igual a ou maior que [b]: é exatamente o que o método [compareTo] espera;
  • linha 11: ordenação em ordem natural;
  • linha 14: ordena o array de pessoas por sobrenome e nome. O segundo parâmetro do método [sort] é uma instância da classe [CompareNames], que implementa a interface genérica [Comparator<Person>];
  • linhas 71–85: a classe [CompareNames]. Seu método [compare] implementa o método [int compare(T x, T y)] da interface [Comparator<T>], em que [T] = [Person]. As cadeias não são comparadas por meio de seu método [compareTo], que segue a ordem dos códigos de caracteres (maiúsculas antes de minúsculas, letras acentuadas depois do “z”), mas sim por um objeto [Collator] (linha 73) que aplica as regras de ordenação da língua francesa;
  • linhas 17–22: ordenação por idade em ordem decrescente. Desta vez o comparador é uma instância de uma classe anônima: a expressão [new Comparator<Person>() { ... }] declara uma classe sem nome que implementa a interface [Comparator<Person>] e cria imediatamente uma instância dessa classe. O corpo da classe (linhas 18–21) fornece o método [compare]. Uma classe anônima evita ter de declarar uma classe usada uma única vez;
  • linha 28: o método [repeat] (Java 11) preenche uma cadeia: a linha de título é preenchida com traços até 50 caracteres.

Resultados:

> java Classes20.java
Array to sort-------------------------------------
[claude, pollon, 25]
[valentine, germain, 35]
[paul, germain, 32]
Array after sorting by age------------------------
[claude, pollon, 25]
[paul, germain, 32]
[valentine, germain, 35]
Array after sorting by last and first names-------
[paul, germain, 32]
[valentine, germain, 35]
[claude, pollon, 25]
Array after sorting by descending age-------------
[valentine, germain, 35]
[paul, germain, 32]
[claude, pollon, 25]

Já encontramos três tipos de classes declaradas dentro de outra: classes aninhadas estáticas ([static class]), classes internas (sem [static], que são associadas a um objeto da classe externa) e classes anônimas. No Capítulo 7, veremos que, para uma interface com apenas um método abstrato, como [Comparator], podemos usar uma alternativa ainda mais curta que uma classe anônima: uma lambda, [Arrays.sort(persons, (p1, p2) -> Integer.compare(p2.getAge(), p1.getAge()));], ou uma referência a método, [Arrays.sort(persons, Comparator.comparing(Person::getLastName));].

4.8.4. Curingas e apagamento de tipos

Uma [List<Integer>] não é uma [List<Number>], embora [Integer] derive de [Number]: se fosse, poderíamos adicionar um [Double] a uma lista de inteiros por meio de uma variável do tipo [List<Number>]. Um método que aceita uma [List<Number>] rejeita, portanto, uma [List<Integer>]. Para escrever métodos que aceitam listas de elementos de tipos relacionados, Java usa curingas (wildcards):

Tipo
Significado
Uso
[List<? extends Number>]
uma lista de elementos de um tipo desconhecido derivado de [Number]
É possível ler [Number] dela, mas não adicionar elementos a ela
[List<? super Integer>]
Uma lista de itens de um tipo desconhecido do qual [Integer] deriva ([Integer], [Number], [Object])
[Integer] pode ser adicionado a esta lista
[List<?>]
uma lista de itens de um tipo desconhecido
É possível ler [Object]

O programa [Classes21.java] ilustra os curingas e uma particularidade dos genéricos de Java: o apagamento de tipos:

// curingas, limites e apagamento de tipos
void main() {
    List<Integer> integers = List.of(1, 2, 3);
    List<Double> reals = List.of(1.5, 2.25);
    // ? extends Number: uma lista de elementos de um tipo derivado de Number
    IO.println("Sum of integers: " + sum(integers));
    IO.println("Sum of reals: " + sum(reals));
    // ? super Integer: uma lista que pode receber Integers
    List<Number> numbers = new ArrayList<>();
    addIntegers(numbers, 3);
    numbers.add(2.5);
    IO.println("numbers=" + numbers + ", sum=" + sum(numbers));
    // um limite recursivo: T deve ser comparável a si mesmo
    IO.println("max : " + max(List.of("paul", "jean", "valentine")) + ", " + max(integers));
    // apagamento de tipos (type erasure): em tempo de execução, uma lista é uma lista
    List<String> l1 = new ArrayList<>();
    List<Integer> l2 = new ArrayList<>();
    IO.println("same class: " + (l1.getClass() == l2.getClass()) + " (" + l1.getClass().getName() + ")");
}

// soma dos elementos de uma lista de números
double sum(List<? extends Number> values) {
    double sum = 0;
    for (Number value : values) {
        sum += value.doubleValue();
    }
    // values.add(1);   // rejeitado: o tipo exato dos elementos é desconhecido
    return sum;
}

// adicionando os inteiros 1, 2, ..., n a uma lista capaz de receber Integers
void addIntegers(List<? super Integer> list, int n) {
    for (int i = 1; i <= n; i++) {
        list.add(i);
    }
}

// o maior elemento de uma lista não vazia
<T extends Comparable<? super T>> T max(List<T> elements) {
    T max = elements.getFirst();
    for (T element : elements) {
        if (element.compareTo(max) > 0) {
            max = element;
        }
    }
    return max;
}
  • Linhas 22–29: o método [sum] aceita uma lista de elementos de qualquer tipo derivado de [Number]: [Integer], [Double], [BigDecimal]… Ele trata os elementos como [Number] e usa seu método [doubleValue]. Java não suporta aritmética genérica: não é possível escrever [a + b] para dois objetos do tipo [T], daí a necessidade de usar [double]. Adicionar um elemento à lista (linha 27) é rejeitado: o compilador não sabe se é uma lista de [Integer] ou de [Double];
  • linhas 6–7: o mesmo método concatena uma lista de [Integer] com uma lista de [Double]. [List.of(...)] cria uma lista somente leitura;
  • linhas 32–36: o método [addIntegers] aceita qualquer lista capaz de conter entradas [Integer], neste caso uma [List<Number>] (linha 10). Seguimos a regra “produtor: [extends], consumidor: [super]”: uma lista cujos elementos são lidos é declarada com [extends], e uma lista que é preenchida é declarada com [super];
  • Linhas 39–47: o método genérico *[max] retorna o maior elemento de uma lista. O limite [T extends Comparable<? super T>] exige que os elementos sejam comparáveis entre si; ele se aplica tanto a cadeias quanto a inteiros (linha 14). O método [getFirst]* (Java 21) retorna o primeiro elemento da lista;
  • linhas 16–18: em tempo de execução, uma ***[List<String>] e uma ***[List<Integer>] são dois objetos da mesma classe, *[ArrayList]*. O compilador verifica os tipos genéricos e depois os apaga: o código compilado só reconhece [ArrayList] e [Object], e conversões são inseridas onde necessário. Esse “apagamento de tipos”, adotado em 2004 para garantir que o código genérico permaneça compatível com o código existente, explica várias limitações: não é possível escrever [new T()] ou [new T[10]], nem testar [o instanceof List<String>], nem usar um tipo primitivo como parâmetro genérico.

Resultados:

1
2
3
4
5
6
> java Classes21.java
Sum of integers: 6.0
Sum of reals: 3.75
numbers=[1, 2, 3, 2.5], sum=8.5
max : valentine, 3
same class: true (java.util.ArrayList)

Ao contrário de outras linguagens como C#, em que as interfaces podem declarar membros estáticos abstratos para implementar cálculos genéricos, Java não permite exigir que um tipo como [T] tenha um método estático: os métodos estáticos de uma interface são chamados pelo nome da interface e não são herdados pelas classes que a implementam.

4.9. Pacotes

Para escrever uma linha na tela, usamos a instrução [IO.println(...)]. Se consultarmos a definição da classe [IO] na documentação do JDK, veremos que ela faz parte do pacote [java.lang] . Isso significa que seu nome completo é [java.lang.IO] e que poderíamos escrever [java.lang.IO.println(...)]. As classes do pacote [java.lang] ([String], [Object], [Math], [Integer]…) são sempre referenciadas por seus nomes simples. Para as demais, usa-se uma cláusula [import], colocada no início do arquivo:

  • [import java.util.List;] importa a classe [List] do pacote [java.util];
  • [import java.util.*;] importa sob demanda todas as classes públicas do pacote [java.util];
  • [import module java.base;] (Java 25) importa todas as classes públicas dos pacotes exportados pelo módulo [java.base] (veja adiante). É isso que um arquivo compacto faz implicitamente;
  • [import static java.lang.Math.sqrt;] importa um membro estático de uma classe, que pode então ser usado sem especificar o nome da classe: [sqrt(2)].

Quando o compilador encontra o nome curto de uma classe, ele a procura no pacote atual e entre as classes importadas. Uma cláusula [import] não acrescenta nada ao programa: apenas evita ter de escrever os nomes completos.

Ao criar uma classe, você a coloca em um pacote. A finalidade dos pacotes é evitar conflitos de nomes entre classes, por exemplo, quando elas são distribuídas. Considere duas empresas, E1 e E2, que distribuem classes empacotadas nos arquivos [e1.jar] e [e2.jar], respectivamente. Suponha que um cliente C compre esses dois conjuntos de classes, nos quais ambas as empresas definiram uma classe chamada [Person]. Se a empresa E1 criar suas classes em um pacote chamado [e1] e a empresa E2 criar suas classes em um pacote chamado [e2], as duas classes [Person] passarão a se chamar [e1.Person] e [e2.Person]. O cliente pode importar uma delas e referir-se à outra pelo nome completo. O pacote resolve essa ambiguidade. Por convenção, os nomes de pacotes são escritos em minúsculas e começam com o nome de domínio invertido da organização que os publica ([com.mysql.cj.jdbc], [org.hibernate]…); em nossos exemplos, usaremos nomes curtos.

Para colocar uma classe em um pacote, escreve-se a declaração [package name;] no início de seu arquivo. Ao contrário de outras linguagens, Java exige uma correspondência biunívoca entre pacotes e diretórios: os arquivos-fonte do pacote [e1] ficam armazenados em uma pasta chamada [e1], e os do pacote [tax.dao] ficam armazenados em uma pasta chamada [tax/dao], a partir da raiz do diretório de código-fonte. A pasta [Namespaces] ilustra esses conceitos:

1
2
3
4
5
6
Namespaces/
  Main.java             the main program (unnamed package)
  e1/
    Person.java         the class e1.Person
  e2/
    Person.java         the class e2.Person

A primeira classe, [Person] [e1/Person.java]:

// as classes deste arquivo pertencem ao pacote e1
package e1;

public class Person {
    private final String firstName;
    private final String lastName;

    public Person(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }

    @Override
    public String toString() {
        return "e1.Person[" + firstName + ", " + lastName + "]";
    }
}

A segunda: [e2/Person.java]:

// as classes deste arquivo pertencem ao pacote e2
package e2;

public class Person {
    private final String name;

    public Person(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    @Override
    public String toString() {
        return "e2.Person[" + name + "]";
    }
}

Ambas as classes são públicas: uma classe sem a palavra-chave [public] é acessível apenas às classes de seu próprio pacote. O programa principal [Main.java] é o seguinte:

// importando uma classe de um pacote
import e1.Person;
// import estático de um membro estático de uma classe
import static java.lang.Math.sqrt;

void main() {
    // Person designa e1.Person, que foi importada
    Person p1 = new Person("Jean", "Dupont");
    // o nome completo de uma classe elimina qualquer ambiguidade
    e2.Person p2 = new e2.Person("Durand");
    IO.println(p1 + " " + p2);
    // nome completo e pacote de uma classe
    IO.println(Person.class.getName() + ", " + e2.Person.class.getName());
    IO.println("package of the Person class: " + Person.class.getPackageName());
    // o módulo que contém uma classe
    IO.println("e1.Person is in a named module: " + Person.class.getModule().isNamed());
    IO.println(String.class.getName() + " is in the module " + String.class.getModule().getName());
    // StringBuilder é conhecida graças ao import automático do módulo java.base
    StringBuilder sb = new StringBuilder("abc");
    IO.println(sb.append("def"));
    // sqrt é conhecido graças ao import estático
    IO.println("sqrt(2)=" + sqrt(2));
}
  • linha 2: importação da classe [e1.Person];
  • linha 4: importação estática do método [sqrt] da classe [Math];
  • Linha 8: [Person] refere-se à classe [e1.Person], que foi importada;
  • Linha 10: o nome completo da classe [e2.Person] elimina qualquer ambiguidade. Java não suporta aliases de tipo: não é possível dar a uma classe um nome diferente;
  • Linhas 13–14: o método [getName] da descrição da classe retorna seu nome completo, prefixado por seu pacote; [getPackageName] retorna o nome do pacote;
  • linhas 16–17: o método [getModule] retorna o módulo que contém a classe (veja adiante);
  • linhas 19–20: a classe [java.lang.StringBuilder] é reconhecida sem importação;
  • linha 22: uso da importação estática.

O iniciador de código-fonte (source code launcher) encontra automaticamente as classes nas subpastas: o comando [java Main.java], digitado na pasta [Namespaces], compila sob demanda os arquivos [e1/Person.java] e [e2/Person.java] . Resultados:

1
2
3
4
5
6
7
8
> java Main.java
e1.Person[Jean, Dupont] e2.Person[Durand]
e1.Person, e2.Person
package of the Person class: e1
e1.Person is in a named module: false
java.lang.String is in the module java.base
abcdef
sqrt(2)=1.4142135623730951

Se substituirmos a importação da linha 2 pelas duas importações sob demanda [import e1.*;] e [import e2.*;], o nome [Person] se torna ambíguo e o compilador o rejeita:

1
2
3
4
5
6
> java Main.java
Main.java:9: error: reference to Person is ambiguous
    Person p1 = new Person("Jean", "Dupont");
    ^
  both class e2.Person in e2 and class e1.Person in e1 match
...

4.9.1. Módulos

A partir do Java 9, os pacotes são agrupados em módulos (“Java Platform Module System”, JPMS). O JDK é dividido em módulos: [java.base] contém os pacotes essenciais ([java.lang], [java.util], [java.math], [java.io]…), [java.sql] fornece acesso a bancos de dados, [java.net.http] é o cliente HTTP, etc. Um módulo declara, em um arquivo chamado [module-info.java] localizado na raiz de seu código-fonte, seu nome, os módulos de que precisa ([requires java.sql;]) e os pacotes que disponibiliza para outros módulos ([exports tax.business;]): um pacote não exportado é invisível do lado de fora, mesmo para suas classes públicas. As classes de uma aplicação que não declara um módulo, como a nossa, pertencem ao módulo sem nome (linha 5 dos resultados), que tem acesso a todos os módulos. É o caso da maioria das aplicações e de todas as deste curso: os módulos interessam principalmente aos autores de bibliotecas e ao próprio módulo do JDK.

4.10. Records

Muitas classes servem apenas para transportar dados: uma pessoa, uma nota, uma faixa de imposto… Para elas, sempre escrevemos o mesmo código: campos privados e [final], um construtor que copia seus parâmetros para os campos, acessores, um [toString] método que exibe os campos, e os métodos [equals] e [hashCode]. O Java 16 introduziu os records: o compilador gera esse código a partir de uma declaração de uma única linha. Nós os encontramos na seção sobre objetos imutáveis; o programa [Classes22.java] os demonstra de forma mais completa:

// records (Java 16)
void main() {
    Person r1 = new Person("Jean", "Dupont", 30);
    Person r2 = new Person("Jean", "Dupont", 30);
    // toString gerado pelo compilador
    IO.println(r1);
    // os acessores têm o nome dos componentes
    IO.println("first name=" + r1.firstName() + ", identity=" + r1.identity());
    // igualdade por valor: r1 e r2 são dois objetos diferentes, mas iguais
    IO.println("r1.equals(r2) : " + r1.equals(r2) + ", r1 == r2 : " + (r1 == r2));
    // os componentes são somente leitura
    // r1.age = 31;   // rejeitado: o campo age é final
    // uma cópia modificada, com um método "wither"
    Person r3 = r1.withAge(31);
    IO.println(r3);
    IO.println("r1.equals(r3) : " + r1.equals(r3));
    // desconstrução em variáveis com um record pattern (Java 21)
    if (r1 instanceof Person(String firstName, String lastName, int age)) {
        IO.println("first name=" + firstName + ", last name=" + lastName + ", age=" + age);
    }

    // a mesma coisa com uma classe
    PersonC c1 = new PersonC("Jean", "Dupont", 30);
    PersonC c2 = new PersonC("Jean", "Dupont", 30);
    IO.println(c1);
    IO.println("c1.equals(c2) : " + c1.equals(c2));

    // dois records que implementam a mesma interface
    Teacher e = new Teacher("Lucile", "Dumas", 56, 61);
    IO.println(e);
    IO.println(e.identity());
    // a igualdade leva o tipo em conta: uma Person não é igual a um Teacher
    Person pe = new Person("Lucile", "Dumas", 56);
    IO.println("pe.equals(e) : " + pe.equals(e));
    // o tipo comum: a interface HasIdentity
    HasIdentity[] identities = { pe, e };
    for (HasIdentity i : identities) {
        IO.println(i.identity());
    }
}

// uma interface implementada pelos records
interface HasIdentity {
    String identity();
}

// um record: firstName, lastName, age são seus componentes
record Person(String firstName, String lastName, int age) implements HasIdentity {
    // métodos podem ser adicionados
    @Override
    public String identity() {
        return "[" + firstName + ", " + lastName + ", " + age + "]";
    }

    // um método "wither": uma cópia em que um componente mudou
    public Person withAge(int age) {
        return new Person(firstName, lastName, age);
    }
}

// um record não pode derivar de outro record
record Teacher(String firstName, String lastName, int age, int section) implements HasIdentity {
    @Override
    public String identity() {
        return "Teacher[[" + firstName + ", " + lastName + ", " + age + "]," + section + "]";
    }
}

// uma classe equivalente... ou quase
final class PersonC {
    private final String firstName;
    private final String lastName;
    private final int age;

    public PersonC(String firstName, String lastName, int age) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }

    public String firstName() {
        return firstName;
    }

    public String lastName() {
        return lastName;
    }

    public int age() {
        return age;
    }
}
  • linhas 48–59: o record [Person]. A declaração [record Person(String firstName, String lastName, int age)] gera:
    • três campos privados e [final] — [firstName], [lastName] e [age] — que são os componentes do record;
    • um construtor de três parâmetros, chamado construtor canônico;
    • três acessores públicos: [firstName()], [lastName()] e [age()] (linha 8);
    • um método [toString] que exibe o nome do tipo e seus componentes (linha 6);
    • os métodos [equals] e [hashCode], que comparam os valores dos componentes em vez das referências;
  • linhas 51–53 e 56–58: um record, assim como uma classe, pode ter métodos adicionais e implementar interfaces (linha 48);
  • linha 10: [r1] e [r2] são dois objetos distintos ([==] é o mesmo que [false]), mas são iguais segundo [equals] porque seus componentes têm os mesmos valores. Para uma classe comum, [equals] compara referências (linha 26);
  • linha 14: como um record é imutável, ele não pode ser modificado (linha 12): o método “wither” [withAge] cria uma cópia de [r1] cuja idade foi alterada;
  • linhas 18–20: um padrão de record (Java 21): se [r1] for um [Person], seus componentes são extraídos para as variáveis [firstName], [lastName], e [age]. Isso é chamado de decomposição de record. Voltaremos a encontrar esses padrões ao filtrar por padrão;
  • linhas 62–67: um record é implicitamente final e deriva implicitamente da classe [java.lang.Record]; ele não pode derivar de outra classe ou record, nem pode ser derivado. Para dar aos records [Person] e [Teacher] um tipo comum, fazemos com que implementem a mesma interface, neste caso [HasIdentity] (linhas 43–45). O record [Teacher] contém, portanto, os componentes da pessoa;
  • linha 34: a igualdade de records leva em conta o tipo real dos objetos: um [Person] nunca é igual a um [Teacher], mesmo que seus componentes em comum sejam iguais;
  • linhas 36–39: a interface comum permite tratar os dois records de forma polimórfica;
  • linhas 70–92: uma classe que se assemelha ao record [Person] … exceto que os campos, o construtor e os acessores tiveram de ser escritos, e a igualdade por valor e o [toString] não são fornecidos.

Resultados:

> java Classes22.java
Person[firstName=Jean, lastName=Dupont, age=30]
first name=Jean, identity=[Jean, Dupont, 30]
r1.equals(r2) : true, r1 == r2 : false
Person[firstName=Jean, lastName=Dupont, age=31]
r1.equals(r3) : false
first name=Jean, last name=Dupont, age=30
Classes22$PersonC@206a70ef
c1.equals(c2) : false
Teacher[firstName=Lucile, lastName=Dumas, age=56, section=61]
Teacher[[Lucile, Dumas, 56],61]
pe.equals(e) : false
[Lucile, Dumas, 56]
Teacher[[Lucile, Dumas, 56],61]

Observe que o método [toString] da classe [PersonC] é o mesmo da classe [Object] (linha 8 dos resultados) e que a igualdade dos dois objetos [PersonC] é falsa (linha 9).

Vamos resumir as diferenças entre uma classe e um record:

 
Classe
Record
Igualdade entre [equals]
mesmo objeto (a menos que seja redefinido)
mesmos valores dos componentes, mesmo tipo
[toString]
nome da classe e código hash
nome do record e componentes
campos, construtor, acessores
a serem escritos
gerados pela declaração
estado
modificável ou não
imutável (campos [final]), sem outros campos de instância
cópia modificada
a ser escrita
a ser escrita (usando métodos "wither")
herança
de uma classe, de várias interfaces
de nenhuma classe, de várias interfaces; um record é sempre final

Um record é usado para dados definidos por seu valor (uma pessoa recuperada de um banco de dados, uma mensagem trocada por uma rede, uma faixa de imposto), e uma classe é usada para um objeto com identidade e comportamento (um serviço de computação, uma conexão, uma lista mutável). Observação: um record é imutável de forma “superficial”: se um componente referencia um objeto mutável, como uma lista, o conteúdo dessa lista continua mutável. Nesses casos, usam-se listas imutáveis ([List.copyOf]).

4.11. Construtores de records

O construtor canônico de um record simplesmente copia seus parâmetros para os campos. No entanto, você pode querer validar ou normalizar esses parâmetros. Java oferece o construtor compacto para essa finalidade, além da possibilidade de adicionar outros construtores. O programa [Classes23.java] ilustra isso:

// construtores de record: construtor compacto, outros construtores
void main() {
    Person p = new Person("  Jean ", "Dupont", 30);
    IO.println(p.identity());
    // um record é imutável: growOlder retorna uma nova pessoa
    Person p2 = p.growOlder();
    IO.println(p.identity() + " -> " + p2.identity());
    // outro construtor
    Person unknown = new Person("Martin");
    IO.println(unknown.identity());
    // as verificações do construtor compacto
    try {
        new Person("Paul", " ", 20);
    } catch (IllegalArgumentException ex) {
        IO.println(ex.getMessage());
    }
    try {
        new Person("Paul", "Martin", -4);
    } catch (IllegalArgumentException ex) {
        IO.println(ex.getMessage());
    }
    // um record com um método e uma fábrica estática
    Point pt = new Point(3, 4);
    IO.println("pt=" + pt + ", distance to the origin: " + pt.distance() + ", origin=" + Point.origin());
}

record Person(String firstName, String lastName, int age) {
    // construtor compacto: ele verifica e normaliza os parâmetros,
    // os campos são então inicializados automaticamente
    Person {
        firstName = check(firstName, "first name");
        lastName = check(lastName, "last name");
        if (age < 0) {
            throw new IllegalArgumentException("age (" + age + ") invalid");
        }
    }

    // qualquer outro construtor deve chamar o construtor canônico
    Person(String lastName) {
        this("?", lastName, 0);
    }

    // um método que retorna uma nova pessoa
    public Person growOlder() {
        return new Person(firstName, lastName, age + 1);
    }

    public String identity() {
        return "[" + firstName + ", " + lastName + ", " + age + "]";
    }

    // um método estático de verificação
    private static String check(String value, String label) {
        if (value == null || value.isBlank()) {
            throw new IllegalArgumentException(label + " (" + value + ") invalid");
        }
        return value.strip();
    }
}

record Point(double x, double y) {
    // um campo estático é permitido, um campo de instância não
    private static final Point ORIGIN = new Point(0, 0);

    public static Point origin() {
        return ORIGIN;
    }

    public double distance() {
        return Math.sqrt(x * x + y * y);
    }
}
  • Linhas 30–36: o construtor compacto. Ele é escrito sem lista de parâmetros; seus parâmetros são implicitamente os do construtor canônico ([firstName], [lastName], [age]). Seu código é executado primeiro; depois, os campos são inicializados automaticamente com os valores (que podem ter sido modificados) dos parâmetros. Aqui, o nome e o sobrenome são validados e têm os espaços iniciais e finais removidos (linhas 31–32), e uma idade negativa é rejeitada (linhas 33–35). Em um construtor compacto, não é possível atribuir valores aos campos ([this.firstName = ...] é rejeitado): você modifica os parâmetros;
  • linhas 39–41: um record pode ter outros construtores, mas eles devem chamar o construtor canônico com [this(...)]: toda criação de um [Person] passa, assim, pelas validações do construtor compacto;
  • linhas 44–46: um record é imutável; envelhecê-lo significa criar uma nova instância;
  • linhas 53–58: um método estático privado de validação;
  • linhas 61–72: um record pode ter campos estáticos (linha 63) e métodos estáticos (linhas 65–67), como a fábrica estática [origin], mas nenhum campo de instância além de seus componentes.

Resultados:

1
2
3
4
5
6
7
> java Classes23.java
[Jean, Dupont, 30]
[Jean, Dupont, 30] -> [Jean, Dupont, 31]
[?, Martin, 0]
last name ( ) invalid
age (-4) invalid
pt=Point[x=3.0, y=4.0], distance to the origin: 5.0, origin=Point[x=0.0, y=0.0]

O nome, fornecido cercado por espaços (linha 3), foi armazenado sem eles (linha 2 dos resultados). O construtor compacto é a maneira idiomática de garantir que um record seja sempre válido: não há como criar um [Person] sem usá-lo.

4.12. Sem métodos de extensão: métodos utilitários estáticos

Como adicionar um método a uma classe que não pode ser modificada, como a classe [String] do JDK? Algumas linguagens, como C# ou Kotlin, oferecem “métodos de extensão”: métodos estáticos que são usados como métodos de instância do tipo estendido. Java não os tem. Em vez disso, escrevemos métodos estáticos, agrupados em uma classe utilitária, e os chamamos pelo nome de sua classe, passando o objeto como parâmetro. O JDK está cheio deles: [Arrays], [Collections], [Objects], [Math]… O programa [Classes24.java] ilustra isso:

// sem métodos de extensão em Java: métodos utilitários estáticos
import static java.lang.Character.toUpperCase;

void main() {
    Person p = new Person("jean", "dupont", 30);
    // os métodos utilitários são chamados com o nome de sua classe
    IO.println(Tools.initials(p));
    IO.println(Tools.firstUpper("jean"));
    IO.println(Tools.fullName(p) + " is an adult: " + Tools.isAdult(p));
    IO.println("\"it is sunny\" has " + Tools.nbWords("it is sunny") + " words");
    // um método estático do próprio record
    Person unknown = Person.unknown();
    IO.println(Tools.fullName(unknown) + " is an adult: " + Tools.isAdult(unknown));
}

// uma pessoa
record Person(String firstName, String lastName, int age) {
    // fábrica estática: uma pessoa desconhecida
    static Person unknown() {
        return new Person("?", "?", 0);
    }
}

// uma classe utilitária: final, construtor privado, métodos estáticos
final class Tools {
    private Tools() {
    }

    static String initials(Person p) {
        return toUpperCase(p.firstName().charAt(0)) + "." + toUpperCase(p.lastName().charAt(0)) + ".";
    }

    static String firstUpper(String s) {
        return s.isEmpty() ? s : toUpperCase(s.charAt(0)) + s.substring(1);
    }

    static boolean isAdult(Person p) {
        return p.age() >= 18;
    }

    static String fullName(Person p) {
        return firstUpper(p.firstName()) + " " + p.lastName().toUpperCase();
    }

    static int nbWords(String s) {
        return s.isBlank() ? 0 : s.strip().split("\\s+").length;
    }
}
  • linhas 25–48: a classe utilitária [Tools]. Ela é final e seu único construtor é privado (linhas 26–27): ela não pode ser derivada nem instanciada. Todos os seus métodos são estáticos;
  • linhas 29–31: o método [initials] recebe a pessoa como parâmetro. Como uma classe utilitária escrita em outro arquivo, ele usa apenas os membros públicos do record [Person], neste caso seus acessores (em um arquivo compacto, porém, teria acesso a campos privados); [charAt(0)] retorna o primeiro caractere de uma cadeia;
  • linha 2: a importação estática do método [Character.toUpperCase], que converte um caractere em maiúscula, permite chamá-lo sem o nome de sua classe (linhas 30 e 34);
  • linhas 45–47: o método [nbWords] divide a cadeia usando o método [split], cujo parâmetro é uma expressão regular: ["\\s+"] corresponde a uma sequência de um ou mais caracteres de espaço em branco;
  • linhas 7–10: os métodos utilitários são chamados pelo nome da classe: [Tools.initials(p)], e não [p.initials()];
  • linhas 19–21: quando o tipo pode ser modificado, seus métodos são naturalmente colocados nele: a fábrica estática [unknown] é um método do record [Person] (linha 12).

Resultados:

1
2
3
4
5
6
> java Classes24.java
J.D.
Jean
Jean DUPONT is an adult: true
"it is sunny" has 3 words
? ? is an adult: false

Com uma importação estática ([import static tools.Tools.*;] se a classe estivesse em um pacote chamado [tools]), poderíamos escrever [initials(p)] sem o nome da classe. Para que um método utilitário seja utilizável, sua classe deve ser acessível e, se estiver em outro pacote, importada.

4.13. Correspondência de padrões em objetos

A instrução [switch] e a correspondência de padrões (pattern matching) não se limitam a valores simples (números, cadeias); também se aplicam a objetos. É possível testar o tipo de um objeto, desconstruir um record, adicionar uma condição e obter o objeto convertido para o tipo correto, tudo em uma única expressão. O programa [Classes25.java] usa uma interface selada e três records que a implementam:

// pattern matching em objetos
void main() {
    Object[] objects = {
        new Individual("Jean", "Dupont", 30),
        new Individual("Lise", "Morel", 12),
        new Teacher("Lucile", "Dumas", 56, 61),
        new Teacher("Marc", "Petit", 44, 27),
        new Student("Paul", "Martin", 19, "computer science"),
        "a string",
        42,
        null,
    };

    // 1 - o type pattern: instanceof Type variável (Java 16)
    for (Object o : objects) {
        if (o instanceof Person p) {
            // aqui p é uma Person
            IO.println(p.firstName() + " is of type " + p.getClass().getSimpleName());
        }
    }

    // 2 - o type pattern seguido de uma condição
    for (Object o : objects) {
        if (o instanceof Person p && p.age() >= 18) {
            IO.println(p.firstName() + " is an adult");
        }
    }

    // 3 - o switch sobre o tipo do objeto, com guardas e record patterns (Java 21)
    for (Object o : objects) {
        IO.println(describe(o));
    }

    // 4 - um switch exaustivo sobre uma interface selada
    for (Object o : objects) {
        if (o instanceof Person p) {
            IO.println(p.firstName() + " : " + category(p));
        }
    }
}

String describe(Object o) {
    return switch (o) {
        case Teacher e when e.section() == 27 -> e.firstName() + " teaches computer science";
        case Teacher e -> e.firstName() + " teaches in section " + e.section();
        case Student(var firstName, _, _, var major) -> firstName + " studies " + major;
        case Person p when p.age() < 18 -> p.firstName() + " is a minor";
        case Person p -> p.firstName() + " is " + p.age() + " years old";
        case String s -> "a string of " + s.length() + " characters";
        case Integer n when n > 0 -> "the positive integer " + n;
        case null -> "the null reference";
        default -> "an unknown object";
    };
}

// sem default: o compilador sabe que os três casos cobrem todas as pessoas
String category(Person p) {
    return switch (p) {
        case Individual _ -> "individual";
        case Teacher _ -> "teacher";
        case Student _ -> "student";
    };
}

// uma interface selada e os três records que a implementam
sealed interface Person permits Individual, Teacher, Student {
    String firstName();
    String lastName();
    int age();
}

record Individual(String firstName, String lastName, int age) implements Person {
}

record Teacher(String firstName, String lastName, int age, int section) implements Person {
}

record Student(String firstName, String lastName, int age, String major) implements Person {
}
  • Linhas 66–79: uma interface selada [Person], implementada por três records: [Individual], [Teacher] e [Student]. A interface declara os métodos [firstName], [lastName] e [age]: os records os implementam automaticamente por meio de seus acessores, já que têm componentes com os mesmos nomes. Como um record é final, ele pode implementar uma interface selada sem outra especificação;
  • linhas 3–12: um array de objetos de vários tipos, incluindo um inteiro (convertido automaticamente em *[Integer]) e a referência *[null];
  • linha 16: o padrão de tipo [o instanceof Person p] (Java 16) é verdadeiro se [o] referencia um objeto do tipo [Person]; nesse caso, a variável [p], do tipo [Person], referencia esse objeto. Isso evita a sequência usada no Java anterior à versão 16: testar o tipo com [instanceof] e depois converter com [(Person) o]. O padrão é falso se [o] for igual a [null];
  • linha 24: a variável de padrão [p] pode ser usada no restante da condição, depois de [&&]: Java não tem padrões de propriedade; os valores dos campos são testados por meio de uma condição;
  • linhas 42–54: a expressão [switch] sobre um objeto (Java 21) testa os padrões em ordem e retorna o valor associado ao primeiro que corresponder:
    • linha 44: um professor da seção 27. A cláusula [when] adiciona uma condição, chamada de guard, ao padrão de tipo;
    • linha 45: qualquer outro professor. A ordem é importante: se este padrão fosse colocado antes do anterior, tornaria o anterior inalcançável, o que o compilador relataria como erro;
    • linha 46: um padrão de record: ele extrai os componentes do record [Student] na ordem em que foram declarados; [var] permite que o compilador infira seu tipo, e o caractere [_] (Java 22) ignora um componente;
    • linhas 47–48: um menor de idade, seguido de qualquer outra pessoa;
    • linha 50: um inteiro positivo;
    • linha 51: o caso [null]. Sem ele, um [switch] sobre uma referência nula lança uma exceção [NullPointerException];
    • linha 52: o caso [default] trata todo o resto. Sem ele, o compilador relataria que a expressão [switch] não cobre todos os casos: um [switch] sobre um objeto deve ser exaustivo;
  • linhas 57–63: um [switch] sobre uma [Person], sem [default]. Mesmo assim, ele é exaustivo: como a interface é selada, o compilador sabe que uma pessoa é um [Individual], um [Teacher] ou um [Student]. O padrão [Individual _] testa o tipo sem declarar uma variável.

Resultados:

> java Classes25.java
Jean is of type Individual
Lise is of type Individual
Lucile is of type Teacher
Marc is of type Teacher
Paul is of type Student
Jean is an adult
Lucile is an adult
Marc is an adult
Paul is an adult
Jean is 30 years old
Lise is a minor
Lucile teaches in section 61
Marc teaches computer science
Paul studies computer science
a string of 8 characters
the positive integer 42
the null reference
Jean : individual
Lise : individual
Lucile : teacher
Marc : teacher
Paul : student

Se o caso [Student] for removido do método [category], o compilador relata um erro:

1
2
3
4
5
6
> java Classes25.java
Classes25.java:58: error: the switch expression does not cover all possible input values
    return switch (p) {
           ^
1 error
error: compilation failed

Essa é a grande vantagem de combinar tipos selados com a correspondência de padrões: se um quarto record for adicionado à hierarquia, o compilador identifica todos os [switch] que precisam ser completados. Observe também que o padrão de tipo corresponde aos tipos que implementam a interface: o laço de padrões de tipo (linhas 15–20) selecionou os três tipos de pessoas. A correspondência de padrões é uma alternativa útil a instruções [if (o instanceof ...)] em cascata; no entanto, ela não deve substituir o polimorfismo: quando o comportamento depende do tipo do objeto e a hierarquia de classes é bem definida, um método redefinido em cada classe costuma continuar sendo a solução orientada a objetos. A correspondência de padrões é adequada para hierarquias de dados (records) sobre as quais se deseja escrever uma lógica de processamento externa a esses dados.

4.14. Tratamento do valor null

Qualquer variável de tipo de referência pode ter o valor [null], e usar uma referência nula causa a exceção [NullPointerException], o erro de execução mais comum em Java. Ao contrário de outras linguagens como C# ou Kotlin, o compilador Java não distingue entre tipos que podem ser [null] e tipos que não podem. No entanto, o JDK e as bibliotecas fornecem várias ferramentas para atenuar esse risco:

  • a classe [Optional<T>] (Java 8), o tipo de retorno de um método que pode não retornar nada;
  • os métodos da classe [Objects]: [requireNonNull] para rejeitar [null] no ponto de entrada de um método ou construtor, e [requireNonNullElse] para fornecer um valor padrão;
  • anotações que documentam a intenção e são verificadas por certas ferramentas de análise. As mais recentes, propostas por um grupo de fornecedores (Google, JetBrains, Spring…), são as da biblioteca JSpecify: [@Nullable] em um tipo que pode ser [null], e [@NullMarked] em uma classe ou pacote para indicar que os demais tipos não podem. O Spring Framework 7, que usaremos, as emprega. Elas exigem uma biblioteca, por isso não as usaremos neste capítulo.

O programa [Classes26.java] demonstra as duas primeiras:

// tratando o valor null: Optional, Objects.requireNonNull...
void main() {
    Person jean = new Person("Jean", "Dupont");
    jean.setMiddleName("Marie");
    Person[] persons = { jean, new Person("Paul", "Martin") };
    for (Person p : persons) {
        // um valor padrão quando a referência é null
        String middle = Objects.requireNonNullElse(p.getMiddleName(), "(none)");
        // um teste explícito
        String length = p.getMiddleName() == null ? "null" : String.valueOf(p.getMiddleName().length());
        IO.println(p.getFirstName() + " : middle name=" + middle + ", length=" + length);
    }

    // um método que pode não encontrar nada: ele retorna um Optional<Person>
    Optional<Person> found = find(persons, "Durand");
    IO.println("Durand found: " + found.isPresent());
    IO.println(found.map(Person::getFirstName).orElse("Durand: person not found"));
    // testamos a presença de um valor antes de usá-lo
    found = find(persons, "Martin");
    if (found.isPresent()) {
        IO.println("Martin : " + found.get().getFirstName());
    }
    // ifPresent: a ação só é executada se houver um valor presente
    find(persons, "Dupont").ifPresent(p -> p.setMiddleName("Louise"));
    find(persons, "Durand").ifPresent(p -> p.setMiddleName("Louise"));
    IO.println(jean.getMiddleName());
    // orElseThrow: afirmamos que o valor está presente, caso contrário uma exceção é lançada
    Person martin = find(persons, "Martin").orElseThrow();
    IO.println(martin.getFirstName());

    // Objects.requireNonNull: um parâmetro obrigatório
    try {
        new Person(null, "Morel");
    } catch (NullPointerException ex) {
        IO.println("Error: " + ex.getMessage());
    }
    // a exceção NullPointerException e sua mensagem detalhada (Java 14)
    try {
        Person lise = new Person("Lise", "Morel");
        IO.println(lise.getMiddleName().length());
    } catch (NullPointerException ex) {
        IO.println("Error: " + ex.getMessage());
    }
}

// procurando uma pessoa pelo sobrenome
Optional<Person> find(Person[] persons, String lastName) {
    for (Person p : persons) {
        if (p.getLastName().equals(lastName)) {
            return Optional.of(p);
        }
    }
    return Optional.empty();
}

class Person {
    // campos obrigatórios: nunca devem ser null
    private final String firstName;
    private final String lastName;
    // campo opcional: null significa "sem nome do meio"
    private String middleName;

    public Person(String firstName, String lastName) {
        this.firstName = Objects.requireNonNull(firstName, "the first name is mandatory");
        this.lastName = Objects.requireNonNull(lastName, "the last name is mandatory");
    }

    public String getFirstName() {
        return firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public String getMiddleName() {
        return middleName;
    }

    public void setMiddleName(String middleName) {
        this.middleName = middleName;
    }
}
  • linhas 56–83: a classe [Person] tem dois campos obrigatórios, inicializados pelo construtor, e um campo opcional, [middleName]: [null] significa “sem nome do meio”. O construtor rejeita um nome ou sobrenome [null] usando [Objects.requireNonNull] (linhas 64–65): o erro é detectado quando o objeto é criado, e não muito depois, quando o campo é usado;
  • linha 8: [Objects.requireNonNullElse(value, defaultValue)] (Java 9) retorna [value] se ele não for igual a [null]; caso contrário, retorna [defaultValue];
  • linha 10: uma verificação explícita costuma ser a abordagem mais simples;
  • linhas 47–54: o método [find] retorna a pessoa procurada encapsulada em um objeto [Optional], ou um [Optional] vazio: seu tipo de retorno, [Optional<Person>], avisa o chamador de que o resultado pode estar ausente e o obriga a tratar esse caso para obter a pessoa. [Optional.of(p)] cria um [Optional] contendo [p], [Optional.empty()], e um [Optional] vazio;
  • linha 16: [isPresent] indica se o [Optional] contém um valor;
  • linha 17: [map(Person::getFirstName)] converte qualquer pessoa presente em seu nome; [orElse(value)] retorna o valor presente ou, se não houver, o valor especificado. A notação [Person::getFirstName] é uma referência a método, que examinaremos no Capítulo 7; aqui, ela designa “o método [getFirstName] da pessoa”;
  • linhas 20–22: [get] retorna o valor presente; ele só é chamado depois de verificar sua presença;
  • linhas 24–25: [ifPresent] executa a ação especificada somente se houver um valor presente. A ação é uma lambda (Capítulo 7): [p -> p.setMiddleName("Louise")] lê-se “para a pessoa p, defina seu nome do meio”. Dupont existe e recebe um novo nome do meio; Durand não existe, e a instrução não faz nada;
  • Linha 28: [orElseThrow] retorna o valor se ele estiver presente ou lança uma exceção [NoSuchElementException] se o [Optional] estiver vazio. É usado quando se tem certeza de que o valor está presente;
  • linhas 32–36: uma pessoa sem nome é rejeitada pelo construtor;
  • linhas 38–43: usar uma referência nula lança a exceção [NullPointerException]. Desde o Java 14, sua mensagem identifica especificamente a expressão nula.

Resultados:

> java Classes26.java
Jean : middle name=Marie, length=5
Paul : middle name=(none), length=null
Durand found: false
Durand: person not found
Martin : Paul
Louise
Paul
Error: the first name is mandatory
Error: Cannot invoke "String.length()" because the return value of "Classes26$Person.getMiddleName()" is null

[Optional] destina-se a valores de retorno de métodos; ele não é usado em campos nem em parâmetros. Neste curso, documentamos se um valor é opcional, verificamos os parâmetros obrigatórios usando [Objects.requireNonNull] e preferimos objetos sempre completos (construídos com todos os seus valores obrigatórios) a objetos preenchidos de forma incremental.

4.15. Aplicação de exemplo - V2

Retomaremos o cálculo do imposto já tratado no capítulo anterior (versão 1) e o implementaremos agora com classes e interfaces. Vamos relembrar o problema. Queremos escrever um programa para calcular o imposto de um contribuinte. Consideraremos o caso simplificado de um contribuinte que tem apenas o salário a declarar (a tabela do imposto de 2004 para a renda de 2003, usada como está: trata-se de um exercício):

  • calcula-se o número de partes do empregado: partes = nbChildren / 2 + 1 se ele for solteiro, nbChildren / 2 + 2 se for casado, em que nbChildren é o número de filhos;
  • se ele tiver pelo menos três filhos, recebe meia parte adicional;
  • sua renda tributável R é calculada como R = 0,72 × S, em que S é seu salário anual;
  • seu quociente familiar é calculado como QF = R / partes;
  • seu imposto I é calculado com a tabela a seguir:
limite
coeffR
coeffN
4962
0
0
8382
0.068
291.09
14,753
0.191
1,322.92
23,888
0.283
2,668.39
38,868
0.374
4,846.98
47,932
0.426
6,883.66
0
0.481
9,505.54

Cada linha tem três campos. Para calcular o imposto I, procure a primeira linha em que QF ≤ limite. Por exemplo, se QF = 5.000, será encontrada a linha (8.382; 0,068; 291,09). O imposto I é então igual a 0,068 × R - 291,09 × partes. Se QF for tal que a condição QF ≤ limite nunca seja satisfeita, usam-se os coeficientes da última linha, resultando em imposto I = 0,481 × R - 9.505,54 × partes.

A aplicação gera o arquivo [TaxV2]. As classes de cálculo são organizadas em um pacote chamado [tax]:

1
2
3
4
5
6
7
TaxV2/
  Main.java                 the program that dialogues with the user
  tax/
    TaxBracket.java         a bracket of the tax scale
    ITax.java               the tax calculation interface
    AbstractTax.java        an abstract class implementing ITax
    HardwiredTax.java       a derived class, with hard-coded data

Primeiro, definimos um tipo capaz de encapsular uma linha da tabela anterior [TaxBracket.java]:

1
2
3
4
5
6
7
package tax;

import java.math.BigDecimal;

// uma faixa da tabela de imposto
public record TaxBracket(BigDecimal limit, BigDecimal coeffR, BigDecimal coeffN) {
}

Usamos um record:

  • porque uma faixa é um pequeno dado sem identidade, definido unicamente por seu valor, e não há motivo para que seja modificada depois de criada: um record é imutável;
  • porque o compilador gera o construtor, os acessores, o [toString], e o operador de igualdade a partir de uma única linha.

Os componentes são do tipo [BigDecimal] (pacote [java.math], daí a importação na linha 3). Os tipos [float] e [double] representam números em binário: um número decimal como 0,068 não tem representação exata neles, e os cálculos acumulam pequenos erros de arredondamento. A classe [BigDecimal] representa números decimais com exatidão: é o tipo a ser usado para valores monetários. Seu inconveniente é a ausência de operadores: escrevemos [a.add(b)], [a.multiply(b)], [a.compareTo(b)].

Em seguida, definimos uma interface [ITax] capaz de calcular o imposto [ITax.java]:

1
2
3
4
5
6
package tax;

public interface ITax {
    // cálculo do imposto de um contribuinte
    int calculate(boolean married, int nbChildren, int salary);
}
  • Linha 5: o método de cálculo do imposto com base em três dados: o estado civil do contribuinte, o número de filhos e o salário anual. Ele arredonda o imposto para baixo, para o euro inteiro mais próximo.

Em seguida, definimos uma classe abstrata que implementa essa interface [AbstractTax.java]:

package tax;

import java.math.BigDecimal;
import java.math.MathContext;
import java.util.List;

public abstract class AbstractTax implements ITax {
    // as faixas de imposto necessárias para o cálculo vêm de uma fonte externa
    // que somente as classes derivadas conhecem
    protected abstract List<TaxBracket> getTaxBrackets();

    // cálculo do imposto
    @Override
    public int calculate(boolean married, int nbChildren, int salary) {
        // cálculo do número de cotas
        BigDecimal shares = BigDecimal.valueOf(nbChildren).divide(BigDecimal.TWO)
                .add(BigDecimal.valueOf(married ? 2 : 1));
        if (nbChildren >= 3) {
            shares = shares.add(new BigDecimal("0.5"));
        }
        // cálculo da renda tributável e do quociente familiar
        BigDecimal income = new BigDecimal("0.72").multiply(BigDecimal.valueOf(salary));
        BigDecimal quotient = income.divide(shares, MathContext.DECIMAL128);
        // procurando a faixa de imposto: a última é usada se nenhum limite servir
        List<TaxBracket> brackets = getTaxBrackets();
        TaxBracket bracket = brackets.getLast();
        for (int i = 0; i < brackets.size() - 1; i++) {
            if (quotient.compareTo(brackets.get(i).limit()) <= 0) {
                bracket = brackets.get(i);
                break;
            }
        }
        // cálculo do imposto
        return income.multiply(bracket.coeffR()).subtract(shares.multiply(bracket.coeffN())).intValue();
    }
}
  • Linha 1: a classe pertence ao pacote [tax]; seu arquivo fica, portanto, na pasta [tax];
  • Linha 7: a classe [AbstractTax] implementa a interface [ITax];
  • Linha 10: os dados da tabela, fornecidos por um método abstrato protegido. A classe [AbstractTax] não sabe de onde esses dados vêm (escritos no código, lidos de um arquivo, de um banco de dados etc.). Ela deixa isso a cargo das classes derivadas. Por isso é declarada abstrata, o que impede sua instanciação. O método abstrato obriga as classes derivadas a fornecer as faixas; o compilador verifica isso;
  • linhas 13–35: a implementação do método [calculate] da interface [ITax]. As classes derivadas não precisarão reescrever esse método. A classe [AbstractTax] serve, assim, como classe de fatoração para as classes derivadas: ela contém o que é comum a todas;
  • linhas 16–17: o número de partes. [BigDecimal.valueOf(n)] converte um inteiro em [BigDecimal]; a divisão por [BigDecimal.TWO] é exata (3 / 2 = 1,5), ao contrário da divisão inteira por [nbChildren / 2] (3 / 2 = 1). A expressão [married ? 2 : 1] vale 2 para um contribuinte casado e 1 caso contrário;
  • linhas 18–20: a meia parte adicional. Um [BigDecimal] é imutável: [add] retorna um novo objeto, que deve ser atribuído à variável;
  • linhas 22–23: a renda tributável e o quociente familiar. As constantes decimais são criadas a partir de cadeias ([new BigDecimal("0.72")]) para garantir que sejam exatas. Dividir um [BigDecimal] pode resultar em um número infinito de casas decimais (1 / 3): especificamos a precisão desejada, neste caso [MathContext.DECIMAL128] (34 dígitos significativos);
  • linhas 25–32: a busca pela faixa. Por padrão, é a última faixa ([brackets.getLast()], linha 26). O laço percorre todas as faixas, exceto a última, e para ([break]) na primeira faixa cujo limite seja maior ou igual ao quociente familiar, conforme testado por [compareTo(...) <= 0];
  • linha 34: o cálculo do imposto. O método [intValue] trunca o resultado em sua parte inteira.

Uma classe que implementa a interface [ITax] pode ser criada derivando-a da classe [AbstractTax]. É o que fazemos agora com [HardwiredTax.java]:

package tax;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;

public class HardwiredTax extends AbstractTax {
    // dados do cálculo do imposto (tabela de 2004 sobre a renda de 2003), "fixos no código"
    private static final double[] LIMITS = { 4962, 8382, 14753, 23888, 38868, 47932, 0 };
    private static final double[] COEFF_R = { 0, 0.068, 0.191, 0.283, 0.374, 0.426, 0.481 };
    private static final double[] COEFF_N = { 0, 291.09, 1322.92, 2668.39, 4846.98, 6883.66, 9505.54 };

    // as faixas de imposto
    private final List<TaxBracket> taxBrackets;

    // construtor
    public HardwiredTax() {
        // criando e preenchendo a lista de faixas de imposto
        List<TaxBracket> brackets = new ArrayList<>();
        for (int i = 0; i < LIMITS.length; i++) {
            brackets.add(new TaxBracket(BigDecimal.valueOf(LIMITS[i]),
                    BigDecimal.valueOf(COEFF_R[i]), BigDecimal.valueOf(COEFF_N[i])));
        }
        // a lista armazenada não é modificável
        taxBrackets = List.copyOf(brackets);
    }

    // implementação do método abstrato da classe pai
    @Override
    protected List<TaxBracket> getTaxBrackets() {
        return taxBrackets;
    }
}
  • Linhas 9–11: a classe [HardwiredTax] codifica diretamente os dados necessários ao cálculo do imposto. Eles são campos de classe ([static]) [final]: são compartilhados por todas as instâncias e não podem ser substituídos por outros arrays. Por convenção, os nomes das constantes ([static final]) são escritos em maiúsculas;
  • linhas 17–26: o construtor usa esses dados para construir a lista de faixas de imposto. [BigDecimal.valueOf(double)] (linhas 21–22) converte um [double] em um [BigDecimal] por meio de sua representação decimal mais curta: [BigDecimal.valueOf(0.068)] é exatamente 0,068. Não use o construtor [new BigDecimal(0.068)], que reproduz todas as casas decimais do valor binário aproximado (0.068000000000000004884981308350688…);
  • linha 25: [List.copyOf] retorna uma cópia somente leitura da lista: nenhuma classe poderá modificar a tabela;
  • linhas 29–32: o método abstrato da classe pai é implementado: ele retorna a lista de faixas.

O próximo capítulo acrescentará outras classes derivadas de [AbstractTax], que lerão as faixas de um arquivo de texto ou de JSON: elas só precisarão fornecer o método [getTaxBrackets].

Um programa de teste poderia ser o seguinte [Main.java]:

// programa interativo de cálculo do imposto
// o usuário digita três dados no teclado: married nbChildren salary
// o programa então exibe o imposto a pagar
import tax.HardwiredTax;
import tax.ITax;

static final String SYNTAX = """
        syntax: Married NbChildren Salary
        Married: y for married, n for not married
        NbChildren: number of children
        Salary: annual salary in euros""";

void main() {
    // criação de um objeto ITax
    ITax tax = new HardwiredTax();

    // laço de entrada
    while (true) {
        // pedimos os parâmetros do cálculo do imposto
        String parameters = IO.readln("Tax calculation parameters in the format: "
                + "Married (y/n) NbChildren Salary, or nothing to stop: ");
        // fim da entrada padrão ou linha vazia: paramos
        if (parameters == null || parameters.isBlank()) {
            break;
        }
        // verificando o número de campos da linha digitada
        String[] fields = parameters.strip().split("\\s+");
        if (fields.length != 3) {
            IO.println(SYNTAX);
            continue;
        }
        // verificando a validade dos parâmetros
        // married
        String married = fields[0].toLowerCase();
        if (!married.equals("y") && !married.equals("n")) {
            IO.println(SYNTAX + "\nIncorrect married argument: type y or n");
            continue;
        }
        // nbChildren
        int nbChildren = positiveInteger(fields[1]);
        if (nbChildren < 0) {
            IO.println(SYNTAX + "\nIncorrect NbChildren argument: type a positive or zero integer");
            continue;
        }
        // salary
        int salary = positiveInteger(fields[2]);
        if (salary < 0) {
            IO.println(SYNTAX + "\nIncorrect salary argument: type a positive or zero integer");
            continue;
        }
        // os parâmetros estão corretos: calculamos o imposto
        IO.println("Tax=" + tax.calculate(married.equals("y"), nbChildren, salary) + " euros");
    }
}

// retorna o inteiro positivo ou zero representado pela string, -1 se a string não representar um
int positiveInteger(String input) {
    try {
        int value = Integer.parseInt(input);
        return value >= 0 ? value : -1;
    } catch (NumberFormatException ex) {
        return -1;
    }
}

O programa acima permite ao usuário realizar simulações repetidas de cálculo de imposto.

  • Linhas 4–5: o programa principal está no pacote sem nome; ele importa os dois tipos de que precisa do pacote [tax]. Esses tipos devem ser públicos;
  • Linhas 7–11: a mensagem de ajuda é uma constante da classe implícita, escrita como um bloco de texto (Java 15) delimitado por três aspas: a cadeia pode se estender por várias linhas, e a indentação comum das linhas é removida. Como as aspas de fechamento são colocadas no fim da última linha, a cadeia não termina com uma quebra de linha;
  • linha 15: criação de um objeto [tax] que implementa a interface [ITax]. Esse objeto é obtido instanciando um tipo [HardwiredTax], um tipo que implementa a interface [ITax]. Observe que à variável [tax] não foi atribuído o tipo [HardwiredTax] , mas sim o tipo [ITax]. Ao escrever isso, indicamos que só nos interessa o método [calculate] do objeto [tax] e não o restante. Para usar dados de um arquivo, basta alterar essa única linha;
  • linhas 18–53: o laço das simulações de cálculo de imposto;
  • linhas 20–21: os três parâmetros exigidos pelo método [calculate] são solicitados em uma única linha digitada no teclado. [IO.readln(message)] exibe a mensagem e depois lê uma linha; ele retorna [null] se a entrada padrão estiver fechada: a verificação da linha 23 então encerra o programa, assim como faria uma linha vazia;
  • linha 27: o método [split] divide a linha (sem os espaços iniciais e finais) em palavras separadas por um ou mais caracteres de espaço (expressão regular ["\\s+"]);
  • Linhas 40 e 46: o método [positiveInteger] (linhas 57–64) verifica se os dois últimos campos são inteiros positivos ou zero. [Integer.parseInt] lança uma exceção [NumberFormatException] se a cadeia não representar um inteiro: o método a captura e retorna -1, que indica um erro;
  • linha 52: chamada ao método [calculate] do objeto [tax] que implementa a interface [ITax].

Eis um exemplo de execução do programa, iniciado a partir da pasta [TaxV2]:

> java Main.java
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: q s d
syntax: Married NbChildren Salary
Married: y for married, n for not married
NbChildren: number of children
Salary: annual salary in euros
Incorrect married argument: type y or n
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 2 d
syntax: Married NbChildren Salary
Married: y for married, n for not married
NbChildren: number of children
Salary: annual salary in euros
Incorrect salary argument: type a positive or zero integer
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: q s d f
syntax: Married NbChildren Salary
Married: y for married, n for not married
NbChildren: number of children
Salary: annual salary in euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y -1 60000
syntax: Married NbChildren Salary
Married: y for married, n for not married
NbChildren: number of children
Salary: annual salary in euros
Incorrect NbChildren argument: type a positive or zero integer
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 2 60000
Tax=4282 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 3 60000
Tax=2959 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: n 0 60000
Tax=11519 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: 

Os valores dos impostos são calculados corretamente: 4.282 euros para um contribuinte casado com dois filhos e salário anual de 60.000 euros (linha 26), e 2.959 euros com três filhos (linha 28). Um contribuinte solteiro sem filhos paga 11.519 euros pelo mesmo salário (linha 30).

Em comparação com a versão 1, o cálculo agora está encapsulado em classes por trás de uma interface: o programa de diálogo só conhece a interface [ITax]. As versões seguintes aproveitarão essa separação: a versão 3 (próximo capítulo) mudará a fonte de dados derivando novas classes de [AbstractTax], e depois a aplicação será organizada em camadas (Capítulo 6).