Dentro de una clase, cualquier función miembro puede acceder directamente a todos los demás miembros de la misma clase por su nombre.
Los modificadores de acceso son prefijos opcionales en las declaraciones de miembros. Determinan si otro código del programa puede acceder al miembro y se escriben antes del tipo o el nombre del método.
Campos
modificador-de-acceso tipo nombreCampoMétodos
modificador-de-acceso tipo-retorno nombreMetodo()
{
...cuerpo del método
}Cinco niveles de acceso
privateprivadopublicpúblicoprotectedprotegidointernalinternoprotected internalprotegido interno
Por ahora, el lector solo debe aprender private y public. El resto se verá en lecciones posteriores.
Todos los miembros son accesibles desde el interior de la clase, independientemente del modificador que tengan.
Veamos un ejemplo
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();
}
}Lenguaje del código: C# (cs)
En el ejemplo anterior observamos que tanto el método público SayHello, los métodos privados AgeUpdate y SayHi, el campo privado age y el campo público name pueden accederse mutuamente siempre que el código esté dentro de la clase.
Importante: evita las llamadas mutuas, ya que generan bucles infinitos. Por ejemplo:
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();
}
}Lenguaje del código: C# (cs)Aquí SayHi llama a SayHello y SayHello vuelve a llamar a SayHi. Estas llamadas cruzadas provocan recursión infinita.
Esto hará que el programa se bloquee
Aparecerá un error de desbordamiento de memoria
Además, no puedes invocar métodos normales directamente al inicializar campos, a menos que el método sea estático. Los métodos de instancia necesitan un objeto para ser llamados.
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();
}
}Lenguaje del código: C# (cs)Como se ve en la imagen, si convertimos el método en estático es válido. Ten cuidado: si el valor que devuelve GetInt cambia al asignárselo a 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");
}
}Lenguaje del código: C# (cs)En este código, GetInt devuelve los segundos actuales. Dentro de Main, un bucle for ejecuta cien veces la función que imprime la edad, con una pausa de un segundo tras cada impresión. Observaremos lo siguiente:
El valor de los segundos que se imprime siempre es el obtenido en el momento de la inicialización. Cuando se asigna age, GetInt se ejecuta una única vez. Si el valor es 45, age mantendrá permanentemente ese número sin importar cuántas veces lo imprimamos. Como comentamos en la sección anterior, el valor inicial de un campo debe quedar definido en el momento de inicializarlo.
Volvamos a los modificadores de acceso
En resumen: dentro de la clase se puede acceder a todos sus miembros, independientemente del modificador de acceso.
private – Acceso privado
Los miembros privados solo pueden accederse desde la clase donde se declaran. Ninguna otra clase puede leerlos ni modificarlos.
El nivel de acceso por defecto de los miembros de clase es private. Omitir el modificador es equivalente a escribir explícitamente private; ambas formas tienen el mismo significado.
int MyInt1; // privado implícito (por defecto)
private int MyInt2; // privado explícitoLenguaje del código: C# (cs)public – Acceso público
Los miembros públicos de instancia pueden ser accedidos por cualquier otro objeto del programa. Debes añadir manualmente el modificador public para declararlos.
public int MyInt; // marcado con el modificador publicLenguaje del código: C# (cs)Reglas de visibilidad de miembros
Se usan diagramas de clases para representar la estructura de clases
La clase completa se dibuja como un recuadro, los miembros son zonas internas;
Miembros private: completamente contenidos dentro del recuadro de la clase, invisibles desde fuera;
Miembros public: una parte del elemento sale fuera del recuadro, indicando acceso global.
class Program
{
int Member1; // private implícito
private int Member2; // private explícito
public int Member3; // public
}Lenguaje del código: C# (cs)
Ejemplo de este 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
{
...
}
}Lenguaje del código: C# (cs)- Miembros privados (F1, F2, DoCalc()): solo el código dentro de la clase
C1puede leer, escribir e invocarlos; las clases externas no los ven; - Miembros públicos (F3, GetVal()): accesibles sin restricciones desde cualquier otra clase u objeto del programa;
- Regla interna de clase: todos los métodos de
C1, sean públicos o privados, pueden acceder a todos los campos y métodos de la misma clase.
Ejemplo ejecutable
class Program
{
static void Main(string[] args)
{
Worker worker = new Worker();
Console.WriteLine(worker.GetHours()); // Válido, se accede al miembro público GetHours fuera de la clase
Console.WriteLine(worker.ReadSavings());//Error: no se puede acceder al miembro privado ReadSavings fuera de la clase, incluso con worker.
Console.WriteLine(worker.hours); // Válido, acceso al campo público hours fuera de la clase
Console.WriteLine(worker.savings); //Error: no se puede acceder al campo privado savings desde fuera
Console.WriteLine(worker.age); //Error: no se puede acceder al campo privado age desde fuera
}
}
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;
}
}Lenguaje del código: C# (cs)
Ahora deberías tener una idea básica sobre los modificadores de acceso.
Modificadores de acceso