Java Atributos

Os atributos são as variáveis que moram dentro de um objeto: o nome e o preço de uma fruta, o titular e o saldo de uma conta. Eles guardam o estado do objeto. Nesta aula você aprende a declará-los, a ler e mudar os seus valores e, principalmente, a entender que cada objeto tem os seus.

A ideia antes do código: os campos da ficha

Volte à ficha de matrícula da aula O que é POO. Os campos impressos na ficha ("Nome: ____", "Turma: ____") são os atributos: todas as fichas têm os mesmos campos. O que cada aluno escreve neles é o valor do atributo, e muda de ficha para ficha. Apagar e reescrever a turma na ficha do Bruno não muda a ficha da Carla.

Em Java, os atributos também são chamados de campos (fields, no inglês da documentação) ou variáveis de instância. São três nomes para a mesma coisa.

Declarar atributos

class Fruta {
    String nome;
    double preco;
    int estoque = 10;
}

String nome;

Um atributo: tipo + nome, como qualquer variável. Fica dentro da classe e fora de qualquer método.

double preco;

Outro atributo. Sem valor escrito: começa com o valor padrão do tipo (veja abaixo).

int estoque = 10;

Um atributo com valor inicial. Toda fruta criada começa com estoque 10.

(sem static)

Atributos de objeto não levam static. Com static, a variável passa a ser da classe, uma só para todos (veja a exceção).

Para os nomes, valem as regras de Variáveis: começam com minúscula, camelCase (precoDeCusto, emPromocao), substantivos que dizem o que guardam. O tipo pode ser qualquer um: primitivos, String, arrays ou outras classes.

Valores padrão

Quando um objeto é criado com new, o Java preenche cada atributo sem valor inicial com um valor padrão, que depende do tipo:

class Produto {
    String nome;
    int estoque;
    double preco;
    boolean emPromocao;
    char categoria;
}

public class Main {
    public static void main(String[] args) {
        Produto p = new Produto();
        System.out.println("nome = " + p.nome);
        System.out.println("estoque = " + p.estoque);
        System.out.println("preco = " + p.preco);
        System.out.println("emPromocao = " + p.emPromocao);
        System.out.println("categoria = [" + p.categoria + "]");
        System.out.println("código da categoria = " + (int) p.categoria);
    }
}

$ javac Main.java && java Main
nome = null
estoque = 0
preco = 0.0
emPromocao = false
categoria = []                « entre os colchetes há um caractere invisível, o de código 0
código da categoria = 0

Ler e mudar: objeto.campo

Do lado de fora da classe, você chega a um atributo pelo nome do objeto, um ponto e o nome do atributo. Ele funciona como uma variável comum: pode ser lido, recebe valores e entra em contas.

class Fruta {
    String nome;
    double preco;
    int estoque = 10;
}

public class Main {
    public static void main(String[] args) {
        Fruta maca = new Fruta();
        maca.nome = "maçã";
        maca.preco = 7.9;
        System.out.println(maca.nome + ": R$ " + maca.preco + ", estoque " + maca.estoque);

        maca.estoque = maca.estoque - 3;
        maca.preco *= 0.9;
        maca.estoque++;
        System.out.println(maca.nome + ": R$ " + maca.preco + ", estoque " + maca.estoque);
    }
}

$ javac Main.java && java Main
maçã: R$ 7.9, estoque 10
maçã: R$ 7.11, estoque 8

Cada objeto tem os seus

Esta é a ideia central da aula. A Ana e o Bruno abriram contas no banco. A classe Conta é a mesma; os saldos, não:

class Conta {
    String titular;
    double saldo;
}

public class Main {
    public static void main(String[] args) {
        Conta daAna = new Conta();
        daAna.titular = "Ana";
        Conta doBruno = new Conta();
        doBruno.titular = "Bruno";

        daAna.saldo = daAna.saldo + 500;
        doBruno.saldo = doBruno.saldo + 80;
        daAna.saldo = daAna.saldo - 120;

        System.out.println(daAna.titular + ": " + daAna.saldo);
        System.out.println(doBruno.titular + ": " + doBruno.saldo);
    }
}

$ javac Main.java && java Main
Ana: 380.0         « 0 + 500 - 120
Bruno: 80.0        « 0 + 80: o saque da Ana não mexeu aqui

Cada new Conta() reservou um espaço novo na memória com um titular e um saldo. São duas "caixinhas" saldo diferentes, uma em cada objeto. O daAna.saldo e o doBruno.saldo têm o mesmo nome de atributo, mas moram em objetos diferentes, como duas fichas com o campo "Turma".

class Conta {
    String titular;
    double saldo;
}

public class Main {
    public static void main(String[] args) {
        Conta daAna = new Conta();
        daAna.titular = "Ana";
        daAna.saldo = 380;
        Conta doBruno = new Conta();
        doBruno.titular = "Bruno";
        doBruno.saldo = 80;

        // faça as operações aqui

        System.out.println(daAna.titular + ": " + daAna.saldo);
        System.out.println(doBruno.titular + ": " + doBruno.saldo);
    }
}

class Conta {
    String titular;
    double saldo;
}

public class Main {
    public static void main(String[] args) {
        Conta daAna = new Conta();
        daAna.titular = "Ana";
        daAna.saldo = 380;
        Conta doBruno = new Conta();
        doBruno.titular = "Bruno";
        doBruno.saldo = 80;

        daAna.saldo += 100;
        daAna.saldo -= 30;
        doBruno.saldo -= 60;

        System.out.println(daAna.titular + ": " + daAna.saldo);
        System.out.println(doBruno.titular + ": " + doBruno.saldo);
    }
}

A exceção: atributos static

Um atributo declarado com static não pertence a cada objeto, e sim à classe: existe uma cópia só, compartilhada por todos. É usado com o nome da classe, e não de um objeto:

class Fruta {
    static int criadas = 0;
    String nome;
}

public class Main {
    public static void main(String[] args) {
        Fruta a = new Fruta();
        a.nome = "maçã";
        Fruta.criadas++;
        Fruta b = new Fruta();
        b.nome = "uva";
        Fruta.criadas++;
        System.out.println(a.nome + " e " + b.nome + ": cada uma tem o seu nome");
        System.out.println("criadas = " + Fruta.criadas + " (um só contador, da classe)");
    }
}

$ javac Main.java && java Main
maçã e uva: cada uma tem o seu nome
criadas = 2 (um só contador, da classe)

É o mural do corredor da aula Escopo. Quando usar e como, você verá na aula static. Por enquanto, a regra: atributo sem static = um por objeto.

Atributos que são outros objetos

Um atributo pode ter como tipo outra classe sua. A loja da Ana compra frutas de fornecedores, e cada fruta guarda quem a fornece:

class Fornecedor {
    String nome;
    String cidade;
}

class Fruta {
    String nome;
    double preco;
    Fornecedor fornecedor;
}

public class Main {
    public static void main(String[] args) {
        Fornecedor sitio = new Fornecedor();
        sitio.nome = "Sítio Boa Vista";
        sitio.cidade = "Campinas";

        Fruta maca = new Fruta();
        maca.nome = "maçã";
        maca.fornecedor = sitio;

        Fruta pera = new Fruta();
        pera.nome = "pera";
        pera.fornecedor = sitio;

        System.out.println(maca.nome + " vem de " + maca.fornecedor.cidade);
        sitio.cidade = "Jundiaí";
        System.out.println(pera.nome + " vem de " + pera.fornecedor.cidade);
        System.out.println(maca.nome + " vem de " + maca.fornecedor.cidade);
    }
}

$ javac Main.java && java Main
maçã vem de Campinas
pera vem de Jundiaí       « o sítio mudou de cidade…
maçã vem de Jundiaí       « …e as duas frutas "veem" a mudança

Fornecedor fornecedor;

Um atributo cujo tipo é a classe Fornecedor. Como todo atributo de tipo classe, começa valendo null.

maca.fornecedor = sitio;

Guarda no atributo a referência para o objeto sitio (veja Classes e Objetos). A pera recebe a mesma referência: as duas frutas apontam para o mesmo fornecedor.

maca.fornecedor.cidade

Pontos encadeados: "a cidade do fornecedor da maçã". Leia da esquerda para a direita.

Se a Ana esquecer de ligar o fornecedor, o atributo continua null, e o segundo ponto falha:

$ javac Main.java && java Main
Fornecedor: null
Exception in thread "main" java.lang.NullPointerException: Cannot read field "cidade" because "<local1>.fornecedor" is null
	at Main.main(Main.java:17)

A mensagem aponta o culpado com precisão: "<local1>.fornecedor", o atributo fornecedor da variável local 1 (a maca), era nulo quando o programa tentou ler a cidade.

Formas diferentes de dar valor aos atributos

Quando dá errado

$ javac Main.java
Main.java:9: error: cannot find symbol
        maca.preso = 7.9;
            ^
  symbol:   variable preso
  location: variable maca of type Fruta
1 error

$ javac Main.java
Main.java:9: error: incompatible types: String cannot be converted to double
        maca.preco = "7,90";
                     ^
1 error

$ java Main
Fornecedor: null
Exception in thread "main" java.lang.NullPointerException: Cannot read field "cidade" because "<local1>.fornecedor" is null
	at Main.main(Main.java:17)

Referência

Missão final: dois contadores

// declare a classe Catraca aqui

public class Main {
    public static void main(String[] args) {

    }
}

class Catraca {
    int pessoas;
}

public class Main {
    public static void main(String[] args) {
        Catraca a = new Catraca();
        Catraca b = new Catraca();
        a.pessoas++;
        a.pessoas++;
        a.pessoas++;
        b.pessoas++;
        System.out.println("catraca A: " + a.pessoas);
        System.out.println("catraca B: " + b.pessoas);
    }
}

Exercícios

Resumo

• Atributos (campos, variáveis de instância) são declarados na classe, fora dos métodos, e guardam o estado de cada objeto.
• Sem valor inicial, recebem o padrão: 0, 0.0, false, '\u0000' ou null. Variáveis locais não têm padrão.
• De fora, use objeto.campo para ler e mudar; operadores como += e ++ funcionam.
• Cada objeto tem os seus atributos: mudar daAna.saldo não muda doBruno.saldo. Só os static são compartilhados.
• Atributos de tipo classe guardam referências; vários objetos podem apontar para o mesmo. Atenção ao null no meio de a.b.c.
• Próximos passos: métodos que usam os atributos (Métodos de Objeto) e construtores que os preenchem (Construtores).