Classes e objetos em Java

Uma classe define um tipo: os dados que seus objetos lembram e as operações que oferecem. Um objeto, também chamado de instância, é um valor desse tipo criado durante a execução de um programa. Escrever uma definição de classe não cria um objeto.

Estado e comportamento

O nome, a espécie e a idade de um animal de estimação formam seu estado. Esses valores atuais ficam em variáveis de instância, também chamadas de campos. Uma operação como celebrar um aniversário é um comportamento, escrito como método. O método de aniversário fica junto da idade que ele altera, de modo que a regra é mantida em um só lugar.

Pense em uma classe como uma planta de construção. Muitas casas podem seguir uma planta, mas cada casa tem seu próprio conteúdo. Da mesma forma, dois animais podem seguir a mesma definição e ter idades diferentes. Você escreve os nomes dos campos uma vez; cada objeto recebe seus próprios valores.

Leia uma classe pequena

public class Pet {
    private String name;
    private String species;
    private int age;

    public Pet(String name, String species, int age) {
        this.name = name;
        this.species = species;
        this.age = age;
    }

    public void celebrateBirthday() {
        this.age++;
    }
}

Leia de fora para dentro. public class Pet apresenta o tipo, e as chaves externas contêm sua definição. As três primeiras declarações descrevem o estado. O bloco chamado Pet é um construtor: ele dá a um novo objeto seus primeiros valores. celebrateBirthday é um método: ele aumenta a idade do objeto atual. As palavras private e public controlam o acesso; exemplos posteriores as usam para proteger o estado.

Os parâmetros do construtor são valores fornecidos quando um objeto é criado. Em this.age = age;, o lado esquerdo indica o campo do objeto e o lado direito indica o parâmetro fornecido. O construtor armazena essa entrada para que o objeto possa lembrá-la após o fim da construção.

Coloque uma classe em uso

Você já usou classes de biblioteca. Scanner descreve objetos que leem dados de entrada, ArrayList descreve listas e um objeto String oferece operações como length(). Uma classe que você escreve segue a mesma ideia básica: ela disponibiliza um tipo útil para o restante do programa.

Sem Pet, um programa poderia passar nome, espécie e idade separadamente para muitos métodos. Ele precisa manter cada grupo unido corretamente. Um objeto Pet reúne os valores relacionados em uma unidade. Os métodos desse objeto sabem qual idade devem usar.

Organize e nomeie o código

Em arquivos de código-fonte comuns, uma classe pública chamada Pet é salva em Pet.java, com as mesmas letras maiúsculas e minúsculas. Uma classe Main separada pode conter o método main do programa, criar animais e chamar seus métodos. Pet não precisa de seu próprio main. Classes no mesmo pacote sem nome podem usar umas às outras sem importações; os exemplos simples mantêm essas classes em uma pasta.

Use substantivos em UpperCamelCase para classes, como LibraryBook. Use lowerCamelCase para campos e métodos: pageCount nomeia dados; giveBack() nomeia uma ação. Essas convenções ajudam o leitor a reconhecer cada parte, embora o compilador permita muitos outros nomes.

Criar um objeto e declarar uma variável são operações diferentes. Uma variável fornece um nome pelo qual acessar um objeto; new cria o objeto ao qual o nome se referirá.

Leia uma instrução de criação de objeto

Pet luna = new Pet("Luna", "cat", 3);

Pet é o tipo da variável, e luna é seu nome. new Pet(...) cria um novo objeto e chama um construtor correspondente com três argumentos. O construtor armazena o nome, a espécie e a idade. A referência resultante é atribuída a luna.

Uma referência informa ao Java qual objeto usar. É útil desenhar uma variável como um nome com uma seta apontando para um objeto. A variável não é uma segunda cópia de todos os campos do objeto.

Chame um método em um objeto específico

O ponto em luna.celebrateBirthday() conecta uma referência a um método a ser executado em seu objeto. Um método que retorna um valor pode fornecê-lo a outra expressão:

luna.celebrateBirthday();
int years = luna.getAge();
System.out.println(years); // 4

Aqui getAge() é um método público que retorna a idade do animal. A chamada de aniversário altera o estado; o método de acesso lê esse estado. Pet.celebrateBirthday() falha porque esse método de instância precisa de um animal específico. O nome da classe, sozinho, não responde de quem é o aniversário.

Objetos distintos e referências compartilhadas

Pet max = new Pet("Max", "dog", 5);
luna.celebrateBirthday();
System.out.println(luna.getAge()); // 5
System.out.println(max.getAge());  // 5

Luna já tinha 4 anos, portanto o próximo aniversário a leva a 5. Max continua com 5. Idades iguais não fazem deles o mesmo objeto: as duas expressões new criaram animais distintos.

Agora considere uma atribuição sem new:

Pet other = luna;
other.celebrateBirthday();
System.out.println(luna.getAge()); // 6

A atribuição copia a referência de Luna. Ambos os nomes acessam um único animal, portanto alterá-lo por meio de other é visível por meio de luna. Para criar um segundo animal, chame new novamente.

Faça os argumentos corresponderem aos parâmetros do construtor

Os argumentos devem corresponder à quantidade, à ordem e aos tipos dos parâmetros de um construtor declarado. Se o único construtor disponível aceitar (String, String, int), new Pet() não compila. O Java não adivinha valores ausentes. Trocar as duas cadeias de caracteres, porém, ainda compila: new Pet("cat", "Luna", 3) fornece os tipos certos, mas os significados errados. Leia os nomes dos parâmetros para verificar essa ordem.

Estas duas tentativas incompletas falham por motivos diferentes:

Pet a;                         // declaration only
// System.out.println(a.getAge()); // a has no assigned value
// Pet b = Pet("Bo", "cat", 2);    // missing new

Uma variável local deve receber um valor antes de ser usada. Sem new, o Java procura um método chamado Pet, não uma expressão de criação de objeto. Depois que um objeto existe, exibi-lo pode mostrar um texto como Pet@8bcc55f até que você forneça um método toString() legível; essa saída não significa que a construção falhou.

Um objeto precisa de um campo para cada valor que deve lembrar entre chamadas de métodos. Escolha esses valores antes de escrever os métodos: eles formam o estado duradouro do objeto.

Declare campos com tipos adequados

Um campo fica dentro das chaves da classe, mas fora de todos os construtores e métodos. Uma declaração precisa de um tipo e um nome; um modificador de acesso e um inicializador também podem aparecer.

private String title;
private int pageCount;
private boolean lentOut = false;

String é adequado para texto, int para uma contagem inteira e boolean para uma condição de sim ou não. Campos também podem usar tipos de classe, como ArrayList<String>. Estes exemplos usam private; omitir o modificador resulta em acesso de pacote, não em acesso privado.

Cada objeto recebe uma cópia separada de cada campo de instância. Dois objetos Rectangle têm, cada um, um width e um height, embora as declarações apareçam apenas uma vez na classe.

Valores padrão nem sempre são valores iniciais utilizáveis

Um valor padrão é atribuído a um campo quando o espaço de armazenamento do objeto é criado. Ele pode não ser adequado à finalidade do objeto. Um campo de lista com valor null não é uma lista vazia: você ainda precisa criar a lista antes de adicionar um item.

Variáveis locais não recebem esse valor padrão. Dentro de um método, int total; seguido de System.out.println(total); não compila porque nenhum valor foi atribuído a total. Mantenha separadas a regra dos campos e a das variáveis locais.

Decida o que deve durar

Um campo permanece com seu objeto. Um parâmetro fica disponível durante sua chamada, e uma variável local fica disponível em seu bloco enquanto essa chamada é executada. Se um contador precisa manter sua contagem de uma chamada para a seguinte, a contagem pertence a um campo. Um subtotal temporário usado em um cálculo pode ser local.

Armazene as entradas; calcule os valores derivados

public class Rectangle {
    private double width;
    private double height;

    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }

    public double area() {
        return this.width * this.height;
    }
}

As dimensões estão em centímetros, portanto area() retorna uma área em centímetros quadrados. Armazenar um campo separado para a área criaria outro valor a atualizar sempre que uma das dimensões mudasse. Calculá-la a partir das dimensões mantém o resultado consistente.

Use um campo de instância final para um valor atribuído uma vez, como private final String title;. Dê a ele um valor em sua declaração ou em cada construtor. final impede a reatribuição. static tem outro significado: cria um campo de classe compartilhado. Adicionar static ao nome de um animal faria animais diferentes compartilharem uma única variável de nome.

Um construtor inicializa um objeto quando new o cria. Seu nome deve corresponder ao da classe, e ele não tem tipo de retorno. Até mesmo void transformaria a declaração em um método.

Transfira as entradas para o estado

public Pet(String name, String species, int age) {
    this.name = name;
    this.species = species;
    this.age = age;
}

Um construtor geralmente recebe entradas como parâmetros e as armazena em campos. Aqui cada parâmetro tem o mesmo nome de seu campo. O nome age sozinho se refere ao parâmetro; this.age se refere ao campo do objeto que está sendo criado. A atribuição lê o valor fornecido à direita e o escreve no campo à esquerda.

Para new Pet("Luna", "cat", 3), primeiro os campos do novo objeto recebem valores padrão: null, null e 0. O construtor então recebe os três argumentos e substitui esses valores padrão. Quando a construção termina, new produz a referência que o código que o chamou armazena.

Dois defeitos que compilam

public Pet(String name, String species, int age) {
    name = name;
    this.species = species;
    this.age = age;
}

As duas ocorrências de name se referem ao parâmetro, portanto a primeira linha atribui esse parâmetro a si mesmo. O nome do objeto permanece null. O código é válido, por isso é importante verificar os valores do novo objeto.

Uma declaração dentro do construtor causa um problema relacionado:

String nick = initialNick;

Se um campo chamado nick já existir, essa linha cria uma variável local com o mesmo nome. A variável local desaparece quando a construção termina. Escreva this.nick = initialNick; para armazenar a entrada no campo; não repita o tipo.

Saiba quando existe um construtor sem argumentos

Se uma classe não declarar construtores, o Java fornece um construtor padrão sem parâmetros. Para uma classe simples, seus campos mantêm os valores dos inicializadores declarados ou seus valores padrão. Assim que você declara um construtor, o Java deixa de fornecer o padrão.

Uma classe que tem apenas Pet(String name, String species, int age) não pode, portanto, ser criada com new Pet(). Adicione um construtor explícito sem argumentos apenas quando houver um estado inicial útil para ele. Observe também public void Pet(...): isso é um método, portanto não fornece o construtor pretendido.

Defina também os valores internos iniciais

Nem todo campo precisa vir de um argumento. Um novo livro sempre pode começar com this.lentOut = false;. Uma classe que possui uma lista pode inicializá-la assim, com ArrayList importado:

private ArrayList<String> tracks;

public Playlist() {
    this.tracks = new ArrayList<>();
}

A lista vazia está pronta para add. Deixar tracks como null faz uma chamada posterior a tracks.add(...) falhar com NullPointerException.

Um inicializador de campo é executado antes do corpo do construtor. Se private int score = 10; for seguido de this.score = 5; no construtor, a pontuação do objeto pronto será 5. Teste os valores após a construção, não apenas os valores escritos junto às declarações dos campos. Os construtores também precisam das mesmas regras de validação usadas em alterações posteriores, para que o estado inicial seja válido.

Uma classe pode oferecer várias formas úteis de criar um objeto. Sobrecarga de construtores significa declarar construtores com listas de parâmetros diferentes.

Distinga construtores pelos parâmetros

O Java distingue construtores pela quantidade, pelos tipos e pela ordem de seus parâmetros. Os nomes dos parâmetros não os distinguem. Box(String label) e Box(String name) descrevem a mesma lista de parâmetros, portanto não podem ser declarados juntos em uma classe.

Um animal pode ser criado com uma idade ou como recém-nascido:

public Pet(String name, String species, int age) {
    this.name = name;
    this.species = species;
    this.age = age;
}

public Pet(String name, String species) {
    this(name, species, 0);
}

new Pet("Pip", "rabbit") seleciona o construtor com dois parâmetros. Esse construtor fornece 0 como a idade ausente e chama o construtor com três parâmetros. O novo objeto termina com o estado "Pip", "rabbit" e 0.

Encadeie a inicialização no mesmo objeto

Dentro de um construtor, this(...) chama outro construtor da mesma classe. O construtor mais curto escolhe os valores padrão; o mais completo faz a inicialização compartilhada. As verificações colocadas nessa inicialização se aplicam às duas formas de construção.

Compare duas linhas que parecem semelhantes:

A segunda linha não preenche os campos do objeto atual. Se seu resultado nunca for armazenado, esse animal extra será descartado. O animal atual ainda pode ter campos null.

Acompanhe uma cadeia antes de rastrear o código posterior

Um relógio pode oferecer a meia-noite como padrão:

public Clock() {
    this(0, 0);
}

public Clock(int hours, int minutes) {
    this.hours = hours;
    this.minutes = minutes;
}

Para new Clock(), entre no construtor sem argumentos, siga this(0, 0) e atribua valores aos dois campos no construtor com dois argumentos. Depois, o controle retorna ao construtor sem argumentos. Isso cria um relógio, não dois. Uma chamada a new Clock(9, 5) começa diretamente no construtor mais completo.

Mantenha a cadeia válida e clara

Um construtor pode conter no máximo uma chamada this(...). A cadeia deve chegar a uma inicialização que não chame de volta a cadeia: dois construtores que delegam um ao outro causam um erro de compilação de construtor recursivo.

Colocar this(...) em primeiro lugar é um estilo claro que funciona em várias versões do Java. No Java 24 e em versões anteriores sem recursos de prévia, ela deve vir primeiro. O Java 25 permite instruções antes dela para tarefas como calcular ou verificar argumentos. Essas instruções não podem ler os campos de instância do objeto atual nem chamar seus métodos de instância; são permitidas atribuições a campos declarados na classe sem inicializadores na declaração.

Ofereça sobrecargas porque os códigos que chamam os construtores têm diferentes entradas úteis. Um relógio à meia-noite faz sentido; um livro sem título talvez não faça. A existência de um construtor completo não cria automaticamente sobrecargas mais curtas.

Um método de instância é executado para um objeto específico. Declare-o sem static e use os campos desse objeto por meio de nomes como this.width. Decida do que o código que o chama precisa: uma alteração de estado, um resultado retornado ou ambos.

Retorne cálculos; deixe alterações de estado explícitas

Para um retângulo cujas dimensões são armazenadas em centímetros:

public double area() {
    return this.width * this.height;
}

public double perimeter() {
    return 2 * (this.width + this.height);
}

public void scale(double factor) {
    this.width = this.width * factor;
    this.height = this.height * factor;
}

Um retângulo com lados de 3,0 e 4,0 tem área de 12,0 centímetros quadrados e perímetro de 14,0 centímetros. scale(2) altera os lados para 6,0 e 8,0. As chamadas seguintes retornam área 48,0 e perímetro 28,0. Cada método lê os campos atuais, portanto não é necessário atualizar uma área armazenada.

area() retorna um número que pode ser armazenado ou usado em um cálculo. Se apenas exibisse o número e tivesse tipo de retorno void, o código que o chama não poderia escrever double twice = r.area() * 2;. Deixe a exibição para o código que chama o método quando a função dele for calcular um valor.

Atualize campos relacionados em ordem

O método advance() de um relógio deve tratar a virada dos minutos e das horas:

public void advance() {
    this.minutes++;
    if (this.minutes == 60) {
        this.minutes = 0;
        this.hours++;
        if (this.hours == 24) {
            this.hours = 0;
        }
    }
}

Às 23:58, a primeira chamada chega a 23:59 e pula os dois blocos de reinicialização. A chamada seguinte chega por um instante ao minuto 60, volta-o para 0, aumenta a hora para 24 e a volta para 0. O estado final é 00:00. Mais uma chamada resulta em 00:01.

Rastreie objetos separadamente

Escreva uma linha após cada instrução e uma coluna para os campos de cada objeto. Altere apenas o objeto indicado pelo objeto receptor da chamada. Para animais com idades 2 e 7, dois aniversários no primeiro animal e setAge(1) no segundo deixam as idades em 4 e 1. Não execute o corpo de um método para todas as instâncias só porque elas compartilham uma classe.

Uma declaração local pode ocultar o campo que você pretendia atualizar. public void reset() { int count = 0; } apenas cria uma variável temporária. this.count = 0; reinicia a contagem duradoura.

Reutilize métodos e complete os caminhos de retorno

Dentro de um método de instância, area() e this.area() chamam o método de área do mesmo objeto. Um método de descrição pode reutilizar esse cálculo em vez de copiar sua expressão. Um método também pode alterar o estado e retornar se a operação foi bem-sucedida, como lend() faz ao marcar um livro como emprestado e informar true.

Um método que não seja void não pode simplesmente chegar ao fim sem retornar um valor compatível. Se get() retorna apenas dentro de if (count > 0), o que acontece quando a contagem é 0? Adicione o caminho de retorno necessário ou lance uma exceção para um valor que o método rejeite. Um caminho que lança uma exceção não retorna ao código que chamou o método e não precisa de um valor de retorno.

Pergunte a quem pertence um valor ou uma operação antes de decidir se deve usar static. A idade de um animal pertence a um animal. A contagem de todos os animais criados pertence à classe como um todo.

O objeto atual é this

Dentro de um construtor ou método de instância, this se refere ao objeto que está sendo construído ou recebendo a chamada. Em this.age++, ele identifica de quem é a idade que muda. Em this.name = name, ele distingue o campo de um parâmetro com o mesmo nome. this(...) é a forma de encadeamento de construtores.

Um método estático não tem objeto atual, portanto this não pode ser usado nele. Ele ainda pode criar um objeto ou receber uma referência e usá-la para chamar métodos de instância.

Campos compartilhados e campos de cada objeto

public class Counter {
    private int count;
    private static int created = 0;

    public Counter() {
        this.count = 0;
        created++;
    }

    public void increment() {
        this.count++;
    }

    public int getCount() {
        return this.count;
    }

    public static int getCreated() {
        return created;
    }
}

Após duas chamadas a new Counter(), há dois campos count separados, ambos inicialmente 0, e um campo created igual a 2. Incrementar o primeiro contador altera sua contagem para 1; o segundo permanece em 0. Counter.getCreated() ainda retorna 2 porque nenhum novo objeto foi construído.

Trabalhe por meio de um objeto a partir de main

public static void main(String[] args) {
    Counter c = new Counter();
    c.increment();
    System.out.println(c.getCount());
}

O método main clássico é estático. Uma chamada a increment() apenas pelo nome nesse método não teria um objeto alvo e não compilaria. A variável c fornece esse alvo. Tornar count estático para eliminar o erro mudaria o projeto: todos os contadores compartilhariam uma única contagem.

O Java 25 também aceita formas de main como método de instância, mas o cabeçalho estático clássico continua válido. Estes exemplos o usam de forma consistente.

Escolha métodos e constantes com cuidado

Uma operação que precisa dos campos de um objeto deve ser um método de instância. Uma operação que depende apenas de seus parâmetros pode ser estática, como um método auxiliar que converte um número total de minutos em horas. Chamadas estáticas normalmente usam o nome da classe: Math.sqrt(16) ou Counter.getCreated().

Um valor fixo compartilhado geralmente é declarado como constante:

public static final int MAX_CELSIUS = 30;

public o torna disponível para os códigos que o usam, static dá à classe um campo compartilhado, e final impede a reatribuição. UPPER_SNAKE_CASE indica uma constante por convenção. Essa é uma exceção comum à regra de tornar campos privados. Não use static para nomes, dimensões ou outros estados comuns que precisam ser diferentes entre objetos.

Encapsulamento mantém o estado de um objeto junto com o código que o controla. Campos geralmente são privados, enquanto os códigos que usam o objeto recorrem a operações públicas. Isso oculta os detalhes de armazenamento e dá à classe um lugar para aplicar suas regras.

Escolha um nível de acesso

Um pacote agrupa classes. Os exemplos simples colocam classes comuns juntas sem uma declaração package, em um pacote sem nome. O acesso de pacote é o resultado da omissão do modificador; não existe uma palavra-chave de acesso package para adicionar a um campo.

Comece com o acesso mais restrito que seja útil. Torne os campos privados, os construtores e as operações necessários a outras classes públicos e os métodos auxiliares internos privados. Constantes públicas são uma exceção comum para campos.

Deixe a classe controlar as alterações

Se Pet declarar private int age;, uma classe Main separada não poderá atribuir luna.age = -5;. O compilador rejeita o acesso. Uma chamada como luna.setAge(-5) pode ser permitida, pois o método público pertence a Pet e pode decidir se armazena o argumento.

Um campo público permitiria que qualquer código contornasse esse método. Quando todas as alterações passam pelo código da classe, as verificações podem ficar em um só lugar. O acesso privado, por si só, não valida uma idade; os métodos também devem fazer as verificações.

Mantenha a interface pública estável

Suponha que um relógio inicialmente armazene campos hours e minutes separados. Os códigos que o usam chamam getHours() e getMinutes(). Depois você substitui os campos por um único valor minutesSinceMidnight:

public int getHours() {
    return this.minutesSinceMidnight / 60;
}

public int getMinutes() {
    return this.minutesSinceMidnight % 60;
}

Com 615 minutos armazenados, a divisão retorna 10 e o resto retorna 15. O relógio informa 10:15 por meio dos mesmos métodos. Os códigos que o usam não precisam ser reescritos porque dependiam das operações públicas, não de como o estado era armazenado. Essa liberdade de alterar detalhes internos é a ocultação de informações.

O acesso pertence às classes, não a objetos individuais

Código dentro de Pet pode ler um campo privado de outro objeto Pet. A permissão de acesso decorre de estar dentro da classe. Uma classe de nível superior diferente não recebe permissão por ter uma referência a um animal ou por estar na mesma pasta.

Para declarações comuns de classes de nível superior, as opções de acesso são public ou nenhum modificador. Uma declaração private class Pet no nível superior é ilegal. Uma classe pública de nível superior fica no arquivo de código-fonte correspondente, e um arquivo de código-fonte comum contém no máximo uma classe pública de nível superior.

Campos privados são um limite de projeto do programa. Eles impedem que outro código comum dependa diretamente dos campos internos, mas não são uma forma de manter um valor em segredo de alguém que pode inspecionar o programa. Use-os para controlar a interface da sua classe e proteger seu estado.

Uma classe pode permitir que os códigos que a usam leiam ou alterem partes selecionadas de seu estado por meio de métodos. Decida quais operações a classe deve oferecer antes de criar métodos de acesso para todos os campos.

Retorne valores com métodos de acesso

Um método de acesso, também chamado de método acessor, retorna informações sem alterar o objeto. Um método de acesso comum lê um campo:

public String getName() {
    return this.name;
}

public int getAge() {
    return this.age;
}

O tipo retornado corresponde à informação fornecida. Um método de acesso que exibe o valor e retorna void não pode fornecer um valor a uma expressão como pet.getAge() + 1. O código que chama o método deve receber o valor e decidir como usá-lo.

Altere valores selecionados com métodos modificadores

Um método modificador, também chamado de método mutador, recebe um novo valor e atualiza o estado:

public void setName(String name) {
    this.name = name;
}

this.name é o campo. name é o parâmetro. Escrever name = name; compila, mas não altera nenhum campo. Não há valor de retorno aqui porque a função desse método modificador é fazer uma alteração.

Para um animal com idade 3:

luna.setName("Lulu");
System.out.println(luna.getName() + " is " + luna.getAge());
// Lulu is 3

O código que chama os métodos nunca acessa um campo diretamente. O método modificador altera o nome, e os métodos de acesso retornam os valores atuais para que o código os combine.

Siga os nomes esperados por outros códigos Java

Coloque em maiúscula a primeira letra do nome do campo depois de get, set ou do prefixo is, usual para booleanos. Um nome como getname() pode compilar, mas não segue a convenção esperada por ferramentas e outros programadores.

Disponibilize apenas operações úteis

O título de um livro pode ter um método de acesso e nenhum método modificador, pois os códigos que o usam devem poder lê-lo, mas não substituí-lo. Um campo privado final pode garantir que ele receba um valor uma única vez. Um contador interno pode não precisar de nenhum dos dois métodos se apenas a classe o usar.

Um método modificador sem verificação pode aceitar o mesmo valor prejudicial que um campo público. Adicione verificações quando uma alteração tiver restrições. Considere também um método de ação: celebrateBirthday() expressa o aumento da idade em uma unidade, e lend() expressa uma tentativa de empréstimo. lend() pode examinar o estado atual e rejeitar um segundo empréstimo. Um método modificador também pode fazer essa verificação; o nome de ação torna a operação mais clara para quem a chama.

Um método de acesso pode calcular uma resposta. getArea() pode retornar o produto da largura pela altura sem nenhum campo area.

Uma invariante é uma regra sobre o estado de um objeto que é verdadeira após a construção e após cada operação pública. Um termostato pode permitir temperaturas desejadas de 5 °C a 30 °C. Toda forma de definir essa temperatura deve preservar esse intervalo.

Escolha o que acontece com uma entrada inválida

Três respostas úteis são manter o valor anterior, limitar o valor ao intervalo ou lançar uma exceção. Elas têm efeitos diferentes, portanto escolha uma resposta clara para cada operação.

Para uma idade não negativa de um animal, um método modificador que ignora valores inválidos pode atribuir o valor apenas dentro de if (age >= 0). Se a idade armazenada for 4, setAge(-2) a mantém em 4. Ele não muda a idade para 0.

Coloque as verificações de intervalo dentro da classe

public static final int MIN_CELSIUS = 5;
public static final int MAX_CELSIUS = 30;
private int target;

public void setTarget(int celsius) {
    if (celsius < MIN_CELSIUS) {
        this.target = MIN_CELSIUS;
    } else if (celsius > MAX_CELSIUS) {
        this.target = MAX_CELSIUS;
    } else {
        this.target = celsius;
    }
}

public void raise() {
    setTarget(this.target + 1);
}

Começando em 20 °C, setTarget(35) armazena 30. setTarget(-3) armazena 5. Após setTarget(29), uma chamada a raise() armazena 30; outra chamada mantém o valor em 30. Reutilizar o método modificador impede que raise() ultrapasse o limite superior.

Verificações apenas em Main não podem proteger o termostato. Outro código que o use poderia esquecê-las. A classe deve verificar a entrada no ponto em que controla o armazenamento.

Valide também o estado inicial

public Thermostat(int target) {
    setTarget(target);
}

Com esse construtor que limita o valor ao intervalo, new Thermostat(50) termina em 30 °C. Atribuir this.target = target; diretamente permitiria o estado inicial inválido 50. Um método privado de verificação compartilhado é outra forma de reutilizar a validação em construtores e métodos posteriores.

Lançar uma exceção é útil quando um argumento inválido indica um erro de programação. Por exemplo, um construtor pode rejeitar uma contagem negativa com throw new IllegalArgumentException("count must not be negative");. O objeto não é construído com sucesso, portanto nenhum objeto concluído inválido é entregue ao código que chamou o construtor. Ignorar a entrada é mais simples, mas silencioso; o código que chamou o método pode precisar de outra forma de perceber que nada mudou.

Mantenha os dados internos mutáveis dentro da classe

Uma lista privada ainda pode ser exposta se um método de acesso retornar a lista original. O código que chamou o método poderia então adicionar ou remover entradas sem usar os métodos da classe, contornando uma regra de tamanho máximo.

Para um campo ArrayList<String> chamado tracks, return new ArrayList<>(this.tracks); fornece uma lista separada que contém as mesmas cadeias de caracteres. Alterar a lista retornada não altera a lista interna. Operações como addTrack(String title) podem manter as alterações da lista dentro da classe e verificar suas regras antes de aceitá-las.

Um objeto útil deve ser fácil de inspecionar como texto. O toString() herdado do Java retorna um nome de classe, um sinal @ e um código de dispersão hexadecimal, como Pet@8bcc55f. Um pacote nomeado passa a fazer parte do nome da classe. O texto do código de dispersão varia e geralmente diz pouco sobre o estado do objeto.

Retorne uma descrição legível

@Override
public String toString() {
    return this.name + " (" + this.species + ", "
        + this.age + " years)";
}

Para Luna, uma gata de 3 anos, a cadeia de caracteres retornada é "Luna (cat, 3 years)". O método lê campos e constrói uma cadeia de caracteres. Ele não altera o animal nem envia saída à tela.

@Override pede ao compilador que verifique se a declaração realmente substitui um método existente. Isso detecta erros como escrever tostring com s minúsculo. A anotação não formata o resultado para você; a expressão de retorno determina o texto.

Reconheça chamadas automáticas

System.out.println(luna);
String label = "Pet: " + luna;
String details = luna.toString();

A primeira linha exibe a descrição legível do animal. A segunda constrói "Pet: Luna (cat, 3 years)". A terceira solicita a mesma descrição explicitamente e a armazena sem exibi-la. Quando um ArrayList de animais é exibido, sua representação usa o toString() de cada animal dentro dos colchetes da lista.

A conversão automática explica por que retornar texto é importante. O código que chama o método pode estar exibindo, armazenando ou concatenando o resultado. Um método que apenas exibe não pode fornecer a cadeia de caracteres necessária a todos esses códigos.

Use o cabeçalho correto do método

Use o cabeçalho exato sem argumentos e inclua a anotação. Uma sobrecarga com parâmetros pode ser um método separado válido, mas a exibição de um objeto não fornece esses parâmetros.

Formate valores sem alterá-los

Um relógio precisa de horas e minutos com dois algarismos. Dentro de seu método toString():

return String.format(java.util.Locale.US,
    "%02d:%02d", this.hours, this.minutes);

Para horas 9 e minutos 5, a cadeia de caracteres é "09:05". Cada %02d formata um inteiro em pelo menos duas posições, usando um zero à esquerda quando necessário. String.format(java.util.Locale.US, "%.2f", 7.5) retorna "7.50". Fornecer a configuração regional torna a saída com ponto decimal independente da configuração regional padrão de formatação do computador.

Mantenha a descrição curta o suficiente para ser lida durante a depuração. Ela pode revelar um estado não inicializado: concatenar um campo de nome null a uma cadeia de caracteres produz o texto "null", o que aponta para a inicialização. A descrição deve informar o estado atual, portanto exibir o objeto duas vezes não deve avançar um relógio nem celebrar um aniversário.

Comece pelo que um objeto deve lembrar, pelo que os códigos que o usam podem pedir que ele faça e por quais estados devem ser permitidos. Depois transforme cada parte em campos, construtores e métodos.

Extraia o projeto de uma descrição

“Um livro de biblioteca tem título, autor e número de páginas. Ele pode ser emprestado e devolvido. Ele não pode ser emprestado novamente enquanto já estiver emprestado.”

Use LibraryBook como nome da classe. Armazene os três valores descritivos e um estado de empréstimo booleano. O título, o autor e o número de páginas permanecem fixos, portanto declare-os final. O estado de empréstimo muda por meio de ações com funções claras. Um método modificador para cada campo é desnecessário.

Implemente a classe completa

public class LibraryBook {
    private final String title;
    private final String author;
    private final int pages;
    private boolean lentOut;

    public LibraryBook(String title, String author, int pages) {
        this.title = title;
        this.author = author;
        this.pages = pages;
        this.lentOut = false;
    }

    public boolean isLentOut() {
        return this.lentOut;
    }

    public boolean lend() {
        if (this.lentOut) {
            return false;
        }
        this.lentOut = true;
        return true;
    }

    public void giveBack() {
        this.lentOut = false;
    }

    @Override
    public String toString() {
        String status = this.lentOut ? "lent out" : "available";
        return this.title + " by " + this.author + ", "
            + this.pages + " pages, " + status;
    }
}

O construtor define o livro como disponível. lend() verifica o estado existente antes de alterá-lo; retornar false em um segundo empréstimo preserva a regra. giveBack() torna o livro disponível. O método de acesso informa o estado, e toString() descreve o livro inteiro sem alterá-lo.

Anote os resultados esperados antes de executar as chamadas

No método main clássico de uma classe Main separada:

LibraryBook b = new LibraryBook("Night Train", "A. Rivera", 320);
System.out.println(b);        // Night Train by A. Rivera, 320 pages, available
System.out.println(b.lend()); // true
System.out.println(b.lend()); // false
b.giveBack();
System.out.println(b.lend()); // true

A segunda tentativa de empréstimo é essencial: um método que sempre define a variável sinalizadora e retorna true passaria na primeira chamada, mas falharia nessa verificação. Teste o estado e também os valores de retorno com isLentOut(). Experimente também um segundo livro para verificar se um empréstimo de um livro deixa o outro disponível.

Teste onde o comportamento muda

Cubra cada construtor e método público. Para verificações de intervalo, experimente os dois extremos e valores imediatamente fora deles. Para um relógio, verifique a virada dos minutos e a passagem pela meia-noite. Para um método modificador que rejeita ou ignora entradas inválidas, verifique se elas têm o efeito prometido sobre o estado anterior. Escreva primeiro o resultado esperado para que uma saída inesperada não se torne, sem perceber, sua nova expectativa.

Implemente em pequenos passos: primeiro os campos e o construtor, depois uma descrição legível e, em seguida, uma operação e suas verificações por vez. Salve classes públicas comuns em arquivos com nomes correspondentes, compile-as juntas e execute a classe que contém main. Manter as operações do modelo separadas da saída na tela permite que a mesma classe sirva a diferentes programas.