C# Objektorientierte Programmierung - Tutorials.de

C#
Objektorientierte
Programmierung
1. Vorwort
2. Einleitung
3. Entwicklungsumgebung
4. Grundlagen
5. Debugging
6. Objektorientierung
(Ver. 1.03)
7. Fehlerbehandlung
by Erik Bartmann
1

1 Objektorientierte Programmierung ..............................................................4
Grundlagen.......................................................................................................4
Klassen und Objekte ........................................................................................5
Klassendefinition .............................................................................................5
Instanzvariablen ...............................................................................................7
Objektgenerierung............................................................................................8
Mehrere Objekte generieren.......................................................................12
Unterschiede bei der Zuweisung................................................................16
Methoden .......................................................................................................20
Zugriffsmodifizierer...................................................................................25
Wertübergabe.............................................................................................26
Call by value ..............................................................................................31
Call by reference........................................................................................33
Wertrückgabe.............................................................................................34
Wissenswertes über return .........................................................................36
Methodenüberladung .................................................................................38
Beliebig viele Argumente ..........................................................................41
Konstruktoren (spezialisierte Methoden).......................................................44
Konstruktorüberladung ..............................................................................48
Standardkonstruktor...................................................................................49
Konstruktor ruft Konstruktor .....................................................................50
this..................................................................................................................52
Garbage Collection ........................................................................................53
2

Destruktoren ..................................................................................................55
Eigenschaften.................................................................................................58
Konstanten .....................................................................................................62
Vererbung ......................................................................................................63
Grundlagen ................................................................................................63
Ableiten von einer Basisklasse ..................................................................64
Kindklasse ruft Basisklasse .......................................................................69
Konstruktoren im Kontext der Vererbung .................................................71
Welcher Konstruktor wird wann aufgerufen?............................................71
Member verdecken ....................................................................................73
Polymorphie...............................................................................................76
Statische Klassen ...........................................................................................82
Konstruktoren ............................................................................................85
Globale Variablen......................................................................................89
Main-Parameter .........................................................................................92
Enumerationen...............................................................................................96
Elemente der Enumeration ausgeben.......................................................100
Werte der Konstanten ausgeben ..............................................................102
Konstantennamen ausgeben.....................................................................103
Basisdatentyp zur Laufzeit ermitteln .......................................................105
3

1 Objektorientierte Programmierung
Grundlagen
Das folgende Kapitel befasst sich mit der Objektorientierten Programmierung -
kurz OOP genannt - unter C#. Was sich so leicht dahinsagt, bereitet manchen
am Anfang möglicherweise Kopfschmerzen. Doch lassen Sie sich durch diese
Aussage nicht entmutigen, denn wir werden auf unterster Ebene beginnen.
Gerade für Entwickler, die aus der Ecke der prozeduralen Programmierung
(z.B. C oder Basic) kommen, ist diese neue Denkweise möglicherweise etwas
ungewohnt. Die Entwickler von objektorientierten Sprachen wie z.B. C#, C++,
VB.NET, Java, Delphi, um nur einige zu nennen, waren bestrebt, die Realität so
naturgetreu wie möglich abzubilden. Alles, was wir so um uns herum sehen,
kann angefasst und auf allgemeiner Ebene als Objekt angesehen werden. Da
haben wir auch schon den Begriff, von der die o.g. Sprachen ihren Zusatz
haben. Betrachten wir in unserem Fall nur Objekte, die von Menschenhand
gefertigt wurden oder noch werden. Mein folgendes Beispiel liegt zwar etwas in
der Zukunft, doch die ist ja Dank StarTrek in greifbare Nähe gerückt. Die
Konstrukteure eines fiktiven Raumschiffs haben sich natürlich vor dem Bau
Gedanken über Aussehen, Größe, Spezifikationen bzw. Bewaffnung gemacht.
Sie haben nicht einfach drauf los gebaut, um zu sehen, (ob) was daraus wird,
sondern einen Konstruktionsplan erstellt, in dem alle Details über die spätere
Realisierung des Projektes enthalten sind. Mit dieser Vorlage kann ein einzelnes
oder auch eine ganze Flotte von Raumschiffen geschaffen werden. Übertragen
wir diese Vorlage auf die Objektorientierte Programmierung, so sprechen wir
von einer Klasse. Diese Klasse dient als Schablone für zukünftig zu
realisierende Objekte und enthält Anweisungen wie diese aufzubauen sind. Da
haben wir auch schon die beiden ersten wichtigen Schlagwörter der OOP.
Klasse und Objekt. Sie erkennen vielleicht jetzt schon, dass es sich hierbei um
4

eine Vorgehensweise handelt, die versucht ist, die Realität möglichst
naturgetreu abzubilden.
Klassen und Objekte
Eine Klasse ist ein Bauplan bzw. eine Vorlage, die beschreibt, wie ein Objekt
zu realisieren ist. Objekte werden auch als Klasseninstanzen bezeichnet.
In der OOP nennt man den Übergang von der Klasse zum Objekt
Instanziierung.
Klassendefinition
Eine Klassendefinition wird immer mit dem Schlüsselwort class eingeleitet,
wobei der darauf folgende Klassenname mit einem Großbuchstaben beginnen
sollte. Wieder eine Konvention, an die Sie sich halten sollten, aber nicht
müssen.
5

Folgende drei Bereiche gibt es bei der allgemeinen Klassendefinition
1. Vergabe des Klassenname
2. Deklaration der Instanzvariablen
3. Deklaration der Methoden
Wir halten fest, dass ein Objekt die Bündelung von Daten (Instanzvariablen)
und den entsprechenden Funktionen (Methoden) zur Bearbeitung dieser
Daten ist.
6

Instanzvariablen
Schauen wir uns einmal das Raumschiff als Objekt genauer an. Wie können wir
es beschreiben, bzw. welche statischen Attribute, auch Eigenschaften genannt,
weist das Objekts auf?
♦ Länge
♦ Breite
♦ Farbe
♦ Bautyp
♦ Geschwindigkeit
♦ Höchstgeschwindigkeit
♦ Anzahl der Besatzung
♦ Waffen
Das sind nur ein paar Beispiel-Eigenschaften und wir wollen es hierbei
bewenden lassen. Unser Raumschiff hat z.B. eine Länge von 200 Metern, eine
Breite von 100 Metern. Die Farbe ist silber-grau und seine momentane
Geschwindigkeit beträgt Warp 2. Es ist mit einer 200 Mann starken Besatzung
unterwegs. Diese Eigenschaften müssen irgendwie gespeichert werden und was
liegt näher, als Variablen dafür zu verwenden. Jedoch werden die Variablen im
Kontext der OOP, Instanzvariablen oder Felder genannt. Die allgemeine
Syntax zur Deklaration von Instanzvariablen lautet:
Zugriffstyp Datentyp Variablenname;
Bis auf den Zugriffstyp public ähnelt die Deklaration der, einer lokalen
Variablen. Schauen wir uns einmal folgende Klassendefinition an:
7

Dotty: „Was bedeutet denn das Schlüsselwort public?“
Es ist ein Zugriffsmodifizierer, der festlegt, wie auf das entsprechende Element
zugegriffen werden darf. Die genauere Bedeutung kommt ein wenig später. Wir
können es an dieser Stelle erst einmal ignorieren.
Objektgenerierung
Dotty: „Nachdem wir jetzt eine Klasse definiert haben, stellt sich mir Frage,
was wir mit der Klasse machen und wie wir sie nutzen können?“
Durch eine Klassendefinition wird quasi ein neuer Datentyp erzeugt. Die
Deklaration einer Variablen bereitet nach dem Studium der Grundlagen
hoffentlich keine Probleme mehr. Sie erfolgt nach dem Schema:
Datentyp Variablenname;
Mit der Anweisung
Raumschiff meinSpeeder;
wird jedoch in C# noch kein konkretes Objekt erzeugt. Es existiert lediglich die
Objektvariable meinSpeeder, die später als eine Art Zeiger, auch Referenz
genannt, auf die Startadresse eines bestimmten Speicherbereich (Heap)
verweist. Im Moment besitzt sie jedoch den Wert null und ist lediglich
8

vorbereitet worden, auf ein Objekt zu zeigen. Wie schon eingangs erwähnt,
existieren im CTS (Common Type System) von .NET zwei unterschiedliche
Kategorien von Datentypen.
♦ Wertetypen
♦ Verweis- bzw. Referenztypen
Wertetypen speichern ihren Wert direkt und werden im Stack abgelegt, wogegen
Verweisvariablen eine Referenz auf einen Speicherbereich, dem Heap, besitzen,
in dem die eigentlichen Daten gespeichert sind.
Abb. 1:
new
Wertetypen und Referenztypen
Um ein reales Objekt aus objektorientierter Sicht zu bekommen, wird das
Schlüsselwort new verwendet. Erst danach wird ein Speicherbereich im Heap
bereitgestellt. Die folgende Anweisung generiert das Objekt mit Hilfe der
Klassendefinition:
9

meinSpeeder = new Raumschiff();
Schauen wir uns das komplette Programm an und versetzten es über einen
Haltepunkt nach dem Start mit der F5 - Taste in den Debug-Modus. Stören Sie
sich im folgenden Beispiel nicht an den Schlangenlinien unterhalb der
Instanzvariablen. Sie besagen nur, dass sie im Moment noch keinen Wert
zugewiesen bekommen haben und deshalb einen Standartwert besitzen. Welche
das sind, erfahren Sie über das Fenster Lokal nach erreichen des Debug-Modus.
Zeile
Erklärung
10 - 17 Klassendefinition der Klasse Raumschiff. In ihr werden Instanzvariablen deklariert, die
10

zur Aufnahme von Objekteigenschaften dienen.
24 Deklaration der Objektvariablen meinSpeeder mittels der Klassendefinition
Raumschiff. (Es wurde noch kein Objekt erzeugt!)
26 Instanziierung des Objektes meinSpeeder mit Hilfe des Schlüsselwortes new. Erst jetzt
existiert ein reales Objekt im Heap.
Tab. 1: Code-Erläuterungen
Starten Sie die Anwendung, wird die Ausführung in Zeile 27 über den gesetzten
Haltepunkt unterbrochen. Ein Blick in Fenster Lokal, gibt Aufschluss über die
zu diesem Zeitpunkt initialisierten Variablen.
Abb. 2:
Fenster Lokal im Debug-Modus
Wir erkennen, dass es eine Variable mit Namen meinSpeeder vom Datentyp
ConsoleApplication16.Raumschiff gibt. Der Name ConsoleApplication16 gibt
in unserem Fall den Namespace an. Die angezeigten Werte entsprechen den
Defaultzuweisungen, welche implizit vorgenommen werden.
Icon
Erklärung
Signalisiert, dass es sich um eine Variable handelt
Tab. 2: Iconerklärung
11

Deklaration und Instanziierung können in einer einzigen Anweisungszeile
zusammengefasst werden.
Zugriff auf Eigenschaften
Da wir über die Klassendefinition einen neuen Datentyp geschaffen haben, stellt
sich uns die Frage, wie man nach der Objektgenerierung auf die Eigenschaften
zugreifen kann. Der Punktoperator . wurde von uns schon mehrfach verwendet,
um eine Verbindung zwischen Objekt und Member herzustellen. (z.B.
Console.ReadLine()) Der Zugriff erfolgt mit der Syntax:
Objekt.Member
Soll unser Raumschiff meinSpeeder mit 200 Mann Besatzung auf die Reise
gehen, dann lautet die Anweisung:
meinSpeeder.intBesatzung = 200;
Mehrere Objekte generieren
Der Grund einer Klasse bzw. Vorlage ist natürlich die Wiederverwendbarkeit.
Was nützt mir ein einziges Raumschiff, wenn ich mich gegen einen mächtigen
Gegner behaupten muss? Gar nichts! Aus diesem Grund muss ich mehrere
Kopien anhand der Vorlage anfertigen.
12

Die folgende Anwendung nutzt die gleiche Klassendefinition, instanziiert
jedoch 2 zwei Objekte:
13

Die beiden Objekte meinSpeeder bzw. deinSpeeder besitzen den gleichen
Ursprung: die Klassendefinition Raumschiff. Sie werden jeweils in den Zeilen
26 und 27 instanziiert. Es sind aber eigenständige Objekte, die sonst keine
Gemeinsamkeiten besitzen. Jedes von Ihnen hat eigene Eigenschaften bzw.
Attribute (Länge, Breite, Farbe und Besatzung). Ein Blick in das Fenster Lokal
gibt Aufschluss über die beiden unabhängigen Objekte.
14

Abb. 3:
Fenster Lokal im Debug-Modus
Hier ein Tipp, der das Arbeiten bzw. erkennen von Objekt-Membern extrem
erleichtert. Wieder leistet IntelliSense unschätzbare Dienste.
Wenn Sie die Eigenschaften eines Objektes initialisieren wollen, geben Sie den
Namen der Objektvariablen, gefolgt vom Punktoperator . ein. Augenblicklich
meldet sich IntelliSense und bietet die Member zur Auswahl an, welche mit
dem Objekt verknüpft sind. Sie erkennen aufgrund der optischen
15

Differenzierung (unterschiedliche Icons) sofort die Instanzvariablen wieder. Es
gibt aber eine Bedingung, auf die wir noch zu sprechen kommen: „Es werden
hier nur Instanzvariablen zur Auswahl angeboten, die den Zugriffsmodifizierer
public haben.“
Unterschiede bei der Zuweisung
Kommen wir zu einem gravierenden Unterschied bei der Zuweisung zwischen
Wertetypen und Referenztypen. Das folgende Beispiel zeigt eine
Wertzuweisung, bei dem der Wert der Variablen auf der rechten Seite in die
Variable auf der linken Seite kopiert wird. Es existieren zwei unabhängige
Variablen.
Die Konsolen-Ausgabe lautet:
Wert1: 10
Wert2: 42
16

Zeile
Erklärung
14 Die Variable intWert1 wird deklariert und mit dem Wert 10 initialisiert
15 Die Variable intWert2 wird deklariert und mit einer Kopie des Wertes von
intWert1 initialisiert.
16 Der Variablen intWert2 wird der Wert 42 zugewiesen, was aber keine
Auswirkung auf den Inhalt von intWert1 hat.
Tab. 3: Code-Erläuterungen
Das folgende Beispiel zeigt Ihnen die Zuweisung bei Referenztypen. Sie erfolgt
in einer Weise, die Sie vielleicht nicht vermutet haben.
17

Die Konsolen-Ausgabe lautet:
99
18

Bis zur Zeile 39 besitzen wir zwei eigenständige Raumschiffe (meinSpeeder,
deinSpeeder), die über je eine Objektreferenz anzusprechen sind. Jedes von
ihnen besitzt individuelle Eigenschaften, was der Zustand „vorher“
widerspiegelt. In Zeile 42 erfolgt nun durch meinSpeeder =
deinSpeeder nicht etwa ein Kopieren des Objektes deinSpeeder nach
meinSpeeder, sondern ein Kopieren der Referenz. Es existieren ab dieser Zeile
zwei Objektreferenzen, die auf ein und dasselbe Objekt verweisen, was der
Zustand „nachher“ widerspiegelt. Sollten Sie jetzt versucht sein, über die
Objektreferenz meinSpeeder das Objekt zu manipulieren (Zeile 43), kann
natürlich über die andere Referenz deinSpeeder das Ergebnis abgefragt werden
(Zeile 44). Egal welchen Zugang zum Objekt Sie wählen, Sie sprechen nur ein
Objekt an.
Dotty: „Wie kommen wir jetzt wieder an das alte Raumschiff meinSpeeder
heran?“
19

Das ist das Problem. Gar nicht mehr. Verliert ein Objekt seine letzte Referenz,
ist es nicht mehr ansprechbar und wird durch eine Einrichtung, die Garbage
Collection genannt wird, entsorgt. Es ist die interne .NET Müllabfuhr, die alle
herrenlosen Objekte aufspürt und den zuvor belegten Speicherplatz wieder
freigibt. Das hat natürlich enorme Vorteile, denn Sie brauchen sich nicht weiter
um diese Angelegenheit wie z.B. in der Programmiersprache C++ zu kümmern.
Wird dort der Aufräumprozess vergessen, kommt es zu so genannten
Speicherlecks, die unter Umständen zur Laufzeit eines Programms den
kostbaren freien Speicher nach und nach aufbrauchen. Weitere Details erfahren
Sie im Kapitel über die Garbage Collection.
Methoden
Wie Sie in der Klassendefinition gesehen haben, gibt es neben den
Instanzvariablen noch einen weiteren elementaren Bestandteil einer Klasse. Es
sind die Methoden. Sie sind Unterprogramme, die eine oder mehrere
Anweisungen enthalten können. Von außen betrachtet kann sie als eine einzelne
Anweisung angesehen werden, die über ihren Methodennamen aufgerufen wird.
Eine äußerst wichtige haben Sie schon im Kapitel über die Grundlagen kennen
gelernt. Es ist die Methode Main. Die allgemeine Syntax lautet:
Zugriffstyp Rückgabetyp Methodenname(Parameterliste)
{
// Methodenrumpf
// Anweisung(en)
}
Was bedeuten die einzelnen Elemente bei der
Definition einer Methode?
Element
Zugriffstyp
Erklärung
Der Zugriff wird über einen so genannten Zugriffsmodifizierer gesteuert
20

und legt fest, wer die Methode im aktuellen Kontext aufrufen darf.
Nähere Informationen liefert der Abschnitt über Zugriffsmodifizierer.
Rückgabetyp Der Rückgabetyp legt fest, welchen Datentyp die Methode
zurückliefert. Wird kein Wert zurückgeliefert, muss der Typ auf void
gesetzt werden.
Methodenname
Parameterliste
Der Name, mit dem die Methode aufgerufen wird. Er kann frei gewählt
werden, darf jedoch kein Schlüsselwort sein.
Die Parameterliste befindet sich innerhalb des runden Klammernpaares
(...) nach dem Methodennamen und beinhaltet die
Datentypbezeichnungen und Variablennamen, die zur Aufnahme der
übergebenen Argumente dienen. Mehrere Parameter werden durch
Kommata voneinander getrennt angegeben. Werden keine Argumente
übergeben, ist die Parameterliste leer, wobei die runden Klammern
nicht entfallen dürfen.
Methodenrumpf Der Methodenrumpf wird durch das geschweifte Klammernpaar {...}
festgelegt und enthält die Anweisung(en), die die Funktionsweise der
Methode ausmachen.
Tab. 4: Methoden-Elemente
Mit Hilfe der Methoden kann auf die Daten einer Klasse zugegriffen werden,
um sie zu lesen oder auch zu modifizieren.
Dotty: „Stop, stop, dass ist meines Wissens nicht ganz korrekt. Der Zugriff
auf Eigenschaften erfolgte im letzten Beispiel ohne eine Methode. Es wurde
einfach die Objektvariable und dessen Eigenschaft angegeben.“
Dem muss ich zustimmen, doch das ist nicht die Regel und diente nur als
anfängliches Beispiel. Ich komme jetzt zu einem weiteren wichtigen Eckpfeiler
der OOP. Es ist die Kapselung. Der Zugriff auf die Eigenschaften eines
Objekts, die in Instanzvariablen abgelegt werden, erfolgte bisher direkt. Durch
die Anweisung
21

meinSpeeder.intBesatzung = 200;
war es möglich, die Eigenschaft des Objektes unmittelbar zu manipulieren. Die
folgende Grafik veranschaulicht den Sachverhalt.
Abb. 4:
Direkter Zugriff auf die Daten eines Objekts
Das war jedoch nur möglich, weil der Zugriffsmodifizierer der betreffenden
Eigenschaft auf public (öffentlich) steht. Ein Zugriff von außen auf die Daten
des Objekts ist somit erlaubt. Stellen Sie sich vor, Sie sind Captain dieses
Raumschiffs und stellen auf einmal fest, dass sich an Bord mehr
Besatzungsmitglieder befinden, als es zur Erfüllung Ihres Auftrages notwendig
ist. Aufgrund des begrenzten Platzangebotes kommt es nach kurzer Zeit zu
Streitigkeiten untereinander, was die gesamte Mission gefährdet.
22

Was ist genau passiert? Durch die Anweisung
meinSpeeder.intBesatzung = 750;
ist die maximal zulässige Besatzungsstärke von 200 Mann um mehr als das 3-
fache überschritten worden. Niemand hat sich verantwortlich gefühlt eine
Zugangskontrolle einzurichten, um ein derartiges Problem erst gar nicht
entstehen zu lassen.
Dotty: „Was können wir aber unternehmen, damit es nicht dazu kommt?“
Wir müssen zwei Modifikationen vornehmen:
1. Den öffentlichen Zugriff von außen unterbinden
2. Den Zugang über eine Kontrollinstanz überwachen lassen, so dass
eingeschritten werden kann, wenn die maximale oder auch minimale
Besatzungsanzahl über- bzw. unterschritten wird.
Das bedeutet im Detail, dass in Schritt 1 in der Deklarationszeile der
Instanzvariablen der Zugriffsmodifizierer public (öffentlich) durch private
(privat) ersetzt werden muss. Durch diese Modifikation kann auf die
Instanzvariable nur noch innerhalb der Klasse zugegriffen werden. Da die
Vorgehensweise für alle bis jetzt genannten Instanzvariablen gleich ist,
konzentrieren wir uns im nun folgenden Beispiel auf intBesatzung.
23

private int intBesatzung;
Versuchen wir jetzt wie bisher auf die Eigenschaft durch
meinSpeeder.intBesatzung = 750;
zuzugreifen, erhalten wir eine Fehlermeldung:
Das ist genau das, was beabsichtigt war. Jetzt kommt Schritt 2. Der Zugriff auf
die Daten ist nur über eine öffentliche Methode gestattet:
Abb. 5:
Indirekter Zugriff auf die Daten eines Objektes
Sie sehen, dass zwischen dem (öffentlichen) Zugriff und den (privaten) Daten
ein Element eingefügt wurde. Die Methode. Sie übernimmt bei entsprechender
Kodierung die Überwachung des Zugangs zum Raumschiff und stellt das
Bindeglied zwischen den privaten, gekapselten Instanzvariablen und der
Außenwelt dar. Das ist genau die Strategie, die die OOP verfolgt. Die
24

Manipulation der von außen unsichtbaren Eigenschaften ist nur über öffentliche
Methoden zulässig bzw. gewünscht.
Da wir an dem Punkt gelangt sind, wo Sie über Eigenschaften und Methoden
bescheid wissen, erkennen Sie, dass in der OOP die Daten (Instanzvariablen)
und die Funktionen (Methoden) zur Manipulation derselben, eine Einheit
(Objekt) bilden.
Zugriffsmodifizierer
Jetzt wird es Zeit, ein paar Worte über die schon mehrfach verwendeten
Zugriffsmodifizierer public bzw. private zu verlieren. Sie legen die Sichtbarkeit
bzw. Zugriffsmöglichkeit der Klassenelemente, auch Member genannt, fest.
Zugriffsmodifizierer
public
private
protected
Bedeutung
Auf Klassenelemente, die als public deklariert wurden, kann über
eine Referenz auf die Klasse zugegriffen werden.
Auf Klassenelemente, die als private deklariert wurden, kann nur von
innerhalb der Klasse zugegriffen werden. In abgeleiteten Klassen
kann auf diese Elemente nicht zugegriffen werden.
Gleiches Verhalten, wie mit private. Jedoch kann in abgeleiteten
Klassen auf diese Elemente zugegriffen werden.
25

Tab. 5: Zugriffsmodifizierer für Klassenelemente
Wird kein Zugriffsmodifizierer angegeben, wird er implizit auf private
gesetzt.
Wertübergabe
Schauen Sie sich die folgende Methode (grauer Kasten) an, die innerhalb der
Klasse Raumschiff definiert wurde:
26

Was erkennen wir? Der Methodenkopf in Zeile 16 beginnt mit dem
Zugriffsmodifizierer public, der den öffentlichen Zugriff auf die Methode
erlaubt. An zweiter Position steht der Rückgabetyp void, der besagt, dass kein
Rückgabewert an den Aufrufer geliefert wird. Als nächstes kommt der
Methodenname mit der Parameterliste in den runden Klammern. Dort findet
27

sich nur ein Parameter (Variable) des Datentyps int. Rufen wir die Methode z.B.
mit der folgenden Anweisung
meinSpeeder.setBesatzung(150);
auf, wird der Wert 150 als Argument dem Parameter intAnzahl übergeben.
Die if-Anweisung überprüft, ob sich der Wert innerhalb der Grenzen von 20 bis
200 befindet. Liegt er außerhalb, wird die Instanzvariable intBesatzung auf
den Wert 0 gesetzt und eine entsprechende Fehlermeldung auf der Konsole
ausgegeben. Bei Einhaltung der gesetzten Grenzen wird der übergebene Wert
der Variablen intAnzahl an die Instanzvariable intBesatzung übergeben
(Zeile 27) und eine Bestätigung an die Konsole geschickt. Auf diese Weise
kann es nie zu einer Überladung unseres Raumschiffs bezüglich der
Besatzungsanzahl kommen. Nach der Eingabe des Objektnamen mit
nachfolgendem Punktoperator zeigt Ihnen übrigens IntelliSense wieder die Liste
der möglichen Member an:
Kapselung
Sie sehen, dass die Methode in ihrer Funktion als Kontrollinstanz arbeitet und
somit die Objektintegrität sicherstellt. In der OOP wird dieses Prinzip
Kapselung genannt. Vielleicht ist Ihnen aufgefallen, dass durch das Ändern des
Zugriffsmodifizierers von public auf private, die Instanzvariable
intBesatzung nicht mehr in der Auswahlliste erscheint. Hier zur Erinnerung
noch einmal die Bedeutung der Icons:
28

Icon
Erklärung
Signalisiert, dass es sich um eine Methode handelt
Tab. 6: Iconerklärungen
Wenn Sie eine Klasse erstellen, seien Sie bestrebt, die darin enthaltene
Komplexität zu verbergen, zu kapseln. Jemand, der die Klasse nutzt, benötigt
keine Informationen über die internen Vorgänge. Der Zugang sollte über
öffentliche Methoden oder die noch zu besprechenden Eigenschaften erfolgen.
Vielleicht haben Sie schon einmal den Begriff Black-Box gehört. Es ist ein
Gebilde, dessen innerstes im Verbogenen liegt und wir wissen nur, dass es eine
bestimmte Aufgabe zu erfüllen hat. Wie es sie erledigt, ist nicht bekannt und
wir müssen es nicht unbedingt wissen. Die Hauptsache ist, dass die Black-Box
funktioniert.
Argument und Parameter
Dotty: „So ganz habe ich den Unterschied zwischen Argumenten und
Parametern noch nicht verstanden!“
Beim Aufruf einer Methode, können ihr Werte übergeben werden, mit denen sie
arbeitet. Diese bezeichnet man als Argumente. Die Methode ihrerseits muss
diese Argumente entgegen nehmen und in entsprechenden Variablen speichern.
Sie werden Parameter genannt.
Argument
150
Parameter
public void setBesatzung(int Anzahl)
{
...
}
Abb. 6:
Argument und Parameter
29

Mehrere Parameter
Natürlich können wir die Parameterliste beliebig erweitern. Dazu werden die
einzelnen Parameter durch Kommata von einander getrennt angegeben.
Schauen Sie sich die Dimension des Raumschiffs an, die ich der Einfachheit
halber auf Länge und Breite reduziert habe. Es mach wenig Sinn, je eine
Methode für die Länge bzw. für die Breite zu definieren.
30

Zeile
Erklärung
18 - 22 Definition der Methode setDimension(double, double). Beachten
Sie bitte, dass für jeden Parameter, obwohl beide den gleichen Datentyp double
besitzen, die explizite Angabe erforderlich ist. setDimension(double
dblL, dblB) ist nicht zulässig!
32 Aufruf der Methode setDimension(). Beachten Sie die Reihenfolge der
Argumente: Argument1 (300.5) wird an Parameter1 (dblL) bzw. Argument2 (76.7)
an Parameter2 (dblB) übergeben.
Tab. 7: Code-Erläuterungen
Call by value
Beim Aufruf einer Methode erfolgte die Übergabe eines oder mehrerer
Argumente bisher nach dem Prinzip der Wertübergabe, auch call by value
genannt. Dabei werden die Argumente des Aufrufers in die entsprechenden
Parameter der Methode kopiert. Das folgende Beispiel zeigt den Aufruf der
Methode swap, an die zwei Werte übergeben werden. Sie hat die Aufgabe, die
beiden Werte zu vertauschen. Jedoch findet der Tausch nur innerhalb der
Methode swap statt, und bezieht sich nur auf die lokalen Variablen intW1 und
intW2. Es findet keine Rückkopplung an die beiden Variablen intWert1 und
intWert2 statt, die als Argumente der Methode swap eingesetzt wurden.
31

Deshalb lautet die Konsolen-Ausgabe:
Wert1: 10
Wert2: 20
Wir sehen, dass die beiden Werte nicht vertauscht wurden. Wie schaffen wir es
aber trotzdem, dass die Methode swap die Aufgabe erfüllt?
32

Call by reference
Fügen wir den Parametern der Methode swap jedoch das Schlüsselwort ref
hinzu, ändert sich das Verhalten der Methode.
Zusätzlich muss der Methodenaufruf dahingehend angepasst werden, dass dort
ebenfalls das Schlüsselwort ref verwendet wird.
Die Konsolen-Ausgabe lautet jetzt:
Wert1: 20
Wert2: 10
Doch wie kommt es zu dieser Wandlung? In diesem Fall wird nicht mit den
Kopien der übergebenen Werte gearbeitet. Der Methodenaufruf übergibt die
Speicheradressen (Referenz- oder Verweisübergabe) der Argumente an die
Parameter, was bedeutet, dass die Parameter als Aliasnamen angesehen werden
können. Folgende Punkte sind bei call by reference zu beachten:
♦ Die Variablen in der Parameterliste werden mit dem Schlüsselwort ref
gekennzeichnet
♦ Den Argumenten im Methodenaufruf muss ebenfalls das Schlüsselwort ref
vorangestellt werden
33

♦ Der oder die Argumente müssen initialisiert sein
♦ Die Übergabe einer Konstanten ist unzulässig. Andernfalls erhalten Sie die
Fehlermeldung :
Der Vollständigkeit halber, möchte ich noch den Parameter out ansprechen. Er
arbeitet ähnlich, wie ref. Der Unterschied ist jedoch, dass beim Methodenaufruf
an den mit out deklariertem Parameter keine initialisierte Variable übergeben
werden muss. Es werden also keine Daten an die Methode übergeben, sondern
sie steht in der Pflicht, diese zurück zu liefern.
Wertrückgabe
Sie haben gesehen, wie über eine öffentliche Methode eine private
Instanzvariable modifizieren werden kann. Natürlich ist der umgekehrte Weg,
das Abfragen einer Instanzvariablen, ebenso möglich. Fügen wir der Klasse
Raumschiff das folgende Codefragment hinzu, wird der Wert von
intBesatzung abgefragt.
Was erkennen wir? Der Methodenkopf in Zeile 33 beginnt mit dem
Zugriffsmodifizierer public, der den öffentlichen Zugriff auf die Methode
erlaubt. An zweiter Position steht der Rückgabetyp int, den die Methode
zurückliefert. Als nächstes folgt der Methodenname, dessen Parameterliste
34

jedoch leer ist, da keine Wertübergabe erfolgen soll. In Zeile 35 benutzen wir
das Schlüsselwort return. Es dient dazu, einen bestimmten Wert an den
Aufrufer zurück zuliefern. Die Syntax lautet:
return Variable;
oder
return Wert;
Die folgende Grafik veranschaulicht den schreibenden bzw. lesenden Prozess
auf das Objekt:
35

Die Anweisung zum Abfragen der Instanzvariablen lautet:
Console.WriteLine(meinSpeeder.getBesatzung());
Wissenswertes über return
Unerreichbarer Code
Vielleicht ist Ihnen in den Sinn gekommen, dass Sie nach dem Zurückliefern
des Wertes von intBesatzung noch zusätzlich eine Information an die
Konsole schicken sollten.
Schon rein optisch gesehen (Schlangenlinien) muss am vorliegenden Code
etwas nicht stimmen. Zeile 35 liefert den Wert von intBesatzung an den
Aufrufer zurück und verlässt damit augenblicklich die Methode. Das bedeutet
natürlich, dass die Anweisung in Zeile 36 nie zur Ausführung gebracht wird.
Fahren Sie mit der Maus über die Schlangenlinien, lautet der Hinweis:
„Unerreichbarer Code wurde entdeckt.“
return zwingend notwendig
Wurde ein Rückgabetyp außer void vereinbart, so ist es zwingend notwendig,
dass die Methode mit return einen Wert zurückliefert. Findet innerhalb der
Methode z.B. eine Verzweigung über die if-else-Anweisung statt, muss
sichergestellt werden, dass jeder mögliche Ausführungszweig eine return-
Anweisung bereitstellt.
36

Innerhalb der Methode befindet eine Kontrollstruktur, die je nach
Wahrheitsgehalt einen von beiden Codepfaden ausführt. Da jedoch nur der if-
Zweig die Bedingung, einen Rückgabewert zu liefern, erfüllt (Zeile 36), würde
es beim Eintritt in den else-Zweig ein Problem geben. Deshalb erhalten wir die
folgende Fehlermeldung:
Sorgen Sie dafür, dass alle möglichen Ausführungspfade in einem solchen Fall
einen Rückgabewert an den Aufrufer liefern.
return auch bei void
Soll eine Methode keinen Wert an den Aufrufer zurück liefern, setzt man den
Rückgabetyp auf void, was übersetzt leer bedeutet. Eine return-Anweisung ist
dadurch nicht notwendig bzw. optional. Dennoch kann die Methode mit return,
jedoch ohne Angabe eines Rückgabewertes, vorzeitig verlassen werden.
Zusammenfassend bedeutet dies, dass eine Methode, die void als
Rückgabetype hat, entweder durch das Erreichen der schließenden
geschweiften Klammer oder durch eine return-Anweisung verlassen werden
kann.
37

Methodenüberladung
In C# können Methoden überladen werden, was bedeutet, dass mehrere mit
gleichem Namen existieren.
Dotty: „Können wir dann immer noch von Eindeutigkeit sprechen?“
Es existiert natürlich ein Unterscheidungsmerkmal. Wenn der Name nicht zur
Differenzierung herangezogen werden kann, konzentrieren wir uns auf die
Parameterliste. Sie muss sich in den einzelnen gleichnamigen Methoden
unterscheiden. Dabei dürfen sich die Methoden nicht nur im möglicherweise
vorhandenen Rückgabetyp unterscheiden.
38

Die Konsolen-Ausgabe lautet:
Parameterlos
Ein int-Parameter
Zwei int-Parameter
Ein int- / ein double-Parameter
Zeile
Erklärung
38 Aufruf der Methode ohne Parameter. Die Methodendefinition in Zeile 13 fühlt sich
39

aufgrund des Fehlens jeglicher Argumente angesprochen.
39 Aufruf der Methode mit einem Ganzzahl-Literal, welches als Datentyp int interpretiert
wird. Die Methodendefinition in Zeile 18 wird angesprungen, da sich in deren
Parameterliste eine Variable vom Datentyp int befindet.
40 Aufruf der Methode mit zwei Ganzzahl-Literalen. Die Methodendefinition in Zeile 23
fühlt sich angesprochen. Sie besitzt in ihrer Parameterliste zwei Variablen des
Datentyps int.
41 Aufruf der Methode mit einem int bzw. double Wert. Die Methodendefinition in Zeile
28 wird angesprungen. Die Parameterliste enthält sowohl eine int-, als auch eine
double-Variable.
Tab. 8: Code-Erläuterungen
Dotty: „Kann man beim Aufruf einer Methode erkennen, ob und wie oft sie
überladen ist?“
Das ist möglich. Vielleicht ist es Ihnen schon beim Tippen der Methode
Console.WriteLine() aufgefallen. Nach der Eingabe des Namens, gefolgt von
der runden öffnenden Klammer, zeigt uns IntelliSense die folgenden
Informationen:
Es existieren vier Methodenüberladungen (1 von 4) wovon die erste
parameterlose Version - zu erkennen am leeren runden Klammernpaar - zur
Auswahl angeboten wird. Sie haben jetzt die Möglichkeit mit den Tasten
Cursoroben bzw. Cursounten sich die einzelnen überladenen Methoden mit deren
Parameterliste anzuschauen:
40

Dotty: „Ich verstehe den Sinn des Überladens noch nicht so ganz.“
Kommen wir noch einmal zu der schon angesprochenen Methode
Console.WriteLine(...), die 19-fach überladen ist. Sie ist so flexibel, dass sie als
Argument die unterschiedlichsten Datentypen akzeptiert und über einen
einzigen Namen aufzurufen ist. Würden die Möglichkeit des Überladens in C#
nicht existieren, so müssten wir für jeden existierenden Datentyp jeweils eine
eigene Methode schreiben, was zur Folge hätte, dass es unzählige Methoden mit
unterschiedlichen Namen geben würde:
♦ WriteLineByte(...)
♦ WriteLineShort(...)
♦ WriteLineInt(...)
♦ usw.
Könnten Sie sich alle möglichen Methoden alleine für WriteLine merken? Ist
natürlich machbar, doch recht ineffektiv. Durch die Methodenüberladung wird
die Sache enorm vereinfacht und durch die Reduzierung unterschiedlicher
Methodennamen vor allen Dingen übersichtlicher. Wir übergeben beim Aufruf
einen Wert, soll sich jemand anderes darum kümmern, die dazu passende
Methode aufzurufen.
Beliebig viele Argumente
Nachdem wir jetzt die Funktionsweise der Methodenüberladung kennen gelernt
haben, sehen wir uns das folgende Beispiel an. Es soll die Möglichkeit bieten,
die Summe von verschiedenen Zahlen zu bilden.
41

Was erkennen wir? Es existieren 3 Methoden mit Namen summe. Sie liefern
jeweils die Summe der übergebenen Argumente an den Aufrufer zurück. Die
Frage, die sich uns stellt ist: „Wie weit wollen wir das Spiel noch treiben?“ Ich
meine damit die Anzahl der überladenen Methoden, um auf möglichst viele
Möglichkeiten in der Anzahl der Argumente reagieren zu können. Es gibt eine
Alternative. Dazu existiert ein spezieller Parameter, der durch das Schlüsselwort
params gekennzeichnet wird.
42

Die Konsolen-Ausgabe lautet:
Summe ist: 0
Summe ist: 21
Summe ist: 10
Summe ist: 17
Durch den Zusatz von params wird aus dem Parameter ein Array, auf das, wie
schon gelernt, zugegriffen werden kann. Die foreach-Schleife spricht jedes
Element des Arrays an und in Zeile 17 wird die Summe gebildet. Zeile 19 liefert
das Ergebnis an den Aufrufer zurück. Wie Sie in Zeile 27 sehen, können auch
keine Argumente übergeben werden.
43

Konstruktoren (spezialisierte Methoden)
Sie bekommen als Captain ihres neuen Raumschiffs meinSpeeder die Aufgabe,
eine nahe gelegene befreundete Kolonie aufzusuchen, in der es einen
feindlichen Übergriff aus dem Nachbarsektor gegeben hat. Natürlich verlassen
sie sich darauf, dass ihre Bewaffnung in Form von Photonentorpedos in
ausreichender Stückzahl zur Verfügung steht. Auf halber Strecke müssen sie
sich leider vom Gegenteil überzeugen lassen. Wie konnte das passieren? Der
folgende Source-Code konzentriert sich nur auf die Instanzvariable
intPhotonentorpedos und lässt die restlichen Eigenschaften außen vor.
44

Die Konsolen-Ausgabe bringt es ans Tageslicht:
Anzahl der Torpedos: 0
Es wurde in der Hektik einfach vergessen, die Methode setPhotonentorpedos
nach dem Generieren des Raumschiffs mit entsprechender Anzahl aufzurufen.
Wie können wir dieses Manko beheben? Am sichersten wäre ein
Automatismus, der nach der Instanziierung des Objektes eine bestimmte
Methode aufruft, die eine Vorinitialisierung vornimmt, so dass z.B. die
Instanzvariablen einen definierten, initialen Startwert bekommen. Das Problem,
welches uns dabei entgegenschlägt ist aber: Jeder Programmierer könnte diese
Methode anders benennen. Wie stellen wir aufgrund dieser Problematik die
Initialisierung des Objektes sicher? Die Antwort ist recht simpel. Die Methode
besitzt den gleichen Namen wie die Klasse und wird somit zum Konstruktor.
Die wörtliche Übersetzung aus dem Englischen heißt „Bauherr“.
Er wird bei der Instanziierung eines Objektes automatisch aufgerufen.
Die Syntax lautet:
Zugriffstyp Klassenname([Parameterliste])
{
}
// Anweisung(en)
Konstruktoren besitzen übrigens keinen Rückgabetyp (void inbegriffen).
45

Dotty: „Das verstehe ich nicht. Ein Konstruktor ist doch auch eine art
Methode, die unter gewissen Umständen eine Berechnung durchführen und
das Ergebnis an den Aufrufer zurückliefern kann.“
Und das ist genau der Kasus Knacktus! Wodurch bzw. durch wen wird ein
Konstruktor aufgerufen? Nicht etwa durch einen expliziten Aufruf von außen.
Der Aufruf erfolgt bei der Instanziierung, also zum Zeitpunkt der
Objektgenerierung. An wen sollte da ein Rückgabewert zurück geliefert
werden? Schauen Sie sich den modifizierten Source-Code inklusive
Konstruktor an:
46

Die Konsolen-Ausgabe lautet:
Konstruktor-Aufruf.
Anzahl der Torpedos: 2500
Konstruktorüberladung
Das Überladen eines Konstruktors ist vergleichbar mit dem einer Methode. Wir
haben schon gesehen, dass mit einem Konstruktor ein Objekt initialisiert
werden kann. Durch unterschiedliche Konstruktoren haben wir jetzt die
Möglichkeit, verschiedene Objekte mit abweichenden Startwerten bei der
Instanziierung zu versehen. Der parameterlose Konstruktor aus dem letzten
Beispiel sorgte dafür, dass die Bestückung bezüglich der Anzahl der
Photonentorpedos automatisch auf den Wert 2500 gesetzt wurde. Überladen wir
den Konstruktor mit der folgenden Definition
können wir mit der Zeile
unser Raumschiff entsprechend bestücken.
48

Standardkonstruktor
Sollten Sie keinen Konstruktor definiert haben, übernimmt C# für Sie die
Aufgabe und generiert automatisch einen parameterlosen Standardkonstruktor.
Er ist u.a. dafür verantwortlich, dass die in der Klasse aufgeführten
Instanzvariablen mit einem Standardwert initialisiert werden. Wenn jedoch ein
eigener parametrisierter Konstruktor hinzufügt wird, ist der Standardkonstruktor
nicht mehr existent. Sie müssen ihn notfalls explizit hinzufügen. Der folgende
Code enthält einen parametrisierten Konstruktor (Zeile 14 bis 17), jedoch keine
explizite Definition für den Standardkonstruktor.
49

Die Schlangenlinien in Zeile 29 weisen uns unbarmherzig auf einen erkannten
Fehler hin.
Das bedeutet, dass es keinen Konstruktor gibt, der 0 Argumente annimmt,
sprich: der Standardkonstruktor fehlt. Falls er sowieso nichts machen soll, fügen
Sie einfach folgenden Code ein:
Konstruktor ruft Konstruktor
Existieren mehrere überladene Konstruktoren, so kann es sinnvoll sein, wenn
ein Konstruktor den anderen aufruft. Wird der parameterlose Konstruktor
aufgerufen, können wir ihn ihm eine Objektinitialisierung mit vordefinierten
Werten festlegen. Existiert ein überladener, parametrisierter Konstruktor, der
ebenfalls für die Objektinitialisierung erstellt wurde, kann der parameterlose
Konstruktor den parametrisierten ausführen, um gleichlautenden Code in beiden
Konstruktoren zu vermeiden. Schauen Sie sich das folgende Beispiel an:
50

Der parameterlose Konstruktor in Zeile 16 wird durch die Objektgenerierung
aus Zeile 33 aufgerufen. Er führt seinerseits durch das Schlüsselwort this den
parametrisierten Konstruktor aus Zeile 21 aus, in dem er ihm die Werte in Form
einer Arumentenliste (250, 300.5, 150.4) übergibt. Sie sehen auch, dass der
Konstruktorrumpf zwischen den Zeilen 17 und 19 leer ist, da die Initialisierung
an anderer Stelle vorgenommen wird.
51

this
Sie erinnern sich bestimmt an die Methode setDimension, mit deren Hilfe wir
die gekapselten Instanzvariablen dblLaenge und dblBreite initialisiert haben.
Die Parameter dblL und dblB waren, wie Sie sicher vermutet haben, eine
Abkürzung der Instanzvariablen, um deren Verwendungszweck deutlicher zu
machen. Was spricht aber dagegen, wenn wir den Parametern die gleichen
Namen vergeben, wie die der Instanzvariablen?
Wenn Sie sich die Zuweisungen in den Zeilen 18 und 19 anschauen, sollten bei
Ihnen die Alarmglocken läuten. Syntaktisch gesehen ist alles in bester Ordnung,
doch was wollen wir eigentlich bezwecken? Die übergebenen Argumente sollen
in den Parametern der Methode gespeichert und mittels Zuweisung an die
privaten Instanzvariablen übergeben werden. Innerhalb der Methode wird direkt
52

auf die definierten Parameter dblLaenge bzw. dblBreite zugegriffen. Wie aber
teilen wir dem Compiler mit, dass er auf die gleich lautenden Instanzvariablen
zugreifen soll? Jetzt kommt this zum Einsatz. Es dienst als Referenz auf das
aktuelle Objekt. Modifizieren wir also die Zeilen 18 und 19 wie folgt:
Auf der linken Seite der Zuweisungen wurden die Variablennamen um das
Schlüsselwort this erweitert. In dieser Kombination bezieht sich der Ausdruck
nicht mehr auf die Parameter der Methode, sondern auf die Instanzvariablen.
Garbage Collection
53

Generieren wir über das Schlüsselwort new ein neues Objekt, wird ihm auf dem
Heap zur Laufzeit ein Stückchen von freiem Speicher zugewiesen. Wie wir alle
wissen, ist unser lokal zur Verfügung stehender Speicher zwar in den letzten
Jahren stetig gewachsen, doch der Vorrat ist nicht unerschöpflich. In einer
Anwendung werden Objekte dynamisch erstellt, können aber nach einer
gewissen Zeit u.U. nicht mehr von Nutzen sein, da sie nicht mehr referenziert
werden. Können wir ein solches Objekt nicht mehr über einen gültigen Verweis
ansprechen, ist es nutzlos geworden und blockiert den kostbaren Speicher, der
an anderer Stelle benötigt wird. Die Frage, die sich uns stellt ist: „Wie
entledigen wir uns der Objektleichen?“ Tja, da können wir gar nichts machen.
Nein wirklich, denn das .NET Framework ist mit einer automatischen
Speicherverwaltung ausgerüstet, welche sich der verwaisten Objekte annimmt.
Der Fachbegriff hierfür ist Garbage Collection (GC). Sie ist Bestandteil der
Common Language Runtime (CLR), arbeitet als Mülldienstleitster auf
Speicherebene im Hintergrund und spürt alle nicht mehr benötigten Objekte auf,
die daraufhin aus dem Speicher entfernt werden, damit dieser bereit für die
Aufnahme neuer Objekte ist. Danach erfolgt eine Reorganisation. Die GC ist
ständig bestrebt, dass immer genug Speicher-Ressourcen für künftige
Anforderungen zur Verfügung stehen und kein Engpass aufgrund von
Speicherleichen (Memory Leaks) entsteht.
Dotty: „Das bedeutet also, dass sie sofort zuschlägt und mit dem großen
Besen vorbeikommt, wenn ein Objekt nicht mehr benötigt wird.“
Dem ist nicht so. Die Garbage Collection legt ein, wie man so schön sagt, nicht
deterministisches Verhalten an den Tag, was bedeutet, dass es nicht
vorhersehbar ist, wann sie zuschlägt. Würde sie sofort in Aktion treten, wenn
auf ein Objekt kein gültiger Verweis mehr existierte, müsste eines natürlich
sicher gestellt sein: Die Garbage Collection muss ständig aktiv sein. Sie können
sich sicherlich vorstellen, dass das mit einer gewissen Rechenleistung
verbunden ist, die bei stetiger Ausführung zu Performanceeinbußen führt. Es
gibt aber dennoch ein Kriterium, das ihn dazu bewegt, aus seinem normalen
Trott heraus, seine Aufräumarbeit zu beginnen. Wenn die freien
Speicherressourcen ein gewissen Wert unterschreiten, so dass ein Engpass
entstünde, wir die Suche gestartet.
54

Destruktoren
Sie haben die Baumeister der Objekte, die Konstruktoren, kennen gelernt. Dazu
gibt es ein passendes Gegenstück. Den Destruktor. Es ist eine Methode, die
kurz bevor die Garbage Collection das Objekt aus dem Speicher entfernt,
aufgerufen wird. Sie trägt den gleichen Namen wie die Klasse, ganz gleich dem
der Konstruktordefinition, jedoch mit dem vorangestellten Tilde-Zeichen ~.
Der Destruktor besitzt keinen Rückgabetyp.
Die Syntax lautet:
~Klassenname()
{
}
// Anweisung(en)
Platzieren Sie den Code innerhalb der Methode, der kurz vor der Entfernung des
Objektes aus dem Speicher ausgeführt werden soll.
55

Zeile
Erklärung
13 - 16 Konstruktordefinition
18 - 21 Destruktordefinition
27 Instanziierung der Objektes meinSpeeder (Impliziter Aufruf des Konstruktors)
56

28 Objektfreigabe mittels Zuweisung durch null. Nach dieser Anweisung wird auf das
Drücken der Enter - Taste gewartet. Sie sehen, dass zu diesem Zeitpunkt der
Destruktor noch nicht aufgerufen wurde. (Keine Konsolenausgabe „Destruktoraufruf.“)
34 Explizites Anstoßen des Garbage Collectors (Aufruf des Destruktors)
Tab. 9: Code-Erläuterungen
Es existiert eine statische Methode GC.Collect(), mit ihrer Hilfe die
Garbage Collection explizit angestoßen werden kann.
Kommen Sie jetzt bitte nicht auf die Idee, diese Methode - für alle Fälle -
mehrfach in Ihrer Anwendung aufzurufen, nur damit alle nicht mehr benötigten
Objekte sofort gelöscht werden. Die Konsequenz dürfte Ihnen bekannt sein.
Dotty: „Was passiert eigentlich, wenn ein einzelnes Objekt mehrere Verweise
besitzt und nur einer davon wegfällt?“
Existieren mehrere Verweise auf ein Objekt, so wird dieses von der Garbage
Collection nur erfasst, wenn der letzte Verweis verschwunden ist. Fügen wir
eine zusätzliche Codezeile (Zeile 29) ein, die eine zweite Referenz auf das
Objekt generiert,
und kappen den ersten Verweis meinSpeeder in Zeile 30, verbleibt immer noch
der Verweis deinSpeeder, um auf das Objekt zuzugreifen. Die Garbage
Collection wird bei diesem Objekt nicht aktiv.
57

Vielleicht trägt das folgende Bild auch ein wenig zum Verständnis bei.
Eigenschaften
Wenn es darum ging, auf eine geschützte, mit private deklarierte
Instanzvariable zuzugreifen, haben wir jeweils eine Methode zum Abfragen
bzw. zum Modifizieren genutzt. Um die beiden namentlich zu unterscheiden,
nutzten wir das Präfix get (z.B. getBesatzung) für das Abfragen und set
(z.B. setBesatzung) für das Modifizieren.
58

Es wäre bestimmt einfacher und wünschenswert, müssten wir uns nicht zwei
unterschiedliche Namen für den Zugriff auf die Instanzvariable merken. Da wir
die Kapselung der Daten nicht aufweichen wollen, ermöglichen wir den Zugriff
auf die geschützten, mit private deklarierten Instanzvariablen nur über
öffentliche Methoden. Das ermöglicht uns, wie schon erwähnt, eine Kontrolle,
der an das Objekt herangetragenen Daten und bewart die Objektintegrität. In C#
gibt es einen speziellen Typ von Methode: Die Eigenschaft (engl. Property). Die
Syntax lautet:
59

Zugriffstyp Rückgabetyp Name
{
get
{
// Anweisung(en)
}
set
{
// Anweisung(en)
}
}
60

Methode
get
set
Erklärung
Liefert ein Wert zurück
Modifiziert einen Wert und nutzt die implizit definierte Variable value
Die Methoden werden auch als getter- bzw. setter-Methoden bezeichnet. Wie
Sie in Zeile 26 sehen, erfolgt die Wertzuweisung mit dem Zuweisungsoperator
=, der auch bei Variablenzuweisungen Verwendung findet. Die Abfrage der
Instanzvariablen, die in Zeile 27 statt findet, erfolgt über denselben Ausdruck.
Zusammenfassend können wir sagen, dass das Verhalten von Eigenschaften
mit der von öffentlichen, mit public deklarierten Instanzvariablen zu
vergleichen ist.
Haben wie eine Eigenschaft erstellt, wird diesem Element im Kontext der
Klassenumgebung ein neues Icon zugewiesen.
Icon
Erklärung
Tab. 10:
Signalisiert, dass es sich um eine Eigenschaft (Property) handelt
Iconerklärungen
Führen Sie sich den Unterschied in den Aufrufen von Methoden und
Eigenschaften noch einmal vor Augen:
Methode
meinSpeeder.setBesatzung(400);
Eigenschaft meinSpeeder.Besatzung = 400;
Read-Only
Sie können den Zugriff auf die privaten Daten über eine Eigenschaft
reglementieren, in dem Sie entweder die get- oder die set-Methode weglassen.
61

Ist nur eine get-Methode vorhanden, haben Sie auch nur die Möglichkeit, Daten
zu lesen. Wir nennen dies Read-Only (nur lesen).
Write-Only
Im Gegensatz dazu können wir mit dem alleinigen Vorhandensein einer set-
Methode nur das Modifizieren gestattet. Es wird Write-Only (nur schreiben)
genannt.
Dotty: „Ich verstehe zwar die Unterschiede in der Implementierung, doch für
welche Variante soll ich mich entscheiden?“
Die Antwort darauf ist nicht einfach und im Endeffekt muss jeder für sich
entscheiden, ob er den Schreib/Lesezugriff auf private Daten lieber über zwei
Methoden mit unterschiedlichen Namen oder über eine einzige Eigenschaft
realisieren möchte. Falls Sie sich grundsätzlich für Methoden entscheiden,
sollten Sie bedenken, dass die Anzahl der Objekt-Member natürlich verdoppelt
wird. Das trägt u.U. nicht gerade zur besseren Übersicht bei.
Konstanten
Möchten Sie zu Beginn einer Anwendung einen oder mehrere Werte festlegen,
die zur Laufzeit nicht geändert werden dürfen, sollten Sie Konstanten
definieren. Die Kreiszahl Pi würde in diese Kategorie fallen. Stellen Sie sich
vor, dass durch irgendeinen dummen Zufall Pi einen anderen Wert als
62

3,141592... bekommen würde. Nicht auszudenken, welchen Aufstand die Kreise
anzetteln würden. Die Syntax lautet:
Zugriffstyp const Datentyp Name = Wert;
Proben Sie dennoch den Aufstand und wollen mit aller Macht eine Änderung,
bekommen Sie die Quittung:
Icon
Erklärung
Tab. 11:
Signalisiert, dass es sich um eine Konstante handelt
Iconerklärungen
Vererbung
Grundlagen
Kommen wir jetzt zu einem Kapitel, das sich mit der Vererbung in C# befasst.
Es geht dabei um ein Konzept in der OOP, welches es ermöglicht, vorhandenen
Code einer Klasse in einer abgeleiteten, Klasse wieder zu verwenden. Die
abgeleitete Klasse - wir nennen sie mal Kindklasse - erbt sozusagen die
Methoden und Eigenschaften der Basisklasse. Wir arbeiten also nach dem
Motto: „Warum das Rad neu erfinden?“ Nutzen wir die vorhandene
63

Funktionalität einer Basisklasse und erweitern diese nach unseren Wünschen,
um die notwendigen Aspekte in einer spezialisierten Kindklasse. Sehen wir uns
das wieder am Beispiel unserer Raumflotte an. Sie besteht natürlich nicht nur
aus Kampfschiffen. Da gibt es z.B. noch Transport- oder Forschungsschiffe. Die
Frage, die wir uns stellen sollten ist: „Welche Eigenschaften haben alle Schiffe
gemeinsam und in welchen Punkten unterscheiden sie sich?“ Die folgenden
Auflistungen der Eigenschaften beschränken sich nur auf das Wesentlichste, um
das Beispiel so knapp und einfach wie möglich zu halten:
Kampfschiff Transportschiff Forschungsschiff
Triebwerke Triebwerke Triebwerke
Besatzung Besatzung Besatzung
Photonentorpedos Lagerräume Forschungseinrichtung
Quantentorpedos
Andockschleusen
Tab. 12: Raumschiff-Typen
Ableiten von einer Basisklasse
Sie sehen, dass die ersten beiden Zeilen die Eigenschaften enthalten, die bei
allen drei Schiffs-Typen gleich lauten. Alle nachfolgenden Zeilen beschreiben
Spezialisierungen des jeweiligen Schiffs-Typ. Es liegt also nahe, die
Gemeinsamkeiten, sprich die Schnittmenge, in eine Basisklasse auszulagern,
um sie nicht in jeder Raumschiffklasse gleichermaßen zu benennen
(Redundanter Code). Etwaige Änderungen bzw. Verbesserungen in der
Basisklasse kommen durch diese Auslagerung allen abgeleiteten Klassen zu
Gute.
64

Wir können die Abhängigkeit bzw. hierarchische Struktur in einem
Klassendiagramm darstellen. Die Spitze des Pfeils zeigt dabei auf die
Basisklasse. (UML-Notation)
Die Kodierung der Basisklasse lautet demnach:
65

So weit so gut. Nun erschaffen wir exemplarisch ein Raumschiff, welches sich
der Eigenschaften der Basisklasse bedient, jedoch einige ihm eigene
Spezialisierungen hinzufügt. Der neue Typ soll Kampfschiff lauten. Bei der
Klassendefinition müssen wir aber zum Ausdruck bringen, dass die Ableitung
von der Basisklasse Raumschiff erfolgen soll. Das wird mit dem
Doppelpunktoperator : und der nachfolgend aufgeführten Basisklasse erreicht.
Generieren Sie jetzt ein neues Kampfschiff, so bietet Ihnen IntelliSense die
Instanzvariablen intBesatzung und intTriebwerke der Basisklasse
Raumschiff ebenso wie intPhotonentorpedos und
intQuantentorpedos der Kindklasse Kampfschiff zur Auswahl an.
66

Eine abgeleitete Klasse ist in der Regel spezialisierter und enthält mehr
Funktionalität als ihre Basisklasse. Sie erhält Zugriff auf alle nicht privaten
Member der Basisklasse und auf alle in ihr selbst definierten.
Dotty: „Mit der Kapselung ist es bei diesem Beispiel ja nicht weit her. Alle
Eigenschaften sind direkt zu Manipulieren, so dass die Objektintegrität
potentiell gefährdet ist.“
Vollkommen korrekt erkannt! Das folgende Beispiel zeigt die Modifikation des
Programms dahingehend, dass die Kapselung wieder aktiviert wird. Der Zugriff
ist ausschließlich den öffentlichen Methoden gestattet. Die als private
deklarierten Member sind in der abgeleiteten Klasse nicht sichtbar.
67

IntelliSense zeigt uns, dass nur auf mit public deklarierte Member der Basisbzw.
Kindklasse zugegriffen werden kann.
Kindklasse ruft Basisklasse
Dotty: „Wie können wir der Kindklasse erlauben, direkt auf private Member
der Basisklasse zuzugreifen, ohne die Kapselung mit public aufzuweichen?“
Wir stecken ein wenig in einer Zwickmühle. Der Zugriffsmodifizierer public ist
zu lasch in seinen Restriktionen, wohingegen private es etwas zu weit treibt.
Die Lösung des Problems ist ein bisher unbekannter Zugriffsmodifizierer, der
diese Funktionalität ermöglicht. Er lautet: protected. Der folgende Zugriff auf
die private Instanzvariable intBesatzung der Basisklasse führt zu einem
Fehler:
69

Durch die folgende Modifikation der Basisklasse wird dieser Fehler vermieden
und der Zugriff über die Kindklasse erlaubt.
Dotty: „Der Fehler ist zwar nicht mehr da, doch die genauen
Zusammenhänge liegen für mich immer noch im verborgenen!“
Wird ein Member mit dem Zugriffsmodifizierer protected deklariert, verhält es
sich für die betroffene Klasse wie mit private deklariert. Es ist nur innerhalb der
Klasse sichtbar. Der Unterschied kommt beim Vererben zum tragen. Das
vererbte protected Member ist in der Kindklasse sichtbar und es kann darauf
zugegriffen werden.
70

Konstruktoren im Kontext der Vererbung
Besitzt eine Basisklasse einen oder mehrere Konstruktoren, stellt sich uns die
Frage, ob diese beim Vererbungsvorgang in die Kindklasse übernommen
werden. Die Antwort lautet: Nein. Eine Basisklasse besitzt keine Informationen
über die Member der Kindklasse, was bedeutet, dass die abgeleitete Klasse, falls
notwendig, selbst für die Konstruktoren verantwortlich ist.
Welcher Konstruktor wird wann aufgerufen?
Besitzen sowohl die Basis- als auch die Kindklasse explizit definierte
Konstruktoren, fragen wir uns: „Wann wird welcher Konstruktor aufgerufen?“
Schauen Sie sich das folgende, ausschließlich mit Konstruktoren versehene
Beispiel an:
71

Die Konsolen-Ausgabe lautet:
Konstruktoraufruf: Basisklasse ’Raumschiff’
Konstruktoraufruf: Kindklasse ’Kampfschiff’
Sie sehen, dass bei der Objektgenerierung einer abgeleiteten Klasse in Zeile 33
zuerst der parameterlose Standardkonstruktor der Basisklasse und danach der,
der Kindklasse aufgerufen wird. Das ist eigentlich logisch, denn die Basisklasse
ist ebenso für ihren Teil der Initialisierung verantwortlich, wie die Kindklasse.
72

Der Aufruf der Konstruktoren in der Vererbungshierarchie beginnt stets bei der
Wurzel, also der Basisklasse und erfolgt von dort aus weiter entlang der
Erblinie, bis hin zum jüngsten Spross. Aus Platzgründen habe ich mich in
meinen Beispielen auf eine einzige Kindklasse beschränkt. Sie können jedoch
die Kindklasse als neue Basisklasse für eine weitere Vererbung nutzen.
Member verdecken
Wir haben schon gesehen, dass durch den Vorgang der Vererbung, alle Member
der Basisklasse (nicht die Konstruktoren und Destruktoren), die nicht mit
private deklariert wurden, ebenso in der Kindklasse zur Verfügung stehen. Was
passiert aber, wenn z.B. eine Methode in der Kindklasse den gleichen Namen
inklusive Parameterliste trägt, wie eine in ihrer Basisklasse?
73

Sowohl in der Basisklasse als auch in der Kindklasse existiert eine Methode mit
Namen getID(). Starten Sie das Programm, so lautet die Konsolen-Ausgabe:
ID: Kampfschiff.
Die Methode der Basisklasse ist überschrieben worden. Die Frage, die Sie sich
jetzt stellen sollten ist: „Ist das von mir so gewollt, oder habe ich durch eine
Unachtsamkeit den gleichen Namen gewählt?“ Der Compiler erkennt dies und
weist Sie mit einer Warnung auf diesen Umstand hin. Sehen Sie die
Schlangenlinien unterhalb von getID() innerhalb der Kindklasse? Der
Hinweis besagt, dass der vererbte Member getID() der Basisklasse
ausgeblendet wird. Falls das so von Ihnen gewünscht ist, können Sie die
74

Warnung dadurch verhindern, dass das Schlüsselwort new in der Kindklasse
verwendet wird:
Dotty: „Können wir jetzt nicht mehr auf die verdeckte Methode zugreifen?“
Doch, das ich weiterhin möglich. Durch die Verwendung des Schlüsselwortes
base wird der Zugriff auf die Basisklasse ermöglicht.
75

Die Konsolen-Ausgabe lautet:
ID: Raumschiff.
Polymorphie
Kommen wir jetzt zu einem Punkt, der vielleicht ein paar Stirnrunzeln bei Ihnen
hervorrufen wird. Übersetzt bedeutet Polymorphie Vielgestaltigkeit. In C#
können in einer Basisklasse z.B. Methoden existieren, die in der abgeleiteten
Kindklasse neu definiert werden. Dadurch erlangen wir die Fähigkeit,
76

estehenden Programm-Code ohne Anpassung bzw. Modifikation nutzen zu
können, ihn jedoch nach unseren Bedürfnissen zu erweitern. Vererbung ist also
ein zwingender Bestandteil für Polymorphie. Doch es gehört noch ein wenig
mehr dazu.
Dotty: „Haben wir Polymorphie nicht schon längst in unserem letzten
Beispiel mit der neu definierten Methode erreicht? Die neue Methode in der
Kindklasse hat die bestehende der Basisklasse mit neuer Funktionalität
abgelöst.“
Das ist eben nicht der Fall. Schauen wir uns das nun folgende Beispiel an,
welches nichts mit Polymorphie zu tun hat.
Die Basisklasse Raumschiff dient als Ausgangspunkt für unsere geplanten
Weiterentwicklungen Kampfschiff und Transportschiff.
77

Die Kindklasse Kampfschiff wird von der Basisklasse Raumschiff abgeleitet.
Die Kindklasse Transportschiff wird von der Basisklasse Raumschiff abgeleitet.
78

Im Hauptprogramm legen wir ein Array mit drei Elementen an, welches die
Raumschiff-Objekte aufnehmen kann (Zeile 58).
Dotty: „Jetzt bin ich vollends verwirrt! Wir erzeugen Referenzen vom Typ
Raumschiff, die aber auf unterschiedliche Objekte (Kampfschiff bzw.
Transportschiff) zeigen. Wie soll das denn gehen?“
Wir halten fest, dass ein Kampfschiff bzw. ein Transportschiff immer auch ein
Raumschiff ist. Das wird in der OOP eine ist-ein-Beziehung genannt. Deshalb
kann die Referenzvariable Raumschiff sowohl auf ein Kampfschiff, als auch auf
ein Transportschiff weisen. Natürlich hat die Basisklasse keine Kenntnis von
den Membern der Kindklasse(n) und kann aus diesem Grunde nicht auf sie
zugreifen. Doch schauen wir uns die Konsolen-Ausgabe einmal genauer an:
ID: Raumschiff. Fighter
ID: Raumschiff. Transporter
ID: Raumschiff. Raumschiff
Was erkennen wir? Nun, die ID-Kennung lautet in jedem Fall für alle drei
Raumschiffe Raumschiff. Ist das korrekt? Gemäß Programm-Code zwar eine
korrekte Ausgabe, doch nicht unbedingt gewollt. Es wird stets die Basisklassen-
Implementierung der Methode getID() aufgerufen und nicht die
79

entsprechende in der Kindklasse. Dieses Verhalten kommt deswegen zustande,
weil wir es mit einer statischen Bindung (early-binding) zu tun haben. Es steht
zur Entwicklungszeit schon fest, welche Methode an welches Objekt gebunden
ist. Doch wie erreichen wir den korrekten Aufruf der Kindklassen-Methode
getID()?
virtual und override
Die beiden Schlüsselwörter virtual und override helfen unserem Programm-
Code auf die Beine. Sie bewirken, dass wir über eine Basisklassenreferenz auf
eine Methode in der abgeleiteten Kindklasse Zugriff nehmen können. Dies wird
dynamische oder späte Bindung (late-binding) genannt. Die Methodenbindung
an ein Objekt steht erst zur Laufzeit des Programms zur Verfügung. Damit wir
wahre Polymorphie erleben, müssen zwei Modifikationen vorgenommen
werden:
1. Die Basisklassendefinition muss mit dem Schlüsselwort virtual versehen
werden
2. Die Kindklassendefinition muss mit dem Schlüsselwort override versehen
werden. Sie kennzeichnet das Überschreiben der Basisklassendefinition
Die Code-Änderungen lauten im Detail:
Jede betroffene Methode der Kindklasse muss mit dem Schlüsselwort override
versehen werden
80

Starten wir jetzt das Programm, erhalten wir die Konsolen-Ausgabe:
ID: Kampfschiff. Fighter
ID: Transportschiff. Transporter
ID: Raumschiff. Raumschiff
Sie sehen, dass jetzt die entsprechenden Methoden (ID: ...) der Kindklassen
aufgerufen werden. Fassen wir noch einmal die wichtigen Punkte für
Polymorphie zusammen:
♦ Die Basisklasse muss eine mit virtual deklarierte Methode besitzen
♦ In der abgeleiteten Klasse wird die gleichnamige Methode mit override
überschrieben
♦ Der Aufruf erfolgt über eine Basisklassenreferenz der Vererbungshierarchie
81

Statische Klassen
Sie haben sich sicherlich schon oft gefragt, warum die Methode Main() mit dem
Schlüsselwort static definiert wurde. Eingangs habe ich kurz erwähnt, dass es
nicht notwendig ist, für die Startmethode Main() eine Instanz zu generieren. Es
muss zu Beginn eines Programms einen initialen Mechanismus geben, von dem
aus alle weiteren Aktionen ausgehen. Am Anfang haben wir ja noch kein
einziges Objekt und Main wird als Einsprungpunkt genutzt. Sind wir erst
einmal in Main angekommen, können natürlich Objekte generiert werden. Es
gibt jedoch Anforderungen, die nicht notwendigerweise ein Objekt
voraussetzten. Ein Beispiel hierfür ist die Klasse Math.
Sie sehen in Zeile 18 den Aufruf der Methode Sqrt (Square-Root = Quadrat-
Wurzel) der Klasse Math. Es war demnach nicht notwendig zuvor eine Instanz
der Klasse Math zu bilden, um die Methode Sqrt nutzen zu können. Zudem
wurden keine Instanzvariablen zur Berechnung benötigt und es existieren auch
keine Methoden, die über gemeinsame Instanzvariablen möglicherweise Daten
austauschen. Warum also ein Objekt erschaffen, wenn nur die Methoden zu
nutzen sind? Schauen Sie sich das folgende Beispiel an, dass eine statische
Methode innerhalb der Klasse definiert, in der sich auch Main befindet.
82

Eleganter ist es natürlich, wenn Sie sich eine eigene Klasse schreiben, die alle
für Sie wichtigen Methoden zur Berechnung enthält. Das ist ungleich schwerer.
Hier sehen Sie den Code für die Klassendefinition:
83

Achten Sie darauf, dass Sie den Zugriffsmodifizierer public nicht vergessen.
Andernfalls wird die Methode implizit als private deklariert und Sie können sie
nicht aufrufen. Der Aufruf der Methode ist nicht weiter schwierig. Sie müssen
nur den Klassennamen dem Methodenaufruf voransetzten.
84

Konstruktoren
Dotty: „So wie ich die Sache sehe, benötigen wir zu Nutzung der statischen
Klassenelemente kein Objekt. Gibt es denn überhaupt Konstruktoren? Diese
werden eigentlich durch das Schlüsselwort new aufgerufen, was aber in
diesem Fall nicht möglich ist.“
Wir können auch hier einen Konstruktor verwenden. Dieser wird dann
aufgerufen, bevor die erste statische Methode aufgerufen wird oder eine Instanz
erstellt wurde.
85

Die Zeile 14 ruft erstmalig die statische Methode Mathe.Add() auf, was einen
vorherigen Aufruf des Konstruktors bedeutet. Die Konsolen-Ausgabe lautet:
Konstruktoraufruf.
7
54
Bedenken Sie, dass es sich in diesem Fall um eine Klassen-Methode handelt,
wogegen eine Methode eines real existierenden Objektes Objekt-Methode
genannt wird.
Eine Klasse kann sowohl Objekt-Methoden als auch Klassen-Methoden
beinhalten. Sie sollten jedoch wissen, dass Klassen-Methoden ausschließlich auf
statische Klassenelemente (statische Variablen bzw. Klassen-Methoden)
zugreifen können. Das folgende Beispiel einer Klassendefinition zeigt das
Problem, dass die Klassen-Methode getWert() auf eine Objekt-Variable
zugreifen möchte. Der Zugriff ist jedoch nur über eine Objekt-Referenz
(Verweis) möglich.
Die Fehlermeldung lautet:
86

Um dieses Zwitterverhalten von Klassen-Elementen und Objekt-Elementen zu
vermeiden, ist es möglich, eine Klasse komplett statisch zu deklarieren. Das hat
zur Folge, dass alle Klassen-Elemente ebenfalls statisch sein müssen. Erkennen
Sie, was das wiederum zur Folge hat? Es kann niemals eine einzige Instanz
dieser Klasse erstellt werden.
Dotty: „Ich sehe eigentlich keinen einzigen Grund, warum ich z.B. eine
statische Klassen-Variable und eine Objekt-Methode deklarieren sollte.“
Stellen wir uns vor, dass wir eine Klasse erstellt haben, von der mehrere Objekt-
Instanzen erstellt werden müssen. Sie wollen aber die Übersicht behalten, wie
viele Objekt-Instanzen erstellt wurden. Es ist also ein Zähler von Nöten, der die
einzelnen generierten Instanzen aufaddiert. Würden wir eine Objekt-Variable
innerhalb einer Klasse deklarieren, bekämen wir bei jeder neuen
Objektinstanziierung eine neue unabhängige Variable. Aus diesem Grund
nutzen wir eine Klassen-Variable, die mit static deklariert wurde. Sie ist Objekt
unabhängig und nur der Klasse verpflichtet und wird durch den Konstruktor der
Klasse bei jeder Instanziierung (Zeile 14, 15 und 16) inkrementiert.
87

Die Konsolen-Ausgabe lautet:
Anzahl der Instanzen: 3
Lassen Sie uns die gewonnen Erkenntnisse zusammenfassen:
♦ Der Zugriff auf statische Methoden und Variablen erfolgt über den
Klassennamen. Das folgende Beispiel zeigt den Zugriff auf die Klassen-
88

Methode Add()
♦ Statische Methoden können nur auf statische Variablen bzw. statische
Methoden zugreifen. Auf Instanz-Variablen bzw. Instanz-Methoden können
sie nicht zugreifen. Dafür wäre eine Objekt-Referenz bzw. ein Verweis
notwendig.
♦ Statische Konstruktoren werden vor dem ersten Aufruf einer statischen
Methode oder durch Instanziierung aufgerufen. Statische Konstruktoren
erlauben keine Parameter bzw. Zugriffsmodifizierer.
Globale Variablen
Wir können mit statischen Klassen z.B. globale Variablen simulieren, die es in
C# eigentlich gar nicht gibt. Fügen Sie einfach eine neue Klasse Ihrem Projekt
hinzu und deklarieren die Variable(n) darin als statisch. Gehen Sie wie folgt
vor, um eine neue Klasse dem aktuellen Projekt hinzuzufügen:
89

1. Aktuelles Projekt markieren + rechte Maustaste
2. Hinzufügen...
3. Neues Element
Im nachfolgenden Dialog
90

4. Die Klassenvorlage wählen
5. Einen eindeutigen Namen vergeben
6. Den Hinzufügen-Button klicken
Im Projektmappen-Explorer erscheint jetzt die neue Klasse:
91

Wechseln Sie mit einem Doppelklick auf den Eintrag in die Code-View der
Klasse und geben als Beispiel folgendes ein:
Anschließend können Sie in Ihrem Hauptprogramm auf die Klassenvariablen
zugreifen, indem Sie den Klassennamen plus Variablennamen verwenden.
IntelliSense bietet die öffentlichen Variablen der Klasse variables zur Auswahl
an. Sie können an jeder Stelle Ihres Programms auf diese Art und Weise
schreibend oder lesend zugreifen.
Main-Parameter
Vielleicht haben sich einige von Ihnen die Methode Main() ein wenig genauer
angeschaut und sich gewundert, warum innerhalb des runden Klammernpaares
etwas steht. Es sieht so aus, als ob wir der Methode etwas beim Start der
Anwendung übergeben könnten. Der Datentyp ist string und es handelt sich um
92

ein Array, was wir an den eckigen Klammern erkennen. Der Variablenname
args ist in diesem Fall willkürlich gewählt und bedeutet soviel wie Argumente.
Sicherlich haben Sie schon einmal das Programm copy bzw. xcopy innerhalb
der DOS-Box verwendet. Diese nützlichen Tools kopieren Dateien bzw.
Verzeichnisse von einem Speicherort zum anderen. Damit sie ihre Arbeit
erfolgreich ausführen können, sind mehrere zusätzliche Angaben erforderlich.
Was möchten Sie wohin kopieren. Nehmen wir z.B. copy. Sie müssen als erstes
Argument angeben, was sie kopieren möchten und als zweites wohin. Also
vielleicht:
copy c:\test.txt d:\info
Diese Befehlszeile kopiert die Datei test.txt der Partition c:\ in das Verzeichnis
info der Partition d:\.
Dotty: „Wie können wir aber aus der Entwicklungsumgebung heraus der
Anwendung einige Argumente übergeben?“
Ganz einfach! Im Projektmappen-Explorer klicken wir auf unser Projekt und
öffnen über die rechte Maustaste das Kontext-Menü und wählen dort den
Eintrag Eigenschaften. Danach wechseln wir in den Reiter Debuggen.
93

Sie erkennen auf der rechten Seite das Textfeld Befehlszeilenargumente. Dort
geben Sie die einzelnen Argumente durch Leerzeichen getrennt an. Wenden wir
uns jedoch jetzt wieder der Anwendung zu. Vorab habe ich folgende Einträge
vorgenommen:
Sie sehen, dass es sich um 3 Argumente handelt.
94

Die Funktion der foreach-Schleife sollte Ihnen bekannt sein. Sie durchläuft in
diesem Fall alle Elemente des Arrays args, wobei bei jedem einzelnen
Durchlauf das ermittelte Element in der Variablen strArgument abgelegt wird.
In Zeile 15 erfolgt die Ausgabe auf die Konsole, die da lautet:
C#
macht
Spass!
Sie können natürlich auch die alternative Möglichkeit mit einer for-Schleife
programmieren.
95

Zeile
Erklärung
14 Überprüfung, ob überhaupt Argumente übergeben wurden. Falls nicht, wird eine
Meldung auf der Konsole ausgegeben.
17, 18 Wurden Argumente übergeben (args.Length != 0), werden diese über eine for-Schleife
Tab. 13:
an die Konsole geschickt.
Code-Erläuterungen
Natürlich kann die Methode Main() auch einen Wert zurückliefern. Ersetzen Sie
einfach das Schlüsselwort void durch int.
Enumerationen
Sie haben kürzlich die Konstanten kennen gelernt. Es handelte sich dabei um
ein Sprachelement, welches einen Wert speichern kann und zur Laufzeit nicht
verändert werden darf. Enumerationen oder auch Aufzählungen sind ähnliche
Konstrukte. Eine Enumeration gruppiert mehrere Konstante, die zu einem
bestimmten Kontext gehören. Möchten Sie in Ihrem Programm z.B. die
Planeten unseres Sonnensystems ansprechen, so ist es möglicherweise etwas
umständlich und unübersichtlich, sie anhand ihrer Positionsnummer zu
benennen. Schauen Sie sich dazu das folgende Enumerations-Beispiel unseres
Sonnensystems an und nageln Sie mich bitte nicht darauf fest, dass ich nicht
alle neu hinzugekommenen Planeten, die erst kürzlich den Aufnahmetest
bestanden haben, auch noch aufführe. Pluto scheint ja nicht mehr dazu zu
gehören.
96

Zeile
Erklärung
9 - 20 Definition der Enumeration Sonnensystem vom Datentyp int
25 Deklaration der Variablen MeinSystem vom Typ Sonnensystem
27 Initialisierung der Variablen MeinSystem mit einem Wert aus der Auswahlliste
Tab. 14: Code-Erläuterungen
97

Die allgemeine Syntax für eine Enumeration lautet:
enum Name [:] { };
Wie Sie sehen, ist der angegebene Basisdatentyp optional. Lassen Sie ihn weg,
so wird standardmäßig der Datentyp auf int gesetzt. Es können nur die
ganzzahligen Datentypen byte, short, int und long verwendet werden. Sie sehen
in Zeile 11, dass ich der Konstanten Merkur explizit einen Wert zugewiesen
habe. Alle nachfolgenden Konstanten, also Venus, Erde, Mars usw., benötigen
eigentlich keine explizite Angabe eines Wertes, wenn dieser sich bei jeder
neuen Konstanten um den Wert 1 erhöhen soll. Dies geschieht implizit. Wir
hätten also auch
schreiben können. Wird bei dem ersten Element der Aufzählung kein
Initialisierungswert angeben, erhält dieses implizit den Wert 0 zugewiesen. Es
ist jedoch auch möglich, die Folge an einer beliebigen Stelle mit einem anderen
Wert fortsetzen zu lassen. Alle nachfolgenden Elemente werden bezogen auf
den neuen Startwert, wiederum jeweils um den Wert 1 erhöht.
98

Die Konstanten besitzen nach dieser Deklaration folgende Werte:
Konstante Wert Initialisierung
Melmac 17 Explizit
Eligor 18 Implizit
Mindrap 19 Implizit
Luginar 73 Explizit
Lemgos 74 Implizit
Eltar 75 Implizit
Die Enumeration hat im IntelliSense ein eigenes Icon:
Icon
Erklärung
Tab. 15:
Signalisiert, dass es sich um eine Enumeration handelt
Signalisiert, dass es sich um ein Element (Konstante) der Enumeration handelt
Iconerklärungen
Innerhalb von .NET sind etliche Enumerationen vorhanden, die Sie auf Schritt
und Tritt verfolgen. Das folgende Beispiel legt eine Hintergrundfarbe für die
Konsole fest, wobei die einzelnen Farben in einer Enumeration abgelegt sind.
99

Dotty: „Gibt es eine Möglichkeit, alle Elemente einer Enumeration mit ihren
Werten auszugeben?“
Elemente der Enumeration ausgeben
Sicherlich! Das folgende Codefragment schreibt alle Konstanten der
Enumeration Sonnensystem mit ihren Werten auf die Konsole:
100

Die Konsolen-Ausgabe lautet:
Element: Melmac Value: 17
Element: Eligor Value: 18
Element: Mindrap Value: 19
Element: Luginar Value: 73
Element: Lemgos Value: 74
Element: Eltar Value: 75
Dazu nutzen wir zwei Methoden der Struktur Enum, von der die
Aufzählungstypen abgeleitet werden.
101

Methode
Erklärung
GetValues() Liest die Werte der Konstanten einer
Enumeration aus. Rückgabe: Array
GetName()
Liefert bei angegebenem Wert den Namen der
Konstanten
Tab. 16: Methoden der Enum-Struktur
Werte der Konstanten ausgeben
Gehen wir die Sache mal im Detail durch. Die Methode GetValues() liefert
beim Aufruf ein Array mit den einzelnen Werten der definierten Konstanten
zurück.
Die Konsolen-Ausgabe lautet:
Value: 17
Value: 18
Value: 19
Value: 73
Value: 74
Value: 75
Sie sehen, dass alle in der Enumeration definierten Werte ausgegeben werden.
Dotty: „Was bedeutet das typeof(Sonnensystem)?“
102

Die Methode typeof() liefert eine Typbeschreibung eines Datentyps zurück.
Diese Typbeschreibung wird in der Methode GetValues() als Argument
übergeben.
Der Tooltip von GetValues() liefert einige wichtige Hinweise über den Typ
des Parameters und den Rückgabetyp.
Haben wir die Werte ermittelt, können wir mit Hilfe der Methode GetName()
den Namen der Konstanten erfahren, die sich dahinter verbirgt. Das folgende
kleine Programm fragt über die Konsole nach einem Wert und gibt
anschließend den passenden Konstantennamen aus.
Die Methode GetName() erwartet dabei zwei Parameter. Der erste ist der Typ
der Enumeration und der zweite der Konstantenwert, der zur Ermittlung des
Namens benötigt wird.
Konstantennamen ausgeben
Es existiert übrigens noch eine interessante Methode zur Ermittlung der
Konstantennamen. Wir sind bisher über die vorher ermittelten Werte zu den
103

Namen gelangt. Die Methode GetNames() liefert ein Array mit allen
Elementen der Enumeration zurück.
Die Konsolen-Ausgabe lautet:
Melmac
Eligor
Mindrap
Luginar
Lemgos
Eltar
Dotty: “Gibt es eine Möglichkeit herauszufinden, ob ein bestimmter Name in
einer Enumeration definiert wurde?”
Das ist machbar. Die Struktur Enum bietet dazu eine Methode mit Namen
IsDefined() an. Beachten Sie, dass bei der Übergabe des Namens an die
Methode die Schreibweise (Case-Sensitive) eine Rolle spielt.
104

Der vorliegende Code überprüft das Vorhandensein des Elements Lemgos in der
Enumeration Sonnensystem.
Basisdatentyp zur Laufzeit ermitteln
Dotty: „Können wir mit Hilfe einer Methode den Basisdatentyp einer
Enumeration zur Laufzeit ermitteln?“
Das ist mit der Methode GetUnderlyingType() möglich.
Die Konsolen-Ausgabe für unser Beispiel lautet:
System.Int32
Das ist der .NET-Laufzeittyp für den Datentyp int, der implizit für unsere
Enumeration vergeben wurde. Doch schauen wir uns zum Schluss noch ein
kurzes Anwendungsbeispiel an, wobei eine Methode genutzt wird, der wir ein
Argument übergeben. Das erwartete Argument ist eine Enumeration, so dass
sich die Auswahl über IntelliSense als sehr hilfreich und viel sagend erweist. Es
ist auf jeden Fall für einen Menschen einleuchtender bzw. verständlicher, eine
für sich sprechende Enumeration anzugeben, als irgendeinen nichts sagenden
Zahlenwert. Für das folgende Beispiel lege ich wieder die eingangs vorgestellte
Enumeration über unser Sonnensystem zugrunde. Die Methode gestaltet sich
folgendermaßen:
105

Sie sehen, dass der Parameter s vom Datentyp Sonnensystem ist. Dieser wird in
einer case-Anweisung auf den Inhalt überprüft und entsprechend verzweigt. Der
Einfachheit halber habe ich nur zwei Möglichkeiten zur Auswahl angeboten,
doch Sie sehen sicherlich sofort, worum es geht. Der Aufruf der Methode lautet
dann:
Ist doch fantastisch! IntelliSense bietet uns die zur Verfügung stehenden
Konstanten zur Auswahl an. Da gehören Tippfehler der Vergangenheit an und
Sie können sich sofort etwas unter den für sich sprechenden Konstanten
vorstellen.
106

Dotty: „Die Auswahl der Konstanten in der Enumeration entspricht in der
Reihenfolge aber nicht der in der Deklaration. Wie kommt das?“
Verantwortlich dafür ist die Entwicklungsumgebung, die die Einträge
alphabetisch sortiert. Das soll uns aber nicht weiter beunruhigen.
107