Arbeiten mit .NET: Grundlagen der OOP/ Zugriffsrechte

Regal: Programmierung Grundlagen der OOP

Lesetipp: Kein normaler Mensch kann sich all diese vielen Begriffe auf Anhieb merken. Deshalb reicht es uns fürs Erste, wenn wir wissen, wie die Zugriffsmodifizierer public und private funktionieren und ahnen, dass es auch noch const und static gibt. Erst bei der Vererbung werden wir uns mit abstract, override und sealed beschäftigen. Die anderen Modifizierer auf der Seite Noch mehr Modifizierer sind erst sehr viel später für die Komponenten- und Bibliotheksentwicklung interessant.

Modifizierer, oder auch Modifikatoren, geben uns die Möglichkeit, ganz einfach zu steuern, wer wann auf welche Weise auf unsere Klassen, Eigenschaften, Ereignisse, Felder und Methoden zugreifen darf. Dabei unterscheiden wir allgemeine Modifizierer und sogenannte Zugriffsmodifizierer als eigene Gruppe innerhalb der Modifizierer.
Und weil diese Modifizierer so wichtig sind, gibt es davon auch eine ganze Menge. Die wichtigsten schauen wir uns hier an. Weitere Modifizierer gibt es im Abschnitt Noch mehr Modifizierer.

Zugriffsmodifizierer

Public

Auf Klassen, Eigenschaften, Methoden, Felder und Ereignisse, die diesen Zugriffsmodifizierer besitzen, darf unbeschränkt zugegriffen werden.

public class Zugriffstest_Public
{
  // ... ein öffentliches Feld
  public string m_Public_Feld = "Öffentliches Feld";

  // ... eine öffentliche Eigenschaft
  public string Public_Eigenschaft 
  { 
     get { return "Öffentliche Eigenschaft"; }
     set { m_Public_Feld = value; }
  }
  
  // ... ein öffentliches Ereignis
  public delegate void Public_Delegate();
  public event Public_Ereignis;

  // ... eine öffentliche Methode
  public string Public_Methode() 
  {
    return "Öffentliche Methode"; 
  }
}

Siehe auch: MSDN C# Referenz (public)

Private

Der Zugriffsmodifizierer private stellt genau das Gegenteil von public dar. So gekennzeichnete Typ-Mitglieder sind gegen jeden Zugriff von außen geschützt. Nur die Klasse selbst darf darauf zugreifen.

class Zugriffstest_Private
{
  // ... ein privates Feld
  private string m_Private_Feld = "Private Feld";

  // ... eine private Eigenschaft
  private string Private_Eigenschaft 
  { 
     get { return "Private Eigenschaft"; }
     set { m_Private_Feld = value; }
  }
  
  // ... ein privates Ereignis
  private delegate void Private_Delegate();
  private event Private_Ereignis;

  // ... eine private Methode
  private string Private_Methode() 
  {
    return "Private Methode"; 
  }
} 

(Hinweis: Private Klassen stellen einen Sonderfall dar, der uns in der Programmierung praktisch nie begegnet. Deshalb haben wir die Deklaration hier weggelassen.)

Siehe auch: MSDN C# Referenz (private)

Modifizierer

Abstract

Der Modifizierer abstract wird für uns schon im Abschnitt Vererbung ganz einfach sehr interessant werden. Mit seiner Hilfe lassen sich Klassen so beschreiben, dass sie nur als sogenannte Basisklassen verwendet werden können. Aber auch Eigenschaften, Ereignisse, Indexer und Methoden lassen sich als abstract definieren. Damit zeigen sie an, dass ihre Funktion erst später genauer definiert werden soll.

// ... eine abstrakte Klasse
abstract class Basisklasse
{
  // ... eine abstrakte Eigenschaft
  abstract public string Abstrakte_Eigenschaft { get; set; }

  // ... ein abstraktes Ereignis
  protected delegate void Private_Delegate();
  abstract event Abstraktes_Ereignis;

  // ... eine abstrakte Methode
  abstract public void Abstrakte_Methode();
}

Siehe auch: MSDN C# Referenz (abstract)

Const

Selbstverständlich haben wir uns schon gedacht, dass const nichts anderes als die Abkürzung von constant, also Konstante, ist. Es gibt an, dass ein so bezeichnetes Feld nicht geändert werden kann:

class ConstTest
{
  // ... ein konstantes Feld
  public const string m_Konstante_Name = "Konstantes Feld";
}

Siehe auch:
MSDN C# Referenz (const)
Modifizierer readonly

Override

Diesen Modifizierer verwenden wir, wenn wir mit abstract oder virtual deklarierte Methoden oder Eigenschaften, aber auch Ereignisse und Indexer, erweitern oder ändern wollen.

class ErbeVonBasisklasse : Basisklasse
{ 
  private string m_Privates_Feld;
  
  // ... wir überschreiben die abstrakte Eigenschaft
  override public string Abstrakte_Eigenschaft
  {
    get { return "Überschriebene Eigenschaft"; }
    set { m_Privates_Feld = value; }
  }

  // ... wir überschreiben die abstrakte Methode
  override public void Abstrakte_Methode()
  {
    return "Überschriebene Methode";
  }
}

Siehe auch: MSDN C# Referenz (override)

Sealed

Auch der Modifizierer sealed (dt. versiegelt) ist für die Vererbung wichtig: Eine versiegelte Klasse kann nicht vererbt werden und eine versiegelte Methode oder Eigenschaft überschreibt eine Methode oder Eigenschaft der geerbten Basisklasse, kann aber später in der Vererbungslinie nicht mehr selbst überschrieben werden.

sealed class VersiegelteKlasse : Basisklasse
{
  // ... eine versiegelte Eigenschaft
  sealed override public string Abstrakte_Eigenschaft
  {
    get { return "Überschriebene und versiegelte Eigenschaft"; }
    set { m_Privates_Feld = value; }
  }

  // ... eine versiegelte Methode
  sealed override public void Abstrakte_Methode()
  {
    // Diese Methode überschreibt die geerbte Methode.
    // Gleichzeitig "versiegelt" sie den Inhalt dieser Methode.
    // Weitere Erben dieser Klasse 
    // können diese Methode nicht mehr überschreiben.
  }
}

Siehe auch: MSDN C# Referenz (sealed)

Static

Mit dem Modifizierer static deklarieren wir statische Mitglieder. Die Besonderheit an statischen Mitgliedern ist, dass sie nicht zu einem bestimmten Objekt gehören, sondern dem Typ selbst zugeordnet sind. Alle Objekte eines Typs teilen sich also die statischen Mitglieder.

class StaticTest
{
  // ... wir deklarieren eine statische Konstante
  static public const string m_Konstante_Name = "Öffentliche, statische Konstante";

  // ... wir deklarieren eine statische Methode
  static public string Static_Methode()
  {
    // Hier stehen Aktionen,
    // die sich alle Objekte dieser Klasse teilen.
    // Wir müssen daher sehr vorsichtig sein,
    // wenn wir hier Variablen verarbeiten.
    // Es kann dabei leicht zu unvorhergesehenen 
    // Nebeneffekten kommen.
  }
}

Siehe auch: MSDN C# Referenz (static)

Regal: Programmierung Grundlagen der OOP