Zugriffsmodifikatoren und Sichtbarkeit

1. Die wichtigsten Zugriffsmodifikatoren in C#

Wenn du ein Programm schreibst, willst du oft ganz genau kontrollieren, wer und woher deine Variablen sehen oder ändern und Methoden aufrufen darf. Das ist wie in einem Mehrfamilienhaus: Nicht alle Räume sind für alle offen. Zu manchen haben nur die Bewohner Zugang, zu anderen nur die Handwerker.

In der Programmierung wird diese "Zugriffskontrolle" über Zugriffsmodifikatoren geregelt. Sie bestimmen, ob ein Member einer Klasse (Variable, Feld, Methode, Property usw.) außerhalb der Klasse, in einer anderen Klasse oder in einem anderen Projekt sichtbar ist. Das ist eine der Hauptumsetzungen von Kapselung im OOP: Wir verstecken die Implementierungsdetails und geben nur die nötigen "Interfaces" nach außen frei.

Hier ist eine Tabelle mit den wichtigsten Modifikatoren und einer kurzen Beschreibung:

public

private

(kein Modifikator)

Sieht kompliziert aus? Eigentlich ist das ganz easy. Lass uns an Beispielen anschauen, wann was am besten passt.

2. Modifikator public – jeder darf rein

Der Modifikator public macht deine Variable oder Methode überall sichtbar. Wenn du ein Klassen-Member als public deklarierst, kannst du von jedem anderen Code, der deine Klasse sieht, darauf zugreifen.

public class Person
{
    public string Name;
    public void SayHello()
    {
        Console.WriteLine($"Hallo! Ich heiße {Name}");
    }
}

Jetzt kannst du überall (im selben Projekt oder sogar in anderen, wenn du die Assembly referenzierst) folgendes schreiben:

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

Praktischer Tipp: Mach nicht alles einfach public: Das ist wichtig für die Sicherheit deines Codes.

3. Modifikator private – das ist Privatbesitz!

Der Modifikator private schließt den Zugriff auf den Inhalt der Klasse: Niemand von außen sieht, was da drin ist, und kann die Daten nicht ändern. Standardmäßig sind alle Felder und Methoden von Klassen in C# – private, wenn du keinen anderen Modifikator angibst.

public class Cup
{
    private double volume; // Dieses Feld sieht nur die Klasse Cup selbst

    public void Fill(double value)
    {
        volume = value; // Kann innerhalb der Klasse verwendet werden
    }

    public double GetVolume()
    {
        return volume; // Aber von außen weiß niemand, dass volume existiert
    }
}

Hier ist volume für alle anderen versteckt, aber jede Methode innerhalb von Cup kann es benutzen. Um das Volumen zu erfahren, stellen wir die öffentliche Methode GetVolume() bereit.

4. Sichtbarkeitsbereich: Variablen, Methoden und Klassen

Sichtbarkeitsbereich – das ist der Bereich im Programm, in dem dein Name (Variable, Methode, Klasse) Sinn macht und zugänglich ist.

• Lokale Variablen (innerhalb einer Methode oder eines Codeblocks deklariert): nur in dieser Methode oder diesem Block sichtbar.
• Methodenparameter: nur innerhalb der Methode sichtbar.
• Felder der Klasse: überall innerhalb der Klasse sichtbar (abhängig vom Zugriffsmodifikator).
• Klassen: Eine verschachtelte Klasse ist nur in der äußeren Klasse sichtbar, wenn sie private ist, usw.

Schauen wir uns ein Beispiel zum Sichtbarkeitsbereich an:

public class Counter
{
    private int count = 0; // überall in der Klasse sichtbar

    public void Increment()
    {
        count++;   // wir können das Feld verwenden
        int temp = count * 2; // temp ist nur innerhalb von Increment sichtbar
    }

    public int GetCount()
    {
        // temp ist hier nicht sichtbar!
        return count;
    }
}

Wenn du versuchst, auf temp innerhalb von GetCount() zuzugreifen – bekommst du einen Fehler.

5. Shadowing von Variablen (Shadowing)

Shadowing – das ist die Situation, wenn im selben Sichtbarkeitsbereich eine Variable (oder ein Parameter) mit demselben Namen wie in einem äußeren Bereich deklariert wird. Innerhalb dieses Blocks verdeckt der neue Name den alten, und auf den äußeren Wert kann man nicht mehr direkt zugreifen.

Beispiel für Shadowing:

class ShadowDemo
{
    int value = 10; // Feld der Klasse

    void PrintValue()
    {
        Console.WriteLine(value);      // 10 – Feld der Klasse
        int value = 5; // lokale Variable verdeckt das Feld der Klasse
        Console.WriteLine(value); // gibt 5 aus, nicht 10
    }
}

In diesem Beispiel, wenn wir int value = 5; schreiben, verdeckt das das Feld der Klasse mit demselben Namen innerhalb der Methode. Wenn du innerhalb von PrintValue() auf value zugreifst, wird die lokale Variable verwendet, nicht das Feld der Klasse.

Wenn du trotzdem auf das Feld der Klasse zugreifen willst, benutzt du das Schlüsselwort this:

class ShadowDemo
{
    int value = 10;

    void PrintValue()
    {
        Console.WriteLine(value);      // 10 – Feld der Klasse
        int value = 5;
        Console.WriteLine(value);      // 5 – lokale Variable
        Console.WriteLine(this.value); // 10 – Feld der Klasse
    }
}

Shadowing kann verwirrend sein, deshalb ist es besser, Variablen sinnvolle, unterschiedliche Namen zu geben – besonders wenn du in großen Teams arbeitest.

2

Aufgabe

C# SELF, Level 8, Lektion 5

Gesperrt

Arbeiten mit dem Gültigkeitsbereich von Variablen

Arbeiten mit dem Gültigkeitsbereich von Variablen

Öffnen

2

Aufgabe

C# SELF, Level 8, Lektion 5

Gesperrt

Variablenschatten

Variablenschatten

Öffnen

1

Umfrage/Quiz

Funktionen, Level 8, Lektion 5

Nicht verfügbar

Funktionen

Einführung in Funktionen

Öffnen