Resumo rápido
- Modificadores de acesso dizem quem pode usar cada parte de uma classe.
public: qualquer código pode usar.private: só a própria classe. É o padrão dos membros quando você não escreve nada.protected: a própria classe e as classes filhas (herança).internal: qualquer código do mesmo projeto. É o padrão das classes.- Regra de ouro: comece com
private e abra só o necessário.
Num abrigo de sobreviventes, nem tudo fica à vista. O mapa da cidade está pregado na parede para todos. O diário do líder fica trancado no quarto dele. O depósito de armas, só os membros do grupo acessam. O C# tem a mesma ideia para o código: os modificadores de acesso.
Você já viu public e private nos posts de classes e propriedades. Agora vamos entender todos de uma vez.
Os quatro principais
| Modificador | Quem acessa | No abrigo |
|---|
public | qualquer código, de qualquer lugar | o mapa na parede |
private | só a própria classe | o diário trancado do líder |
protected | a própria classe e as classes filhas | o depósito do grupo |
internal | qualquer código do mesmo projeto (assembly) | a área comum do abrigo |
Existem ainda as combinações protected internal e private protected, usadas em casos bem específicos de bibliotecas. Para começar, os quatro acima resolvem quase tudo.
public e private na prática
C#
Sobrevivente leon = new Sobrevivente("Leon");
leon.ComerRacao();
leon.ComerRacao();
leon.MostrarStatus();
// leon.fome = 0; // erro: 'fome' é private
// leon.CalcularFome(); // erro: método private
class Sobrevivente
{
public string Nome; // todo mundo pode ver
private int fome = 8; // só a classe mexe
public Sobrevivente(string nome)
{
Nome = nome;
}
public void ComerRacao()
{
fome = CalcularFome(fome, 3);
Console.WriteLine($"{Nome} comeu. Fome: {fome}");
}
public void MostrarStatus()
{
Console.WriteLine(fome == 0 ? $"{Nome} está satisfeito." : $"{Nome} ainda tem fome.");
}
private int CalcularFome(int atual, int alimento)
{
return Math.Max(atual - alimento, 0);
}
}
Saída esperada
Leon comeu. Fome: 5
Leon comeu. Fome: 2
Leon ainda tem fome.
De fora, só dá para usar o que é public: Nome, ComerRacao e MostrarStatus. O campo fome e o método auxiliar CalcularFome são detalhes internos. Se você descomentar as duas últimas linhas do topo, o código não compila.
Isso é ótimo: amanhã você pode mudar a forma de calcular a fome sem quebrar nenhum código que usa a classe, porque ninguém de fora dependia dela.
O padrão quando você não escreve nada
| Onde | Sem modificador vira |
|---|
| campo, método ou propriedade dentro de uma classe | private |
| classe declarada direto no arquivo | internal |
C#
class Arma // internal
{
int dano = 10; // private
void Recarregar() { } // private
}
Por isso o erro mais comum de quem está começando é criar um campo sem public e não conseguir usar fora da classe. Mesmo assim, escrever o modificador sempre deixa a intenção clara para quem lê.
protected: herança no grupo
Uma classe pode herdar de outra com :, ganhando tudo o que a classe mãe tem. O protected deixa um membro escondido de fora, mas visível para as classes filhas:
C#
Soldado jill = new Soldado();
jill.Treinar();
jill.MostrarVida();
// jill.vida = 999; // erro: protected não é visível aqui fora
class Personagem
{
protected int vida = 100;
public void MostrarVida()
{
Console.WriteLine($"Vida: {vida}");
}
}
class Soldado : Personagem
{
public void Treinar()
{
vida += 20; // a filha pode usar o protected
Console.WriteLine("Treino concluído: +20 de vida.");
}
}
Saída esperada
Treino concluído: +20 de vida.
Vida: 120
Soldado : Personagem quer dizer "Soldado é um Personagem". Ele herda vida e MostrarVida, e como vida é protected, o Treinar pode mexer nela. O código lá de fora, não.
internal: dentro do mesmo projeto
Um projeto C# compilado vira um assembly (um .exe ou .dll). Algo internal é visível para tudo dentro desse projeto e invisível para outros projetos que usem a sua DLL.
No dia a dia de um projeto só, internal e public se comportam igual. A diferença aparece quando você cria uma biblioteca: o que for public vira a "vitrine" que os outros projetos enxergam, e o resto fica internal.
Como escolher
| Pergunta | Se sim |
|---|
| Só a própria classe precisa disso? | private (comece sempre por aqui) |
| As classes filhas precisam, mas o resto não? | protected |
| Outras classes do projeto precisam? | public ou internal |
| Outros projetos vão usar? | public |
💡 Campos privados, propriedades públicas
O padrão em C# é deixar os campos private e expor os dados por propriedades public. Assim a classe controla o que entra, como você viu no post de propriedades.
Erros comuns
1. Tudo public. Funciona até alguém fazer jogador.vida = -1 em outro canto do código. Abra só o necessário.
2. Esquecer que o padrão é private. Erro "inacessível devido ao seu nível de proteção" quase sempre é um membro sem public.
3. Usar protected sem herança. Se nenhuma classe herda da sua, protected se comporta igual a private. Prefira private.
DESAFIO
Tente resolver antes de abrir a resposta. Sobreviveu? Vá para o próximo.
Um campo declarado como int municao; dentro de uma classe, sem modificador, é public ou private?
Ver resposta
private. Membros de classe sem modificador são privados.
Na classe Personagem, vida é protected. Quem consegue mexer nela: a classe Soldado : Personagem, o código do Main, ou os dois?
Ver resposta
Só a classe Soldado (e o próprio Personagem). O código de fora, como o Main, não enxerga membros protected.
Reescreva public int Balas; para que todo mundo possa ler as balas, mas só a própria classe possa mudar.
Ver resposta
public int Balas { get; private set; }
Conclusão
Modificadores de acesso são as portas e trancas do seu código. Com private por padrão e public só no que precisa ser usado de fora, cada classe protege os próprios dados e o resto do jogo não depende dos detalhes internos dela.
Com isso você fecha a trilha básica: variáveis, entrada e saída, operadores, decisões, laços, arrays, métodos, classes, propriedades e acesso. Já dá para montar um jogo de sobrevivência inteiro no console.
📖 Volte ao começo da série: Variáveis em C#.
Comentários
Postar um comentário