Java Modificadores de Acesso

Até aqui, qualquer parte do programa podia ler e mudar qualquer atributo: conta.saldo = -1000000; compilava sem reclamar. Os modificadores de acesso são palavras colocadas antes de classes, atributos, métodos e construtores para dizer quem pode usá-los. São quatro níveis: public, protected, o padrão (sem palavra nenhuma) e private.

A ideia antes do código: as portas da escola

A escola da Ana tem lugares com regras de entrada diferentes:

Em Java, o "prédio" é o pacote (uma pasta de classes; veja Pacotes e import), a "família" são as subclasses (veja Herança) e a "diretoria" é a própria classe.

A tabela de visibilidade

Esta é a tabela que todo programador Java consulta. Cada linha é um modificador; cada coluna, um lugar de onde alguém tenta usar o membro (atributo, método ou construtor):

Lida de cima para baixo, a tabela vai do mais aberto ao mais fechado. Na prática, o dia a dia usa quase só os extremos: private para atributos e public para os métodos que formam a "porta de entrada" da classe. O padrão e o protected aparecem em situações específicas.

private: só a própria classe

A Ana marcou o saldo da conta como private. Agora, quem está fora da classe Conta não pode tocar nele:

class Conta {
    String titular;
    private double saldo;
}

public class Main {
    public static void main(String[] args) {
        Conta c = new Conta();
        c.saldo = 1000000;
        System.out.println(c.saldo);
    }
}

$ javac Main.java
Main.java:9: error: saldo has private access in Conta
        c.saldo = 1000000;
         ^
Main.java:10: error: saldo has private access in Conta
        System.out.println(c.saldo);
                            ^
2 errors

"saldo tem acesso privado em Conta". Nem escrever nem ler: o main está em outra classe. Então como alguém deposita ou consulta? Pelos métodos da própria classe, que podem usar o atributo privado à vontade:

class Conta {
    String titular;
    private double saldo;

    void depositar(double valor) {
        if (valor > 0) {
            saldo = saldo + valor;
        }
    }

    double consultarSaldo() {
        return saldo;
    }
}

public class Main {
    public static void main(String[] args) {
        Conta c = new Conta();
        c.titular = "Ana";
        c.depositar(500);
        c.depositar(-1000);
        System.out.println(c.titular + ": " + c.consultarSaldo());
    }
}

$ javac Main.java && java Main
Ana: 500.0          « o depósito negativo foi ignorado pela regra do método

private double saldo;

O modificador vem antes do tipo. Só o código escrito dentro das chaves de class Conta pode usar saldo.

void depositar(double valor)

Está dentro da classe: pode mexer em saldo. E impõe uma regra: só aceita valores positivos.

double consultarSaldo()

Deixa ler o saldo sem deixar mudá-lo.

c.depositar(-1000);

Quem está fora não consegue estragar o saldo: o único caminho passa pela regra.

Esse é o coração do encapsulamento, o primeiro pilar da POO: os dados ficam escondidos e só mudam por métodos que conferem o que está acontecendo. A aula Encapsulamento mostra o padrão completo, com getters e setters.

class Fruta {
    String nome;
    int estoque;
}

public class Main {
    public static void main(String[] args) {
        Fruta f = new Fruta();
        f.nome = "maçã";
        f.estoque = -50;
        System.out.println(f.nome + ": " + f.estoque);
    }
}

class Fruta {
    String nome;
    private int estoque;
}

public class Main {
    public static void main(String[] args) {
        Fruta f = new Fruta();
        f.nome = "maçã";
        f.estoque = -50;
        System.out.println(f.nome + ": " + f.estoque);
    }
}

Métodos private: ajudantes internos

Métodos também podem ser privados. É útil para pedaços de lógica que só fazem sentido dentro da classe, como uma conferência usada por outros métodos:

class Conta {
    private double saldo;
    private double limite = 200;

    boolean sacar(double valor) {
        if (!podeSacar(valor)) {
            System.out.println("Saque de " + valor + " recusado.");
            return false;
        }
        saldo = saldo - valor;
        System.out.println("Saque de " + valor + " feito. Saldo: " + saldo);
        return true;
    }

    private boolean podeSacar(double valor) {
        return valor > 0 && valor <= saldo + limite;
    }
}

public class Main {
    public static void main(String[] args) {
        Conta c = new Conta();
        c.sacar(150);
        c.sacar(100);
    }
}

$ javac Main.java && java Main
Saque de 150.0 feito. Saldo: -150.0     « usou o limite (cheque especial)
Saque de 100.0 recusado.                « passaria de 200 negativos

Se o main tentar chamar o ajudante:

$ javac Main.java
Main.java:25: error: podeSacar(double) has private access in Conta
        c.podeSacar(10);
         ^
1 error

Vantagem: a Ana pode mudar ou apagar podeSacar amanhã sem quebrar nenhuma outra classe, porque ninguém de fora depende dele.

Padrão (de pacote) e public

A diferença entre o acesso padrão e o public só aparece quando há pacotes diferentes. Um pacote é uma pasta de classes com uma declaração package no topo de cada arquivo; você vai estudá-los em Pacotes e import. Para ver os modificadores funcionando, a Ana separou o programa em duas pastas:

modif/
├── banco/
│   └── Conta.java      (package banco;)
└── app/
    └── Main.java       (package app;)

package banco;

public class Conta {
    public String titular;
    double saldo;
    private String senha = "1234";

    public Conta(String titular) {
        this.titular = titular;
    }

    public void depositar(double valor) {
        saldo = saldo + valor;
    }

    public double consultarSaldo() {
        return saldo;
    }
}

package app;

import banco.Conta;

public class Main {
    public static void main(String[] args) {
        Conta c = new Conta("Ana");
        c.depositar(500);
        System.out.println(c.titular + ": " + c.consultarSaldo());
        System.out.println(c.saldo);
        System.out.println(c.senha);
    }
}

$ javac -d out banco/Conta.java app/Main.java
app/Main.java:10: error: saldo is not public in Conta; cannot be accessed from outside package
        System.out.println(c.saldo);
                            ^
app/Main.java:11: error: senha has private access in Conta
        System.out.println(c.senha);
                            ^
2 errors

Tirando as duas linhas proibidas, o programa compila e roda. A opção -d out manda o javac colocar os .class na pasta out, organizados por pacote, e -cp out diz ao java onde procurá-los:

$ javac -d out banco/Conta.java app/Main.java
$ java -cp out app.Main
Ana: 500.0

Repare que a classe Conta e o seu construtor também precisaram de public: sem isso, o pacote app não conseguiria nem enxergar a classe nem criar contas.

E o protected?

protected é o padrão "com um extra": vale para o mesmo pacote e para as subclasses, mesmo em outro pacote. Ele só faz sentido com herança, então fica para a aula Herança (e super). Por enquanto, guarde a posição dele na tabela: entre o padrão e o public.

Modificadores em classes

Uma classe "de primeiro nível" (que não está dentro de outra) só aceita duas opções:

private e protected não fazem sentido para uma classe de primeiro nível (privada de quem?):

$ javac Main.java
Main.java:1: error: modifier private not allowed here
private class Conta {
        ^
1 error

Classes declaradas dentro de outras podem ser privadas; isso aparece em Classes Internas e Anônimas.

Modificadores que não são de acesso

Existem outras palavras que aparecem no mesmo lugar, antes do tipo, mas que não falam de quem acessa, e sim de como a coisa funciona. Cada uma tem a sua aula:

Um membro pode ter um modificador de acesso e vários outros: public static void main, private static final double TAXA = 0.05;. A ordem não muda o significado, mas a convenção é: acesso primeiro, depois static, depois final. Só não dá para usar dois modificadores de acesso juntos:

$ javac Main.java
Main.java:2: error: illegal combination of modifiers: public and private
    public private double saldo;
                          ^
1 error

Qual usar? (regras práticas)

Quando dá errado

$ javac Main.java
Main.java:9: error: saldo has private access in Conta
        c.saldo = 1000000;
         ^

$ javac -d out banco/Conta.java app/Main.java
app/Main.java:10: error: saldo is not public in Conta; cannot be accessed from outside package
        System.out.println(c.saldo);
                            ^

Referência

Missão final: o termômetro protegido

class Termometro {
    double graus;

    public void mostrar() {
        System.out.println("Temperatura: " + graus);
    }
}

public class Main {
    public static void main(String[] args) {
        Termometro t = new Termometro();
        t.ajustar(22.5);
        t.ajustar(-300);
        t.mostrar();
    }
}

class Termometro {
    private double graus;

    public void ajustar(double novo) {
        if (novo < -273.15) {
            System.out.println("Valor recusado: " + novo);
            return;
        }
        graus = novo;
    }

    public void mostrar() {
        System.out.println("Temperatura: " + graus);
    }
}

public class Main {
    public static void main(String[] args) {
        Termometro t = new Termometro();
        t.ajustar(22.5);
        t.ajustar(-300);
        t.mostrar();
    }
}

Exercícios

Resumo

• Modificadores de acesso dizem quem pode usar uma classe, atributo, método ou construtor.
• public: todos. protected: pacote + subclasses. Padrão (nada): só o pacote. private: só a própria classe.
• Regra prática: atributos private, métodos da "porta de entrada" public, ajudantes private.
• Erros: has private access (membro privado usado de fora) e is not public in …; cannot be accessed from outside package (membro padrão usado de outro pacote).
• Classes de primeiro nível: só public ou nada.
• static, final e abstract também são modificadores, mas não de acesso; cada um tem a sua aula.