Classes em Java: definir campos, métodos e objetos

Uma classe é um modelo

Até agora seu código viveu em métodos que passam valores simples de um lado para o outro. Uma classe permite agrupar dados relacionados e o comportamento que opera sobre eles em um único tipo nomeado. A classe é o modelo; as coisas reais com que você trabalha são os objetos criados a partir dela.

Uma classe declara dois tipos de membros: campos (os dados que cada objeto guarda) e métodos (o que cada objeto pode fazer).

class Dog {
    String name;          // um campo: todo Dog tem um nome
    int age;              // outro campo

    void bark() {         // um método: comportamento que todo Dog tem
        System.out.println(name + " says woof!");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog d = new Dog();    // cria um objeto a partir do modelo
        d.name = "Rex";       // define seus campos
        d.age = 3;
        d.bark();             // chama seu método
    }
}

new Dog() cria um objeto na memória e entrega a você uma referência para ele. d.name e d.bark() acessam esse objeto específico.

Cada objeto tem seu próprio estado

O sentido de uma classe é que você pode produzir muitos objetos independentes, cada um carregando seus próprios valores de campo. Alterar um nunca afeta o outro.

class Dog {
    String name;

    void bark() {
        System.out.println(name + " barks");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog rex = new Dog();
        rex.name = "Rex";

        Dog bella = new Dog();
        bella.name = "Bella";

        rex.bark();     // Rex barks
        bella.bark();   // Bella barks
    }
}

rex e bella são dois objetos distintos. Cada um tem seu próprio name, então cada bark() imprime um valor diferente. Esses dados por objeto são chamados de estado de instância.

Campos e métodos trabalham juntos

Os métodos dentro de uma classe podem ler e atualizar diretamente os campos do próprio objeto, sem precisar passá-los como parâmetros. O método já "vive no" objeto cujos dados ele acessa.

class Counter {
    int count;            // começa em 0 por padrão

    void increment() {
        count++;          // atualiza o campo deste objeto
    }

    int value() {
        return count;
    }
}

public class Main {
    public static void main(String[] args) {
        Counter c = new Counter();
        c.increment();
        c.increment();
        c.increment();
        System.out.println(c.value());   // 3
    }
}

Repare que increment() não recebe argumentos. Ele opera sobre o campo que pertence ao Counter no qual você o chamou. Essa é a diferença entre um método de classe e um método estático solto: o método tem um objeto implícito sobre o qual atuar.

A palavra-chave this

Dentro de um método, this é uma referência ao objeto no qual o método foi chamado. Em geral você não precisa dela: escrever count já significa this.count. Mas this se torna essencial quando o nome de um parâmetro colide com o de um campo, o que acontece o tempo todo em setters e construtores.

class Point {
    int x;
    int y;

    void move(int x, int y) {
        this.x = x;       // this.x é o campo; x é o parâmetro
        this.y = y;
    }

    void show() {
        System.out.println("(" + x + ", " + y + ")");
    }
}

public class Main {
    public static void main(String[] args) {
        Point p = new Point();
        p.move(4, 7);
        p.show();         // (4, 7)
    }
}

Um erro comum de iniciante é escrever x = x; dentro de move. Isso apenas atribui o parâmetro a si mesmo e deixa o campo intacto: o compilador não avisará e seu objeto manterá silenciosamente os valores antigos. this.x = x; é o que realmente atualiza o campo.

Valores padrão de campos e referências null

Quando você cria um objeto, seus campos não ficam com lixo: o Java os inicializa com valores padrão: 0 para números, false para boolean e null para referências a objetos como String. Esse valor padrão null é a origem de uma falha clássica.

class User {
    String name;          // não atribuído, então fica null por padrão
}

public class Main {
    public static void main(String[] args) {
        User u = new User();
        System.out.println(u.name.length());   // NullPointerException
    }
}

u.name é null porque ninguém o definiu, então chamar .length() sobre ele lança uma NullPointerException. Sempre atribua valores significativos a um objeto antes de usar seus campos, que é exatamente o problema que os construtores resolvem.

Organizando o código em torno de classes

Programas reais modelam seu domínio como classes que mantêm juntos os dados e as operações sobre eles. Aqui, uma única classe BankAccount guarda um saldo e controla como ele muda:

class BankAccount {
    String owner;
    double balance;

    void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        }
    }

    boolean withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
            return true;
        }
        return false;     // fundos insuficientes
    }
}

public class Main {
    public static void main(String[] args) {
        BankAccount acc = new BankAccount();
        acc.owner = "Sam";
        acc.deposit(100.0);
        boolean ok = acc.withdraw(30.0);

        System.out.println(acc.owner + " balance: " + acc.balance);  // 70.0
        System.out.println("withdrawal succeeded: " + ok);
    }
}

Os dados (balance) e as regras para alterá-los (deposit, withdraw) vivem em um único lugar. O código de outras partes pede à conta para fazer coisas em vez de mexer diretamente em seus números: a base de um design limpo e fácil de manter.

A seguir: construtores

Definir cada campo manualmente depois do new é tedioso e fácil de esquecer e, como você acabou de ver, um campo esquecido deixa um null à espera para causar uma falha. Um construtor permite exigir e inicializar os campos de um objeto no momento exato em que ele é criado, de modo que uma BankAccount nunca possa existir sem um proprietário. É disso que trata a próxima página.