Modificadores de acceso y ámbito de visibilidad

1. Modificadores de acceso principales en C#

Cuando escribes un programa, muchas veces quieres controlar claramente quién y desde dónde puede ver o cambiar tus variables y llamar a tus métodos. Es como en un bloque de pisos: no todas las habitaciones están abiertas para todos. Algunas solo las pueden usar los vecinos, y otras solo los técnicos de mantenimiento.

En programación, este "control de acceso" se resuelve con los modificadores de acceso. Ellos definen si un miembro de clase (variable, campo, método, propiedad, etc.) es visible fuera de la clase, en otra clase, en otro proyecto. Esta es una de las formas principales de encapsulación en la POO: ocultamos los detalles de implementación y solo damos fuera los "interfaces" necesarios.

Aquí tienes una tabla con los modificadores principales y una descripción corta:

public

private

(sin modificador)

¿Parece complicado? En realidad no tiene nada de difícil. Vamos a verlo con ejemplos para entender cuándo usar cada uno.

2. Modificador public — acceso libre

El modificador public hace que tu variable o método sea visible en todas partes. Si declaras un miembro de clase como public, puedes acceder a él desde cualquier otro código que vea tu clase.

public class Person
{
    public string Name;
    public void SayHello()
    {
        Console.WriteLine($"¡Hola! Me llamo {Name}");
    }
}

Ahora, en cualquier parte (en el mismo proyecto o incluso en otros, si añades la referencia a la assembly), puedes escribir:

Person p = new Person();
p.Name = "Alicia";
p.SayHello();

Consejo práctico: no hagas todo public porque sí: es clave para la seguridad del código.

3. Modificador private — ¡esto es propiedad privada!

El modificador private cierra el acceso al contenido de la clase: nadie desde fuera verá lo que hay ni podrá cambiar los datos. Por defecto, todos los campos y métodos de las clases en C# son private, si no pones otro modificador.

public class Cup
{
    private double volume; // Este campo solo lo ve la clase Cup

    public void Fill(double value)
    {
        volume = value; // Se puede usar dentro de la clase
    }

    public double GetVolume()
    {
        return volume; // Pero desde fuera nadie sabe que existe volume
    }
}

Aquí volume está oculto para todos los demás, pero cualquier método dentro de Cup puede usarlo. Para saber el volumen, damos un método público GetVolume().

4. Ámbito de visibilidad: variables, métodos y clases

Ámbito de visibilidad — es la zona del programa donde tu nombre (variable, método, clase) tiene sentido y está accesible.

• Variables locales (declaradas dentro de un método o bloque de código): solo se ven en ese método o bloque.
• Parámetros de métodos: solo se ven dentro del método.
• Campos de clase: se ven en toda la clase (según el modificador de acceso).
• Clases: una clase anidada solo se ve en la clase contenedora si es private, etc.

Vamos a ver un ejemplo de ámbito de visibilidad:

public class Counter
{
    private int count = 0; // visible en toda la clase

    public void Increment()
    {
        count++;   // podemos usar el campo
        int temp = count * 2; // temp solo se ve dentro de Increment
    }

    public int GetCount()
    {
        // ¡aquí temp no se ve!
        return count;
    }
}

Si intentas acceder a temp dentro de GetCount() — te dará error.

5. Shadowing de variables

Shadowing — es cuando en un mismo ámbito declaras una variable (o parámetro) con el mismo nombre que en un ámbito externo. Dentro de ese bloque, el “nuevo” nombre tapa al antiguo, y ya no puedes acceder directamente al valor externo.

Ejemplo de shadowing:

class ShadowDemo
{
    int value = 10; // campo de clase

    void PrintValue()
    {
        Console.WriteLine(value);      // 10 — campo de clase
        int value = 5; // variable local tapa el campo de clase
        Console.WriteLine(value); // muestra 5, no 10
    }
}

En este ejemplo, cuando escribimos int value = 5;, esto tapa el campo de clase con el mismo nombre dentro del método. Al acceder a value dentro de PrintValue(), se usa la variable local, no el campo de clase.

Si de verdad necesitas acceder al campo de clase, usa la palabra clave this:

class ShadowDemo
{
    int value = 10;

    void PrintValue()
    {
        Console.WriteLine(value);      // 10 — campo de clase
        int value = 5;
        Console.WriteLine(value);      // 5 — variable local
        Console.WriteLine(this.value); // 10 — campo de clase
    }
}

El shadowing puede liar bastante, así que es mejor poner nombres claros y diferentes a las variables — sobre todo si curras en equipos grandes.

1

Cuestionario/control

Funciones, nivel 8, lección 5

No disponible

Funciones

Introducción a las funciones

Abrir