Zugriffsmodifikatoren

Innerhalb einer Klasse kann jede Mitgliedsfunktion über den Namen direkt auf alle anderen Mitglieder derselben Klasse zugreifen.

Zugriffsmodifikatoren sind optionale Präfixe bei Mitgliedsdeklarationen. Sie legen fest, ob anderer Programmcode auf das betreffende Mitglied zugreifen darf und werden vor Typ oder Methodenname geschrieben.

Felder

Zugriffsmodifikator Typ Feldname

Methoden

Zugriffsmodifikator Rückgabetyp Methodenname()
{
    ...Methodenrumpf
}

Fünf Zugriffsebenen

1. private privat
2. public öffentlich
3. protected geschützt
4. internal intern
5. protected internal geschützt intern

Leser sollten zunächst nur private und public erlernen. Die übrigen Ebenen werden in späteren Lektionen behandelt.

Innerhalb der Klasse können sämtliche Mitglieder unabhängig vom Modifikator aufeinander zugreifen.

Sehen Sie sich dieses Beispiel an

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-Sprache: C# (cs)

Aus dem Beispiel geht hervor: Sowohl die öffentliche Methode SayHello, die privaten Methoden AgeUpdate und SayHi, das private Feld age als auch das öffentliche Feld name können gegenseitig aufgerufen werden, solange sich der Code innerhalb der Klasse befindet.

Achtung: Vermeiden Sie gegenseitige Aufrufe, da diese eine Endlosschleife erzeugen. Zum Beispiel:

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-Sprache: C# (cs)

Hier ruft SayHi die Methode SayHello auf, und SayHello ruft wiederum SayHi auf. Gegenseitige Aufrufe führen zu einer endlosen Rekursion.

Das Programm stürzt daraufhin ab

Es wird ein Speicherüberlauf gemeldet

Zudem können Sie bei der Feldinitialisierung keine normalen Methoden direkt aufrufen – nur statische Methoden. Instanzmethoden benötigen zum Aufruf ein Objekt.

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-Sprache: C# (cs)

Wie im Bild ersichtlich funktioniert es, wenn Sie die Methode statisch deklarieren. Beachten Sie aber: Wenn der Rückgabewert von GetInt bei der Zuweisung an age variabel ist

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-Sprache: C# (cs)

In diesem Code gibt GetInt die aktuelle Sekunde der Uhrzeit zurück. Innerhalb von Main wird eine Schleife 100-mal ausgeführt, um das Alter auszugeben. Nach jeder Ausgabe wartet das Programm eine Sekunde. Dabei stellen wir Folgendes fest:

Die ausgegebene Sekunde bleibt immer der Wert aus dem Initialisierungszeitpunkt. Beim Festlegen von age wird GetInt einmal aufgerufen. Beträgt der Wert beispielsweise 45, behält age dauerhaft diesen Wert, egal wie oft Sie ihn ausgeben. Wie im vorherigen Abschnitt erläutert, muss der Anfangswert eines Feldes zum Initialisierungszeitpunkt feststehen.

Kehren wir nun zu den Zugriffsmodifikatoren zurück

Zusammenfassend: Innerhalb einer Klasse können alle Mitglieder unabhängig von ihrem Zugriffsmodifikator aufgerufen werden.

private – Privater Zugriff

Private Mitglieder sind nur innerhalb der Klasse zugänglich, in der sie deklariert wurden. Keine andere Klasse kann sie lesen oder verändern.

Der Standardzugriff für Klassenmitglieder ist private. Wenn Sie den Modifikator weglassen, ist es identisch mit der expliziten Angabe von private; beide Schreibweisen haben dieselbe Bedeutung.

int MyInt1;              // implizit privat (Standard)
private int MyInt2;      // explizit privatCode-Sprache: C# (cs)

public – Öffentlicher Zugriff

Öffentliche Instanzmitglieder können von allen Objekten im Programm aufgerufen werden. Sie müssen den Modifikator public manuell zur Deklaration hinzufügen.

public int MyInt;        // markiert mit dem public-ZugriffsmodifikatorCode-Sprache: C# (cs)

Regeln zur Sichtbarkeit von Mitgliedern

Zur Beschreibung von Klassen werden häufig Klassendiagramme verwendet

Die gesamte Klasse wird als Rechteck gezeichnet, Mitglieder sind Bereiche innerhalb dieses Rechtecks;

private-Mitglieder: vollständig innerhalb des Klassenrahmens verborgen, von außen nicht sichtbar;

public-Mitglieder: Teile ragen über den Klassenrahmen hinaus und zeigen an, dass sie global zugänglich sind.

class Program
{
    int Member1;         // implizit private
    private int Member2; // explizit private
    public int Member3;  // public
}Code-Sprache: C# (cs)

Beispiel aus diesem Kapitel

class C1
{
    int F1;                // implizit privates Feld
    private int F2;        // explizit privates Feld
    public int F3;         // öffentliches Feld

    void DoCalc()          // implizit private Methode
    {
        ...
    }

    public int GetVal()    // öffentliche Methode
    {
        ...
    }
}Code-Sprache: C# (cs)

1. Private Mitglieder (F1, F2, DoCalc()): Nur Code innerhalb der Klasse C1 kann lesen, schreiben und aufrufen; externe Klassen sehen diese Mitglieder überhaupt nicht;
2. Öffentliche Mitglieder (F3, GetVal()): Jede andere Klasse oder jedes Objekt im Programm kann uneingeschränkt darauf zugreifen;
3. Regel innerhalb der Klasse: Alle Methoden von C1 – gleich ob öffentlich oder privat – können sämtliche Felder und Methoden derselben Klasse aufrufen.

Laufbares Beispiel

class Program
{
    static void Main(string[] args)
    {
        Worker worker = new Worker();
        Console.WriteLine(worker.GetHours()); // Zulässig: Öffentliches Mitglied GetHours ist außerhalb der Klasse erreichbar
        Console.WriteLine(worker.ReadSavings());//Fehler: Privates Mitglied ReadSavings ist außerhalb nicht zugänglich, auch nicht über worker.

        Console.WriteLine(worker.hours); // Zulässig: Öffentliches Feld hours ist außerhalb erreichbar
        Console.WriteLine(worker.savings); //Fehler: Privates Feld savings ist außerhalb nicht zugänglich
        Console.WriteLine(worker.age); //Fehler: Privates Feld age ist außerhalb nicht zugänglich
    }
}

class Worker
{
    int age;                // implizit privates Feld
    private double savings;        // explizit privates Feld
    public int hours;         // öffentliches Feld

    void ReadSavings()          // implizit private Methode
    {
        Console.WriteLine(savings);
    }

    public int GetHours()    // öffentliche Methode
    {
        return hours;
    }
}Code-Sprache: C# (cs)

Sie sollten nun ein grundlegendes Verständnis der Zugriffsmodifikatoren haben.

Zugriffsmodifikatoren