Arbeiten mit .NET: Grundlagen der OOP/ Zugriffsrechte
|
|
Lesetipp: Kein normaler Mensch kann sich all diese vielen Begriffe auf Anhieb merken. Erst bei der Vererbung werden wir uns mit abstract, override und sealed beschäftigen. |
|---|
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
[Bearbeiten]Public
[Bearbeiten]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
[Bearbeiten]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
[Bearbeiten]Abstract
[Bearbeiten]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
[Bearbeiten]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
[Bearbeiten]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
[Bearbeiten]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
[Bearbeiten]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)