Dentro de uma classe, qualquer função membro consegue acessar diretamente todos os outros membros da mesma classe apenas pelo nome.
Modificadores de acesso são prefixos opcionais usados na declaração de membros. Eles definem se outras partes do código do programa conseguem acessar aquele membro, e são escritos antes do tipo ou do nome do método.
Campos
modificador-de-acesso tipo nomeCampoMétodos
modificador-de-acesso tipo-retorno nomeMetodo()
{
...corpo do método
}Code language: JavaScript (javascript)Cinco níveis de permissão de acesso
privateprivadopublicpúblicoprotectedprotegidointernalinternoprotected internalprotegido interno
Por enquanto, o leitor só precisa estudar private e public. Os demais serão explicados nas aulas seguintes.
Todos os membros podem ser acessados dentro da classe, independente do modificador utilizado.
Veja um exemplo prático
class Robot
{
public string name;
int age;
public void SayHello()
{
Console.WriteLine($"Hello everyone my name is {name},I come from Foxdevelop.com");
Console.WriteLine($"I am {age} years old");
}
void AgeUpdate()
{
age = age+1;
}
void SayHi()
{
SayHello();
}
}Code language: C# (cs)
No exemplo acima, perceba que tanto o método público SayHello, os métodos privados AgeUpdate e SayHi, o campo privado age e o campo público name podem ser acessados mutuamente, desde que o código esteja dentro da classe.
Atenção: evite criar chamadas recíprocas, pois isso causa recursão infinita. Veja o exemplo:
class Robot
{
public string name;
int age;
public void SayHello()
{
Console.WriteLine($"Hello everyone my name is {name},I come from Foxdevelop.com");
Console.WriteLine($"I am {age} years old");
SayHi();
}
void AgeUpdate()
{
age = age+1;
}
void SayHi()
{
SayHello();
}
}Code language: C# (cs)Nesse trecho, SayHi chama SayHello, e SayHello chama novamente SayHi. Essas chamadas cruzadas geram um loop infinito.
Isso fará com que o programa pare de funcionar abruptamente
A mensagem de erro de estouro de memória será exibida
Além disso, não é possível chamar métodos comuns diretamente na inicialização de campos, a menos que o método seja estático. Métodos de instância só podem ser invocados por meio de uma instância de objeto.
class Robot
{
public string name;
int age = GetInt();
static int GetInt()
{
return 1;
}
public void SayHello()
{
Console.WriteLine($"Hello everyone my name is {name},I come from Foxdevelop.com");
Console.WriteLine($"I am {age} years old");
}
void AgeUpdate()
{
age = age+1;
}
void SayHi()
{
SayHello();
}
}Code language: C# (cs)Conforme a imagem, basta transformar o método em estático para funcionar. Mas fique atento: se o valor retornado por GetInt variar no momento da atribuição da variável age
class Program
{
static void Main(string[] args)
{
Robot robot1 = new Robot();
for (int i = 0; i < 100; i++)
{
robot1.WriteAge();
System.Threading.Thread.Sleep(1000);
}
}
}
class Robot
{
public string name;
int age = GetInt();
static int GetInt()
{
return DateTime.Now.Second;
}
public void WriteAge()
{
Console.WriteLine($"I am {age} years old");
}
}Code language: C# (cs)No código acima, GetInt retorna os segundos atuais do relógio. Dentro do Main, um laço for executa cem vezes a função que imprime a idade, com uma pausa de um segundo após cada exibição. Ao executar, notamos o seguinte:
O valor dos segundos exibido permanece o mesmo valor capturado no momento da inicialização. Ao definir age, a função GetInt é executada apenas uma vez. Se o valor obtido for 45, por exemplo, age permanecerá fixo em 45, não importa quantas vezes seja impresso. Como comentado na seção anterior, o valor inicial de um campo precisa estar definido no momento da inicialização.
Agora vamos retornar ao assunto dos modificadores de acesso
Resumindo: dentro da classe, todos os membros são acessíveis, independente do modificador de acesso usado.
private – Acesso privado
Membros privados só podem ser acessados dentro da classe onde foram declarados. Nenhuma outra classe consegue ler ou alterá-los.
O nível de acesso padrão dos membros de classe é private. Omitir o modificador tem o mesmo efeito de escrever private de forma explícita; ambas as formas possuem o mesmo significado.
int MyInt1; // privado implícito (padrão)
private int MyInt2; // privado explícitoCode language: C# (cs)public – Acesso público
Membros públicos de instância podem ser acessados por qualquer outro objeto no programa. Você precisa adicionar manualmente o modificador public na declaração.
public int MyInt; // marcado com o modificador publicCode language: C# (cs)Regras de visibilidade dos membros
Usamos frequentemente diagramas de classes para representar a estrutura das classes
A classe inteira é representada por um quadrado, e os membros são áreas internas dentro desse quadrado;
Membros private: totalmente contidos dentro do quadrado da classe, invisíveis externamente;
Membros public: parte do elemento se estende para fora do quadrado da classe, indicando acesso global.
class Program
{
int Member1; // private implícito
private int Member2; // private explícito
public int Member3; // public
}Code language: C# (cs)
Exemplo usado neste capítulo
class C1
{
int F1; // campo privado implícito
private int F2; // campo privado explícito
public int F3; // campo público
void DoCalc() // método privado implícito
{
...
}
public int GetVal() // método público
{
...
}
}Code language: C# (cs)- Membros privados (F1, F2, DoCalc()): apenas o código dentro da classe
C1consegue ler, gravar e invocá-los; classes externas não conseguem visualizá-los; - Membros públicos (F3, GetVal()): acessíveis sem restrições por qualquer outra classe ou objeto do programa;
- Regra interna da classe: todos os métodos da própria
C1, sejam públicos ou privados, conseguem acessar todos os campos e métodos da mesma classe.
Exemplo executável
class Program
{
static void Main(string[] args)
{
Worker worker = new Worker();
Console.WriteLine(worker.GetHours()); // Válido: membro público GetHours acessível fora da classe
Console.WriteLine(worker.ReadSavings());//Erro: não é possível acessar o membro privado ReadSavings fora da classe, mesmo usando a instância worker.
Console.WriteLine(worker.hours); // Válido: campo público hours acessível fora da classe
Console.WriteLine(worker.savings); //Erro: não é possível acessar o campo privado savings fora da classe
Console.WriteLine(worker.age); //Erro: não é possível acessar o campo privado age fora da classe
}
}
class Worker
{
int age; // campo privado implícito
private double savings; // campo privado explícito
public int hours; // campo público
void ReadSavings() // método privado implícito
{
Console.WriteLine(savings);
}
public int GetHours() // método público
{
return hours;
}
}Code language: C# (cs)
Agora você já deve ter uma compreensão básica sobre os modificadores de acesso.
Modificadores de acesso