Methoden - Microsoft
Werbung
Datei: 08.doc, Seite115
31. Oktober 2006
Kapitel 8
Methoden
was eine Methode ist und wofür Sie sie benötigen
wie Sie eine Methode aufrufen
wie Sie eigene Methoden erstellen
wie Sie Methoden aus bestehendem Code extrahieren
was Methodenstubs sind
wie Sie Methoden überladen
8.1 Wozu werden Methoden benötigt?
Der Begriff Methode ist Ihnen in diesem Buch schon häufig begegnet. Bereits im ersten Beispiel in Kapitel 3 haben wir Sie mit den Methoden Main und WriteLine konfrontiert und Ihnen auf einer knappen Seite
die wichtigsten Informationen rund um Methoden geliefert. Dieser Vorgriff war gewissermaßen »aus
der Not geboren«, denn ohne Methoden können Sie in C# kein Programm erstellen. Auch in den Klassen, die wir in Kapitel 11 noch ausführlich vorstellen, sind immer Methoden enthalten.
Gut, jetzt wissen Sie, dass in C# ohne Methoden nichts geht. Aber die Frage nach der dahinter stehenden
Idee ist damit noch nicht geklärt. Die Antwort auf diese Frage hängt letztendlich mit der Arbeitsweise
des menschlichen Gehirns zusammen: Da das Gehirn schlicht und einfach nicht in der Lage ist, alle
Abläufe eines Programms im Detail zu erfassen, ist ein Programmierer gezwungen, komplexe Probleme
in viele kleine Teilaufgaben zu zerlegen. Von diesen Aufgaben muss er nicht immer wissen, wie sie im
Detail gelöst werden können, sondern er kann auf bestehende Lösungen zurückgreifen. Eine solche
Teilaufgabe erledigt zum Beispiel die Methode WriteLine. Die scheinbar simple Anweisung, etwas auf
dem Bildschirm auszugeben, ist technisch gesehen eine komplizierte Aufgabe, die einiges an Spezialwissen erfordert. Wenn sich jeder Programmierer mit diesem Wissen »belasten« müsste, wären moderne
Programme absolut undenkbar.
Methoden erstellen heißt also, ein Problem in sinnvolle Teilaufgaben zu zerlegen, die jede für sich betrachtet möglichst autark und überschaubar ist. Besonders bei Aufgaben, die in einem Programm mehrfach durchgeführt werden müssen, bietet sich das Erstellen einer Methode an. Der Code wird übersichtlicher und wartungsfreundlicher, da es im Idealfall keinen doppelten Code mehr gibt.
Visual C# 2005 Express Edition unterstützt dieses Konzept, indem es das Arbeiten mit Methoden sehr
komfortabel macht. Mit IntelliSense haben Sie bereits eine dieser Funktionen kennengelernt, andere wie
Methodenstubs und das Extrahieren von Methoden werden wir Ihnen im weiteren Verlauf des Kapitels
noch vorstellen.
115
Probekapitel aus "Programmieren lernen mit Visual C# 2005", Microsoft Press. Klicken Sie hier um das Buch zu kaufen.
Beispielcode zu diesem Kapitel finden sie auf der Website zu diesem Buch und der Reihe "Richtig Einsteigen"
III – Konzepte der OOP
In diesem Kapitel lernen Sie
Datei: 08.doc, Seite116
31. Oktober 2006
Kapitel 8
Methoden
8.2 Eigene Methoden erstellen
Damit wir die Praxis nicht aus den Augen verlieren, wollen wir Ihnen zunächst ein kurzes Beispiel vorstellen, bevor wir gleich näher auf die Syntax von Methoden eingehen. In einigen der bisherigen Beispielprogramme sollte der Anwender eine Zahl eingeben, die dann auf verschiedene Art und Weise
weiterverarbeitet wurde. Dazu mussten die Programme jeweils mehrere Aufgaben erledigen:
Anzeigen einer Eingabeaufforderung
Einlesen der Eingabe des Anwenders
Umwandeln der Eingabe in einen Integerwert
In Programmen, die die Eingabe von zwei Zahlen erforderten, haben wir den entsprechenden Code
sogar doppelt eingegeben (z. B. bei unserem Minirechner aus Kapitel 6). Hier drängt sich die Erstellung
einer Methode geradezu auf.
Bevor Sie eine neue Methode anlegen, müssen Sie sich zunächst genau überlegen, welches Ergebnis die
Methode erzielen soll und welche Informationen sie zu diesem Zweck benötigt. In unserem Fall liegt die
Sache recht einfach:
Die Methode soll zuerst eine Eingabeaufforderung anzeigen. Der dazu benötigte Text wird ihr beim
Aufruf übergeben.
Anschließend soll sie die Eingabe des Anwenders entgegennehmen.
Im nächsten Schritt soll die Eingabe in einen Integerwert umgewandelt werden. Wenn diese Umwandlung fehlschlägt, soll die Methode so tun, als ob der Anwender eine Null (0) eingegeben hat.
Als letzte Aktion soll die Methode die eingegebene Zahl zurückgeben.
Nach diesen gedanklichen Vorarbeiten können wir mit der praktischen Umsetzung beginnen:
1. Erstellen Sie ein Projekt vom Typ Konsolenanwendung und geben Sie ihm den Namen Methoden.
2. Tippen Sie unterhalb der main-Methode folgenden Code ein:
private static int LeseZahl(string s)
{
}
Sie haben jetzt eine leere Methode mit dem Namen LeseZahl erstellt, die einen Parameter vom Typ
String erwartet und als Ergebnis einen int-Wert liefert.
3. Fügen Sie nun innerhalb der geschweiften Klammern den eigentlichen Programmcode der neuen
Methode ein:
private static int LeseZahl(string s)
{
string eingabe;
int ret;
// Diese Variablen werden innerhalb der Methode benötigt
Console.Write(s);
eingabe = Console.ReadLine();
// Eingabeaufforderung anzeigen
// Eingabe entgegennehmen
try
{
ret = int.Parse(eingabe);
}
// Eingabe in einen int-Wert umwandeln (mit Fehlerbehandlung)
116
Probekapitel aus "Programmieren lernen mit Visual C# 2005", Microsoft Press. Klicken Sie hier um das Buch zu kaufen.
Beispielcode zu diesem Kapitel finden sie auf der Website zu diesem Buch und der Reihe "Richtig Einsteigen"
Datei: 08.doc, Seite117
31. Oktober 2006
8.2 Eigene Methoden erstellen
catch (FormatException)
{
ret = 0;
}
return ret;
// Ergebnis der Methode zurückliefern
}
Da Sie den Code bereits aus den letzten Kapiteln kennen, verzichten wir an dieser Stelle auf eine
nähere Erläuterung. Damit ist die Erstellung der Methode abgeschlossen und die Methode steht für
ihren ersten Einsatz bereit.
4. Fügen Sie nun in die main-Methode die folgenden Codezeilen ein. Nutzen Sie die IntelliSense-
Funktion, um den Namen der Methode einzugeben (siehe nächstes Bild):
int i, j;
i = LeseZahl("Bitte geben Sie die erste Zahl ein: ");
j = LeseZahl("Bitte geben Sie die zweite Zahl ein: ");
III – Konzepte der OOP
Console.WriteLine("Die größere Zahl ist: {0}", i > j ? i : j);
Abbildung 8.1: IntelliSense hat die neue Methode sofort erkannt und bietet sie in der Auswahlliste an.
Sehen Sie, wie aufgeräumt und übersichtlich der Code der main-Methode geworden ist? Die Funktionsweise des Programms lässt sich auf einen Blick erkennen, da der Code dank der neuen Methode von »störenden« Detailproblemen befreit wurde.
5. Starten Sie das Programm mit Strg+F5 und prüfen Sie, ob es die erwarteten Ergebnisse liefert.
Den vollständigen Code finden Sie im Beispielprojekt Kap08\Methoden in dem Ordner, in den die Beispiele für dieses Buch installiert wurden.
Methoden dokumentieren
Wenn Sie sich das letzte Bild genau angesehen haben, ist Ihnen vielleicht aufgefallen, dass im Tooltipp
neben dem Methodennamen lediglich der Rückgabetyp und eine Liste der Parameter enthalten sind.
Üblicherweise finden Sie in den Tooltipps der IntelliSense-Funktion aber zusätzlich noch eine kurze
Beschreibung des ausgewählten Elements. Diesen Komfort können Sie mit minimalem Aufwand auch
für Ihre selbst erstellten Methoden bereitstellen. Und wie Sie gleich sehen werden, übernimmt die IDE
einen Großteil der Tipparbeit für Sie:
117
Probekapitel aus "Programmieren lernen mit Visual C# 2005", Microsoft Press. Klicken Sie hier um das Buch zu kaufen.
Beispielcode zu diesem Kapitel finden sie auf der Website zu diesem Buch und der Reihe "Richtig Einsteigen"
Datei: 08.doc, Seite118
31. Oktober 2006
Kapitel 8
Methoden
1. Setzen Sie die Einfügemarke über die Zeile
private static int LeseZahl(string s)
2. Geben Sie dort drei Schrägstriche ein, also ///. Sobald Sie den dritten Schrägstrich eingetippt haben,
fügt die IDE automatisch diese Zeilen ein:
///
///
///
///
///
<summary>
</summary>
<param name="s"></param>
<returns></returns>
Dies ist das Grundgerüst für die Methodenbeschreibung, wie sie normalerweise in den Tooltipps
angezeigt wird. Wir wollen an dieser Stelle nicht weiter auf die technischen Hintergründe dieser
Anweisungen eingehen, sondern lediglich zeigen, wie solche Kommentare erstellt werden. In Kapitel 11 werden wir noch einmal ausführlich auf dieses Thema zurückkommen.
3. Ergänzen Sie die neuen Zeilen wie folgt:
///
///
///
///
///
<summary>
Zeigt eine Eingabeaufforderung an und liest eine Ganzzahl ein.
</summary>
<param name="s">Eingabeaufforderung</param>
<returns>Die eingelesene Ganzzahl oder 0, wenn keine Zahl eingegeben wurde.
</returns>
4. Geben Sie in der main-Methode den Anfang der Anweisung i = LeseZahl("Ihre Eingabe: "); ein und
achten Sie dabei auf den Tooltipp der IntelliSense-Funktion.
Abbildung 8.2: IntelliSense zeigt jetzt auch die Beschreibung der Methode an.
5. Vervollständigen Sie die Anweisung und achten Sie diesmal auf den Tooltipp, der nach dem Ein-
tippen der runden Klammer erscheint:
Abbildung 8.3: Auch die Parameterbeschreibung wurde von IntelliSense erkannt.
Nutzen Sie dieses Feature in Ihren eigenen Methoden unbedingt. Das (zugegeben lästige) Kommentieren und Dokumentieren von Programmcode war wirklich noch nie so einfach wie mit dieser Entwicklungsumgebung!
118
Probekapitel aus "Programmieren lernen mit Visual C# 2005", Microsoft Press. Klicken Sie hier um das Buch zu kaufen.
Beispielcode zu diesem Kapitel finden sie auf der Website zu diesem Buch und der Reihe "Richtig Einsteigen"
Datei: 08.doc, Seite119
31. Oktober 2006
8.3 Die allgemeine Syntax von Methoden
8.3 Die allgemeine Syntax von Methoden
Nach diesem Ausflug in die Praxis wollen wir uns nun die Syntax einer Methode näher ansehen, die
ganz allgemein so aussieht (die erste Zeile wird übrigens als Methodensignatur bezeichnet):
Zugriffsmodifizierer Rückgabetyp Methodenname(Parameterliste)
{
// Methodenkörper (Anweisungen der Methode)
}
Wenn man dieser Syntax die Definition der Methode LeseZahl() gegenüberstellt, lassen sich die verschiedenen Elemente leicht zuordnen:
private static int LeseZahl(string s)
{
string eingabe;
...
return ret;
}
Zugriffsmodifizierer
Mit dem Zugriffsmodifizierer können Sie festlegen, von wo aus eine Methode aufgerufen werden kann:
Methoden, die als private gekennzeichnet sind, können nur innerhalb ihrer eigenen Klasse aufgerufen werden und sind außerhalb ihrer Klasse sozusagen »unsichtbar«. Dies ist gleichzeitig der Standardzugriffsmodus, d. h. wenn eine Methodendefinition keinen Zugriffsmodifizierer enthält, ist die
Methode private. Sie sollten allerdings nicht mit diesem Automatismus arbeiten, sondern immer
explizit angeben, wie auf die Methode zugegriffen werden kann.
Methoden, die als public gekennzeichnet sind, lassen sich aus allen anderen Klassen aufrufen.
Der Zugriffsmodifizierer internal legt fest, dass die Methode innerhalb der gesamten Assembly, also
des aktuellen Programms, aufgerufen werden kann.
Der vierte Modifizierer nennt sich protected und wird im Zusammenhang mit Vererbung eingesetzt. Er bestimmt, dass eine Methode nicht nur aus ihrer eigenen Klasse, sondern auch aus den von
ihr abgeleiteten Klassen aufgerufen werden kann.
Der Zugriffsmodifizierer kann zusätzlich noch mit dem Schlüsselwort static kombiniert werden. Statische Methoden sind nicht an die Existenz eines Objekts gebunden und können direkt aufgerufen werden. Einige bekannte statische Methoden, die Sie in den Beispielen dieses Buches schon häufig eingesetzt
haben, sind Write(), WriteLine(), Read() und ReadLine(). Wenn Sie zum Beispiel folgenden Methode
definieren:
public static double Kreisfläche(double radius)
{
return radius * radius * Math.PI;
}
können Sie sie anschließend aus einer beliebigen Klasse (da public) mit folgender Anweisung aufrufen:
fläche = Kreisfläche(radius);
119
Probekapitel aus "Programmieren lernen mit Visual C# 2005", Microsoft Press. Klicken Sie hier um das Buch zu kaufen.
Beispielcode zu diesem Kapitel finden sie auf der Website zu diesem Buch und der Reihe "Richtig Einsteigen"
III – Konzepte der OOP
In den folgenden Abschnitten gehen wir nun im Detail auf die einzelnen Bestandteile einer Methode ein.
Datei: 08.doc, Seite120
31. Oktober 2006
Kapitel 8
Methoden
Erstellen Sie hingegen eine Methode ohne das Schlüsselwort static, müssen Sie für den Zugriff auf die
Methode erst ein Objekt der Klasse erstellen, in der sich die Methode befindet, und können dann über
diese Objektvariable auf die Methode zugreifen:
Klassenname objVariable = new Klassenname();
double radius;
double umfang;
...
umfang = objVariable.Kreisumfang(radius);
// Objektvariable der Klasse "Klassenname" erzeugen
In diesem Kapitel ist das Schlüsselwort static jedoch nicht mehr als eine Randerscheinung, die wir nur
der Vollständigkeit halber erwähnt haben. In Kapitel 11, wenn wir uns mit dem Thema Klassen beschäftigen, werden wir auf diese Zusammenhänge noch näher eingehen.
Rückgabewert
In den meisten Fällen soll eine Methode dem aufrufenden Code ein Ergebnis liefern. Dieses Ergebnis
wird als Rückgabewert bezeichnet und muss immer den bei der Methodendefinition festgelegten Datentyp besitzen. (Die Syntax einer Methodendefinition finden Sie auf Seite 119.) Soll eine Methode keinen
Rückgabewert besitzen, wird dies durch das Schlüsselwort void kenntlich gemacht, das Ihnen bereits in
einigen der letzten Beispiele begegnet ist.
Damit der Rückgabewert den aufrufenden Code erreicht, muss innerhalb der Methode eine returnAnweisung ausgeführt werden, die den gewünschten Datentyp liefert. Die folgende Funktion lässt sich
zum Beispiel nicht kompilieren, da der Rückgabewert der Methode den Datentyp string besitzt, die
return-Anweisung jedoch ein int liefert:
Abbildung 8.4: Die return-Anweisung liefert den falschen Datentyp.
Die return-Anweisung beendet automatisch die Ausführung einer Methode. Alle Anweisungen, die
hinter einer return-Anweisung stehen, werden daher nicht ausgeführt und lösen beim Kompilieren die
Warnung Unerreichbarer Code wurde entdeckt! aus:
private int GetMinimum(int ErsteZahl, int ZweiteZahl)
{
return (ErsteZahl <= ZweiteZahl) ? ErsteZahl : ZweiteZahl;
Console.WriteLine("Aufruf von GetMinium() erfolgreich!");
}
// Diese Zeile kann nie erreicht werden
Diese Einschränkung gilt natürlich nicht für Anweisungen, die zwar unterhalb der aktuellen returnAnweisung stehen, sich aber in einem Anweisungsblock befinden, zu dem die Programmausführung
ohnehin nicht mehr gelangen könnte. Die folgende Methode ist also aus Sicht des Compilers völlig
korrekt:
120
Probekapitel aus "Programmieren lernen mit Visual C# 2005", Microsoft Press. Klicken Sie hier um das Buch zu kaufen.
Beispielcode zu diesem Kapitel finden sie auf der Website zu diesem Buch und der Reihe "Richtig Einsteigen"
Datei: 08.doc, Seite121
31. Oktober 2006
8.3 Die allgemeine Syntax von Methoden
private double GetMinimum(double ErsteZahl, double ZweiteZahl)
{
if (ErsteZahl <= ZweiteZahl)
{
return ErsteZahl;
}
else
{
return ZweiteZahl;
}
}
Methodenname
Auch wenn zwei Methoden eine ähnliche Aufgabe erfüllen, sollte dies an ihren Namen zu erkennen sein.
Wenn Sie zum Beispiel zusätzlich zur Methode LeseZahl() noch eine weitere Methode schreiben würden, die den Anwender auffordert, einen Text einzugeben, sollten Sie ihr einen Namen wie LeseString()
oder LeseZeichenkette() geben; Namen wie ZeichenketteHolen() oder GetString() wären hingegen eher
ungeeignet, da sie durch die andere Wortwahl auch eine andere Funktionsweise implizieren. In umfangreichen Projekten sind durchdachte Namen für Variablen und Methoden von unschätzbarem Wert. Sie
tragen entscheidend dazu bei, dass der Programmcode wartbar bleibt. (Wer jemals ein altes FortranProgramm gesehen hat, in denen Variablennamen selten länger als vier Buchstaben sind und ihr Anfangsbuchstabe gleichzeitig über ihren Datentyp entscheidet, weiß, wovon wir sprechen.)
Parameter
Parameter dienen dazu, einer Methode bei ihrem Aufruf Informationen bzw. Daten zu übergeben. Dazu
muss in der Methodendefinition innerhalb der runden Klammern für jeden Parameter dessen Datentyp
und sein Name angegeben werden. Bei mehreren Parametern werden die Angaben durch Kommata
voneinander getrennt. Soll die Methode keinen Parameter erhalten, bleiben die runden Klammern leer.
Im Methodenkörper können Sie über die Parameternamen auf die übergebenen Daten zugreifen. Dazu
ist es in der Regel sinnvoll, den Parametern aussagekräftige Namen zu geben. Die Verwendung eines
einzelnen Buchstabens, wie im obigen Beispiel, ist zwar durchaus üblich, eignet sich aber nur für kurze,
überschaubare Methoden. Bedenken Sie auch, dass der Parametername im Tooltipp der IntelliSenseFunktion angezeigt wird (siehe Bild 8.1) und auch hier wertvolle Dienste leisten kann.
Beim Aufruf der Methode müssen die Anzahl, die Reihenfolge und die Datentypen der Parameter zwingend eingehalten werden. Es ist auch nicht wie in einigen anderen Sprachen erlaubt, einzelne Parameter
auszulassen. Dass C# an dieser Stelle so restriktiv ist, hängt mit dem Konzept der Überladung von Methoden zusammen, auf das wir weiter unten noch zu sprechen kommen.
121
Probekapitel aus "Programmieren lernen mit Visual C# 2005", Microsoft Press. Klicken Sie hier um das Buch zu kaufen.
Beispielcode zu diesem Kapitel finden sie auf der Website zu diesem Buch und der Reihe "Richtig Einsteigen"
III – Konzepte der OOP
Für den Namen einer Methode gelten die gleichen formalen Regeln wie für Variablen, die wir Ihnen im
vierten Kapitel vorgestellt haben. Dort haben wir auch erwähnt, dass die Entwurfsrichtlinien für das
.NET Framework vorsehen, dass Namen von öffentlichen Methoden mit einem Großbuchstaben
:beginnen (Pascal-Schreibweise). Darüber hinaus sollten Sie bei der Namensgebung darauf achten, dass
der Name einer Methode einen deutlichen Hinweis auf ihre Funktionalität liefert.
Datei: 08.doc, Seite122
31. Oktober 2006
Kapitel 8
Methoden
Eine wichtige Frage, die es noch im Zusammenhang mit Parametern zu klären gilt, ist die folgende: Was
passiert eigentlich, wenn eine Methode einen Parameter verändert? Betrifft diese Änderung das aufrufende Programm oder nicht? Nun, probieren Sie es doch einfach mal aus:
1. Erstellen Sie ein neues Projekt und geben Sie ihm den Namen Parameter.
2. Schreiben Sie eine Methode Quadrat, die einen int-Wert als Parameter erwartet und sein Quadrat
als Ergebnis liefert. Beachten Sie, dass der Parameter zahl innerhalb der Methode geändert wird:
private static int Quadrat(int zahl)
{
zahl *= zahl;
return zahl;
}
3. Fügen Sie in die main-Methode folgende Anweisungen ein.
int z = 2;
Console.WriteLine("{0} ist die Quadratzahl von {1}.", Quadrat(z), z);
4. Starten Sie das Programm mit Strg+F5 und sehen Sie sich die Ausgabe des Programms an.
Das Ergebnis der WriteLine-Methode lautet 4 ist die Quadratzahl von 2. Wie Sie sehen, hat die Veränderung des Parameters zahl innerhalb der Methode Quadrat keinen Einfluss auf die Variable z der mainMethode, die wir für die Parameterübergabe verwendet haben. Parameter werden in C# nämlich als
Wert übergeben, d. h. die Methode erhält eine Kopie der Variable z. Alle Änderungen an der methodeninternen Variablen haben dadurch keinen Einfluss auf das Original.
Mit dieser Information im Hinterkopf starten wir nun unseren nächsten Versuch:
1. Erstellen Sie ein neues Projekt und geben Sie ihm den Namen VorsichtFalle.
2. Schreiben Sie wieder eine Methode Quadrat, die diesmal eine Array-Variable als Parameter erwar-
tet. Das übergebene Array soll mit Quadratzahlen gefüllt werden. Als Ergebnis soll die Methode einen String mit allen Quadratzahlen liefern:
private static string Quadrat(int[] zahlen)
{
string quadratzahlen = "";
// nimmt den Rückgabewert auf
for (int i = 0; i < zahlen.Length; i++)
// Array mit Quadratzahlen füllen
{
zahlen[i] = (i+1) * (i+1);
quadratzahlen = quadratzahlen + zahlen[i] + " ";
}
return quadratzahlen;
}
3. Erweitern Sie die main-Methode mit den im folgenden Listing fett gedruckten Anweisungen.
static void Main(string[] args)
{
// lokales Array definieren
int[] leeresArray = new int[10];
// Methode aufrufen und lokales Array übergeben
Console.WriteLine("Rückgabe der Methode: {0}", Quadrat(leeresArray));
122
Probekapitel aus "Programmieren lernen mit Visual C# 2005", Microsoft Press. Klicken Sie hier um das Buch zu kaufen.
Beispielcode zu diesem Kapitel finden sie auf der Website zu diesem Buch und der Reihe "Richtig Einsteigen"
Datei: 08.doc, Seite123
31. Oktober 2006
8.3 Die allgemeine Syntax von Methoden
// Inhalt des lokalen Arrays anzeigen
Console.WriteLine("\nInhalt des lokalen Arrays:");
foreach (int i in leeresArray)
Console.Write("{0} ", i);
Console.WriteLine();
}
Mit diesem Code wird zunächst ein Array aus zehn int-Werten definiert, das durch die automatische Initialisierung anschließend vollständig mit Nullen (0) gefüllt ist. Dieses Array wird dann der
Methode Quadrat übergeben, die als Ergebnis eine Zeichenkette mit den ersten zehn Quadratzahlen liefern müsste. Zum Schluss wird noch geprüft, ob das lokale Array durch den Aufruf der Methode wirklich nicht verändert wurde.
III – Konzepte der OOP
4. Starten Sie das Programm mit Strg+F5 und sehen Sie sich seine Ausgabe an.
Abbildung 8.5: Die Methode Quadrat hat das lokale Array verändert!
Hoppla, irgendwie hat es die Methode doch geschafft, das Array zu verändern. Dabei hatten wir doch
gesagt, dass Methodenparameter eine Kopie der übergebenen Daten erhalten und das Original daher
nicht verändern können. Haben Sie eine Idee, wo wir Sie in diesem Beispiel aufs Glatteis geführt haben?
Des Rätsels Lösung ist eigentlich gar nicht so kompliziert: In unserem ersten Beispiel hat die Methode
Quadrat über die Variable zahl einen int-Wert als Parameter erhalten. Bei diesem Datentyp handelt es
sich um einen Werttyp. Eine Kopie der Variable enthält daher den gleichen Wert wie die Variable selbst.
Ganz anders verhält es sich im zweiten Beispiel. Der Parameter der Methode ist diesmal ein Array, also
ein Verweistyp! Die Methode erhält zwar tatsächlich eine Kopie der Variablen leeresArray, aber dabei
handelt es sich ja nur um den Verweis auf den Speicherbereich der Array-Elemente und nicht um die
Elemente selbst. Die Methode arbeitet also mit einem kopierten Verweis, der exakt auf den gleichen
Speicherbereich verweist wie sein Original.
Sie sehen also, wie wichtig es ist, dass Sie den Unterschied zwischen Wert- und Verweistypen kennen
und beachten.
123
Probekapitel aus "Programmieren lernen mit Visual C# 2005", Microsoft Press. Klicken Sie hier um das Buch zu kaufen.
Beispielcode zu diesem Kapitel finden sie auf der Website zu diesem Buch und der Reihe "Richtig Einsteigen"
Datei: 08.doc, Seite124
31. Oktober 2006
Kapitel 8
Methoden
Besonderheiten bei string-Variablen
Obwohl der Datentyp string ein Verweistyp ist, verhält sich eine string-Variable, die Sie einer
Methode als Argument übergeben, wie ein Werttyp. Das heißt, wenn Sie innerhalb der Methode die String-Variable ändern, hat das keine Auswirkung auf die Variable im aufrufenden
Programmcode. Dieses auf den ersten Blick merkwürdige Verhalten hängt mit einer besonderen Eigenschaft von string-Variablen zusammen: Sie können ein string-Objekt nicht verändern! Jede Änderung einer string-Variable löst in Wirklichkeit die Erzeugung eines neuen
string-Objekts aus. Wenn Sie also in einer Methode ein string-Argument verändern, erzeugen
Sie unbemerkt ein neues string-Objekt, ohne dass dabei das string-Objekt des aufrufenden
Codes beeinflusst wird.
ref-Parameter
Sie können Parameter aber auch als Verweis an eine Methode übergeben. In diesem Fall kann die Methode direkt auf die Variable des aufrufenden Codes zugreifen. Dazu müssen Sie dem Parameter sowohl
in der Methodendefinition als auch beim Aufruf der Methode das Schlüsselwort ref voranstellen. Außerdem muss der entsprechenden Variablen vor dem Aufruf der Methode ein Wert zugewiesen werden:
static void Main(string[] args)
{
string s = "“;
Wochentag(ref s);
Console.WriteLine("Heute ist {0}", s);
}
private static void Wochentag(ref string wochentag)
{
wochentag = DateTime.Now.ToString("dddd“);
}
In diesem Beispiel wird die Variable s zunächst mit einer leeren Zeichenkette initialisiert. Anschließend
wird beim Aufruf der Methode Wochentag eine Referenz auf diese Variable übergeben. Dadurch verweisen nun die beiden Variablen s und wochentag auf das gleiche String-Objekt. Wenn dann innerhalb der
Methode eine Zuweisung an die Variable wochentag erfolgt, hat dies die gleiche Wirkung als ob die Zuweisung direkt im aufrufenden Code mit der Variablen s vorgenommen würde.
out-Parameter
Eine Methode kann normalerweise nur genau einen Rückgabewert liefern. Gelegentlich soll eine Methode aber auch mehrere Ergebnisse liefern können. Natürlich ließe sich das auch indirekt über refParameter lösen, da eine Methode auf diesem Weg ihre Ergebnisse direkt im aufrufenden Code ablegen
könnte. Und in der Tat geht C# auch genau diesen Weg. Allerdings wird in diesen Fällen anstelle des
Schlüsselwortes ref das Schlüsselwort out verwendet (für output).
Die Wirkungsweise von out ist mit der von ref bis auf zwei wichtige Ausnahmen identisch:
Die als Argument übergebenen Variablen müssen nicht initialisiert sein.
Die Methode muss(!) dem Parameter einen Wert zuweisen.
124
Probekapitel aus "Programmieren lernen mit Visual C# 2005", Microsoft Press. Klicken Sie hier um das Buch zu kaufen.
Beispielcode zu diesem Kapitel finden sie auf der Website zu diesem Buch und der Reihe "Richtig Einsteigen"
Datei: 08.doc, Seite125
31. Oktober 2006
8.3 Die allgemeine Syntax von Methoden
Unter Verwendung eines out-Parameters sähe das letzte Beispielprogramm also folgendermaßen aus:
static void Main(string[] args)
{
string s;
Wochentag(out s);
Console.WriteLine("Heute ist {0}", s);
}
private static void Wochentag(out string wochentag)
{
wochentag = DateTime.Now.ToString("dddd“);
}
Die einzigen Änderungen sind demnach die fehlende Initialisierung der Variablen s und die Verwendung des Schlüsselwortes out anstelle von ref.
Es gibt gelegentlich Situationen, in denen sich für eine Methode die Anzahl der zur Laufzeit benötigten
Parameter nicht im Voraus festlegen lässt. Denken Sie zum Beispiel an die Methode WriteLine(), bei der
die Anzahl der Parameter von der Anzahl der verwendeten Platzhalter abhängt:
Console.WriteLine("H = {0}, B = {1}, T = {2}", höhe, breite, tiefe);
Für solche Fälle gibt es in C# das Schlüsselwort params, das einen Parameter in die Lage versetzt, beliebig
viele Argumente entgegenzunehmen. Allerdings darf dieses Schlüsselwort in einer Methodendefinition
nur ein einziges Mal verwendet werden, und es muss sich dabei um den letzten Parameter handeln.
Ein möglicher Anwendungsfall für params wäre zum Beispiel eine Methode, der Sie beliebig viele intWerte übergeben können, und die dann die größte dieser Zahlen zurückgibt. Die entsprechende Methodendefinition sähe dann etwa so aus:
public static int GrößterWert(int zahl1, int zahl2, params int[] zahlen)
{
// Code der die größte übergebene Zahl ermittelt
}
Der Methode müssen mindestens zwei Argumente übergeben werden (zahl1 und zahl2), denn ansonsten macht die Ermittlung des Maximums wenig Sinn. Wie Sie sehen, besitzt der dritte Parameter den
Datentyp int[], er ist also ein Array aus int-Werten. Bekanntlich können Arrays aber sowieso beliebig
viele Elemente enthalten, wozu ist also noch das Schlüsselwort params nötig? Nun, der wichtige Unterschied ist, dass der dritte Parameter durch die Verwendung von params optional wird. Das heißt, Sie
können ihm beim Aufruf der Methode wahlweise Argumente übergeben oder ihn vollständig ignorieren. Ein weiterer Unterschied ergibt sich beim Aufruf der Methoden, doch darauf kommen wir gleich
noch zurück.
Innerhalb der Methode können Sie mit der gewohnten Array-Syntax auf die optionalen Argumente
zugreifen. Für unser Beispiel bietet sich der Einsatz einer foreach-Schleife an:
public static int GrößterWert(int zahl1, int zahl2, params int[] zahlen)
{
int maximum;
125
Probekapitel aus "Programmieren lernen mit Visual C# 2005", Microsoft Press. Klicken Sie hier um das Buch zu kaufen.
Beispielcode zu diesem Kapitel finden sie auf der Website zu diesem Buch und der Reihe "Richtig Einsteigen"
III – Konzepte der OOP
params-Parameter
Datei: 08.doc, Seite126
31. Oktober 2006
Kapitel 8
Methoden
// zunächst die beiden ersten Parameter auswerten
maximum = zahl1 > zahl2 ? zahl1 : zahl2;
// jetzt alle Elemente des Parameterarrays prüfen
foreach (int i in zahlen)
if (i > maximum)
{
maximum = i;
}
return maximum;
}
Nachdem die Methode implementiert ist, stellt sich natürlich als nächstes die Frage, wie die Methode
aufgerufen wird. Müssen die optionalen Argumente als Array angegeben werden oder gibt es noch andere Varianten? Wenn Sie wieder an die Methode WriteLine() denken, kennen Sie zumindest schon einen
Teil der Antwort: Die optionalen Argumente werden im einfachsten Fall wie ganz normale Parameter
übergegeben:
Console.WriteLine(GrößterWert(1, 2, 3, 4, 5, 6, 7, 8, 9));
Und mit dieser Schreibweise haben Sie bereits den zweiten Vorteil von params gegenüber einem normalen Array kennengelernt. Einem Array-Parameter müssen Sie auch auf jeden Fall ein Array übergeben.
Die korrekte Schreibweise sähe dann zum Beispiel so aus:
int[] zahlen = {3, 4, 5, 6, 7, 8, 9};
Console.WriteLine(GrößterWert(1, 2, zahlen));
oder kürzer:
Console.WriteLine(GrößterWert(1, 2, new int[] {3, 4, 5, 6, 7, 8, 9}));
Das params Schlüsselwort macht Ihren Code also auch weniger umständlich und besser lesbar.
8.4 Refactoring Tools für Methoden
In diesem Abschnitt möchten wir Sie mit zwei weiteren bemerkenswerten Features der IDE aus der
Abteilung Komfort bekannt machen: den Methodenstubs und dem Extrahieren von Methoden. Beide
Funktionen beschleunigen das Erstellen von Methoden erheblich, entlasten Sie von lästiger Tipparbeit
und erhöhen so Ihre Produktivität.
Methodenstubs
Unter einem Methodenstub versteht man bei Visual C# 2005 Express Edition ein leeres Methodengerüst. Die dahinter stehende Idee geht von folgendem Szenario aus: Sie sind dabei, Code zu schreiben und
merken soeben, dass Sie für die nächste Teilaufgabe am besten eine neue Methode erstellen sollten.
Normalerweise würden Sie jetzt wahrscheinlich Ihren aktuellen Denkprozess unterbrechen und mit dem
Implementieren der benötigten Methode beginnen. Mit Methodenstubs vermeiden Sie diese störende
Ablenkung und können weiterhin konzentriert an Ihrem ursprünglichen Codeproblem arbeiten. Wie
das funktioniert? Probieren Sie es aus!
126
Probekapitel aus "Programmieren lernen mit Visual C# 2005", Microsoft Press. Klicken Sie hier um das Buch zu kaufen.
Beispielcode zu diesem Kapitel finden sie auf der Website zu diesem Buch und der Reihe "Richtig Einsteigen"
Datei: 08.doc, Seite127
31. Oktober 2006
8.4 Refactoring Tools für Methoden
1. Erstellen Sie ein neues Projekt vom Typ Konsolenanwendung und geben Sie ihm den Namen
Stubs. Das Programm soll den Anwender zur Eingabe einer Ganzzahl auffordern und anschließend
deren Quersumme berechnen und anzeigen.
2. Fügen Sie in die Main-Methode zunächst die Deklaration zweier Variablen ein, die die Eingabe des
Anwenders und die daraus ermittelte Quersumme aufnehmen sollen.
l
o
n
ge
i
n
g
a
b
e
;
i
n
tq
u
e
r
s
u
m
m
e
;
3. Jetzt müssten Sie den Code schreiben, mit dem Sie eine Eingabeaufforderung anzeigen und die
Eingabe des Anwenders entgegennehmen können. Stattdessen tun Sie einfach so, als ob bereits eine
Methode existieren würde, die genau diese Aufgabe erledigt. Schreiben Sie also:
e
i
n
g
a
b
e=L
e
s
e
L
o
n
g
w
e
r
t
(
"
G
e
b
e
nS
i
eb
i
t
t
ee
i
n
eG
a
n
z
z
a
h
le
i
n
:"
)
;
An dem Namen der unbekannten Methode taucht daraufhin das Zeichen für einen Smarttag auf.
4. Öffnen Sie das Smarttagmenü, wählen Sie den Befehl Methodenstub für "LeseLongwert" in
"Stubs.Program" generieren. Die IDE analysiert den Aufruf der noch nicht vorhandenen Methode
und erstellt automatisch das passende Codegerüst. Einfacher geht es nicht!
static void Main(string[] args)
{
long eingabe;
int quersumme;
eingabe = LeseLongwert("Geben Sie bitte eine Ganzzahl ein: ");
}
private static long LeseLongwert(string p)
{
throw new Exception("The method or operation is not implemented.");
}
5. Sie können nun mit der Codierung des Hauptprogramms fortfahren und eine weitere leere Metho-
de zur Berechnung der Quersumme erstellen. Den vollständigen Code (allerdings ohne die Implementierung der beiden Methoden) finden Sie im Beispielprojekt Kap08\Stubs in dem Ordner, in
den die Beispiele für dieses Buch installiert wurden.
Das Arbeiten mit Methodenstubs hat beim Codieren zwei Vorteile: Zum einen können Sie sich, wie
bereits erwähnt, auf die Programmierung der übergeordneten Methode konzentrieren und müssen sich
in einer frühen Phase der Programmentwicklung nicht mit Detail-Problemen beschäftigen. Zum anderen lässt sich Ihr Code nach wie vor kompilieren und sogar starten, da alle verwendeten Methoden
bereits vorhanden sind.
Ein Aufruf der Methoden erzeugt eine Ausnahme, da die Methodenstubs standardmäßig eine entsprechende Anweisung enthalten. Es steht Ihnen natürlich frei, die Methodengerüste mit eigenen Anweisungen zu füllen.
127
Probekapitel aus "Programmieren lernen mit Visual C# 2005", Microsoft Press. Klicken Sie hier um das Buch zu kaufen.
Beispielcode zu diesem Kapitel finden sie auf der Website zu diesem Buch und der Reihe "Richtig Einsteigen"
III – Konzepte der OOP
Abbildung 8.6: Das Smarttagmenü der unbekannten Methode.
Datei: 08.doc, Seite128
31. Oktober 2006
Kapitel 8
Methoden
Methoden extrahieren
Beim Extrahieren von Methoden passiert gewissermaßen das genaue Gegenteil vom Generieren von
Methodenstubs. Denn jetzt soll nicht aus einem Methodenaufruf eine leere Methode erstellt, sondern
bereits bestehender Code in eine Methode überführt werden. Am besten greifen Sie direkt zur Tastatur
und probieren dieses bemerkenswerte Feature sofort aus:
1. Öffnen Sie das Projekt Kap08\Extrahieren, das Sie in dem Ordner finden, in den die Beispiele für
dieses Buch installiert wurden. Dieses Beispiel ist identisch mit dem Programm ListeFüllen aus Kapitel 7.
2. Wenn Sie sich den Code der Main-Methode ansehen, werden Sie feststellen, dass die Methode am
Anfang und innerhalb der do-while-Schleife eine identische Gruppe von jeweils drei Anweisungen
enthält, mit denen der Status des Arrays ausgegeben wird. Diese beiden Passagen sollen nun durch
einen Methodenaufruf ersetzt werden. Wie schätzen Sie den Zeitaufwand dafür ein? Eine Minute?
Fünf Minuten? Wir behaupten, es ist lediglich eine Sache von wenigen Sekunden.
3. Markieren Sie die drei folgenden Zeilen am Anfang der Main-Methode:
Console.WriteLine("Kapazität des Arrays: {0} Elemente", arrayListe.Capacity);
Console.WriteLine("Anzahl der Elemente : {0}", arrayListe.Count);
Console.WriteLine();
4. Klicken Sie mit der rechten Maustaste in die Markierung und wählen Sie im Kontextmenü den
Befehl Umgestalten/Methode extrahieren.
Abbildung 8.7: Aus den markierten Codezeilen soll eine neue Methode erstellt werden.
128
Probekapitel aus "Programmieren lernen mit Visual C# 2005", Microsoft Press. Klicken Sie hier um das Buch zu kaufen.
Beispielcode zu diesem Kapitel finden sie auf der Website zu diesem Buch und der Reihe "Richtig Einsteigen"
Datei: 08.doc, Seite129
31. Oktober 2006
8.5 Gültigkeitsbereich von Variablen
5. Auf dem Bildschirm erscheint dann ein Dialog, in dem Sie einen Namen für die zu erstellende
Methode festlegen können.
Abbildung 8.8: Sie müssen lediglich einen Namen für die neue Methode eingeben.
6. Geben Sie einen Namen für die Methode ein (Pascal-Schreibweise) und klicken Sie auf OK. Das war
alles! Die Methode ist fertig und die markierten Zeilen sind durch einen passenden Methodenaufruf ersetzt. Die IDE hat richtig erkannt, dass die Methode genau einen Parameter benötigt (nämlich
die Variable arrayListe) und dass sie keinen Rückgabewert liefern muss.
III – Konzepte der OOP
static void Main(string[] args)
{
ArrayList arrayListe = new ArrayList(1);
string eingabe;
ArrayStatus(arrayListe);
...
}
private static void ArrayStatus(ArrayList arrayListe)
{
Console.WriteLine("Kapazität des Arrays: {0} Elemente", arrayListe.Capacity);
Console.WriteLine("Anzahl der Elemente : {0}", arrayListe.Count);
Console.WriteLine();
}
7. Ersetzen Sie jetzt auch die drei Codezeilen am Ende der do-while-Schleife durch den neuen Metho-
denaufruf. Hier eine knappe Schnellanleitung: Zuerst den neuen Methodenaufruf markieren und
mit Strg+C in die Zwischenablage übernehmen; dann die drei Codezeilen markieren und mit
Strg+V durch den Inhalt der Zwischenablage ersetzen.
8.5 Gültigkeitsbereich von Variablen
In Kapitel 4 haben Sie bereits erfahren, wie Variablen deklariert und initialisiert werden. In diesem Abschnitt wollen wir nun den sogenannten Gültigkeitsbereich einer Variablen untersuchen, d. h. wir wollen
klären, wann und wo eine deklarierte Variable überhaupt verwendet werden kann.
129
Probekapitel aus "Programmieren lernen mit Visual C# 2005", Microsoft Press. Klicken Sie hier um das Buch zu kaufen.
Beispielcode zu diesem Kapitel finden sie auf der Website zu diesem Buch und der Reihe "Richtig Einsteigen"
Datei: 08.doc, Seite130
31. Oktober 2006
Kapitel 8
Methoden
Sehen Sie sich dazu zunächst den folgenden Programmcode an:
private static int NichtsNutz(int p)
{
int i;
i = p;
i = (30 * i) / (5 * 6);
return i;
}
In diesem Beispiel werden zwei lokale Variablen verwendet. Zum einen der übergebene Parameter p und
zum anderen die Variable i. Diese Variablen können nur innerhalb der geschweiften Klammern des
Methodenkörpers verwendet werden. Sie werden erst beim Aufruf der Methode im Speicher (auf dem
Stack) erzeugt und beim Beenden der Methode wieder von dort entfernt. Durch diese Abschottung wird
es auch möglich, in zwei Methoden den gleichen Namen für eine Variable zu benutzen, ohne dass sich
die beiden Variablen ins Gehege kommen.
Es gibt aber auch Variablen, deren Gültigkeitsbereich noch kleiner ist. Erinnern Sie sich an Kapitel 6, in
dem wir die verschiedenen Schleifenkonstrukte von C# vorgestellt haben? Dort haben wir in einigen
Beispielen sinngemäß folgende for-Schleife eingesetzt:
for (int i = 0; i <=10; i++)
{
// Anweisungen der for-Schleife
}
In diesem Fall wird die Variable i, die als Schleifenzähler fungiert, innerhalb der for-Anweisung deklariert und ist daher auch nur innerhalb dieser for-Schleife gültig. Wenn Sie hinter der for-Schleife versuchen, auf die Variable i zuzugreifen, reagiert der Compiler mit einer Fehlermeldung:
Abbildung 8.9: Der Gültigkeitsbereich der Variable i beschränkt sich auf die for-Schleife.
Die Schleifenvariable i ist also dem Code außerhalb der for-Schleife nicht bekannt. Interessanterweise
können Sie diese Fehlermeldung nicht beheben, indem Sie vor oder nach der for-Schleife eine Variable i
deklarieren. Denn auch dann erhalten Sie eine Fehlermeldung:
Abbildung 8.10: Der Compiler lehnt die zweite Deklaration der Variable i ab.
Diese Fehlermeldung erscheint auf den ersten Blick unlogisch, da wir ja zuvor gesehen haben, dass es die
Variable i hinter der for-Schleife aus Sicht des Compilers gar nicht gibt. Das ist auch nach wie vor richtig. Der Grund, warum der Compiler die zweite Deklaration ablehnt, liegt in der potentiellen Verwechs-
130
Probekapitel aus "Programmieren lernen mit Visual C# 2005", Microsoft Press. Klicken Sie hier um das Buch zu kaufen.
Beispielcode zu diesem Kapitel finden sie auf der Website zu diesem Buch und der Reihe "Richtig Einsteigen"
Datei: 08.doc, Seite131
31. Oktober 2006
8.5 Gültigkeitsbereich von Variablen
lungsgefahr der beiden Variablen. Wenn Sie tatsächlich eine Variable i benötigen, auf die Sie sowohl in
der for-Schleife als auch in der restlichen Methode zugreifen können, müssen Sie sie auf Methodenebene
deklarieren:
static void Main(string[] args)
{
int i;
for (i = 0; i < args.Length; i++)
Console.WriteLine(i + ". Argument: " + args[i]);
Console.WriteLine("Inhalt von i: {0}", i);
}
Befehlszeilenargumente in der IDE eingeben
III – Konzepte der OOP
Wenn Sie in Ihrem Programm die Befehlszeilenargumente auswerten, können Sie zum
Testen des Programms die Befehlszeile festlegen, mit der das Programm aus der IDE gestartet
werden soll. Wählen Sie dazu Projekt/[Name des Projekts] – Eigenschaften und wechseln Sie
auf das Register Debuggen. Dort können Sie im Textfeld Befehlszeilenargumente die gewünschten Argumente eintragen.
Abbildung 8.11: Das Programm erhält die Befehlszeilenargumente beim nächsten Start.
131
Probekapitel aus "Programmieren lernen mit Visual C# 2005", Microsoft Press. Klicken Sie hier um das Buch zu kaufen.
Beispielcode zu diesem Kapitel finden sie auf der Website zu diesem Buch und der Reihe "Richtig Einsteigen"
Datei: 08.doc, Seite132
31. Oktober 2006
Kapitel 8
Methoden
Methodenübergreifender Zugriff auf Variablen
Wenn Sie eine Variable außerhalb einer Methode deklarieren, erstreckt sich ihr Gültigkeitsbereich auf
die gesamte Klasse. In diesem Fall ist es auch unerheblich, an welcher Stelle des Klassenkörpers sich die
Deklaration befindet. Sie können sie entweder an den Anfang, ans Ende oder irgendwo zwischen zwei
Methoden unterbringen.
class Program
{
static void Main(string[] args)
{
Console.WriteLine(version);
VersionZeigen();
}
static void VersionZeigen()
{
Console.WriteLine(version);
}
static string version = "0.9";
}
In dieser Klasse wurde die Variable version außerhalb der beiden Methoden Main und VersionZeigen
deklariert und kann daher von beiden Methoden verwendet werden. Und wie Sie sehen, muss die Variable in diesem Fall nicht vor ihrer ersten Verwendung deklariert werden.
8.6 Methoden überladen
Zum Schluss dieses Kapitels wollen wir noch kurz auf das Überladen von Methoden zu sprechen kommen. Da wir dieses Thema in Kapitel 11 noch weiter vertiefen werden, beschränken wir uns an dieser
Stelle darauf, Ihnen einen ersten Überblick zu geben.
Unter dem Überladen von Methoden versteht man in C# folgendes: Wenn in einer Klasse mehrere Methoden vorhanden sind, die zwar alle den gleichen Namen, aber unterschiedliche Parameter besitzen,
nennt man diese Methoden überladen. Ein kleines Beispiel gefällig?
1. Erstellen Sie das Projekt Überladen vom Typ Konsolenanwendung.
2. Deklarieren Sie zunächst oberhalb der Main-Methode die Variable version:
static string version = "0.9a";
3. Erstellen Sie nun die erste Methode und nennen Sie sie ZeigeVersion. Die Methode soll einfach
den Inhalt der Variablen version auf dem Bildschirm ausgeben:
static public void ZeigeVersion()
{
Console.WriteLine(version);
}
4. Schreiben Sie jetzt eine zweite Methode. Sie soll ebenfalls ZeigeVersion heißen, aber einen Parame-
ter mit dem Datentyp string erwarten. Den übergebenen String soll sie dann zusammen mit der
Variable version ausgeben:
132
Probekapitel aus "Programmieren lernen mit Visual C# 2005", Microsoft Press. Klicken Sie hier um das Buch zu kaufen.
Beispielcode zu diesem Kapitel finden sie auf der Website zu diesem Buch und der Reihe "Richtig Einsteigen"
Datei: 08.doc, Seite133
31. Oktober 2006
8.6 Methoden überladen
static public void ZeigeVersion(string ausgabetext)
{
Console.WriteLine(ausgabetext + version);
}
Voilà, damit haben Sie ihre erste überladene Methode erstellt!
5. Im nächsten Schritt wollen wir die Auswirkung dieser Überladung untersuchen. Geben Sie dazu in
der Main-Methode Zeige ein. Wie nicht anders zu erwarten, meldet sich sofort die IntelliSense und
zeigt die gewohnte Auswahlliste an.
6. Zeigen Sie mit der Maus ganz unten in der Liste auf den Eintrag ZeigeVersion. Es erscheint ein
III – Konzepte der OOP
Tooltipp mit dem Hinweis, dass diese Methode einmal überladen ist.
Abbildung 8.12: In der Auswahlliste von IntelliSense wird die Überladung angezeigt.
7. Vervollständigen Sie den Namen der Methode und geben Sie die öffnende runde Klammer ein.
Abbildung 8.13: Mit den Pfeiltasten können Sie die verschiedenen Überladungen anzeigen.
8. Jetzt können Sie mit den Pfeiltasten zwischen den beiden Überladungen wechseln und das vorhan-
dene Angebot prüfen. Um eine der beiden Varianten auszuwählen, vervollständigen Sie den Methodenaufruf mit den entsprechenden Parametern.
Überladene Methoden verhalten sich also aus Sicht des Programmierers wie eine einzelne Methode, die
mit unterschiedlichen Parametern aufgerufen werden kann. Damit der Compiler die Methodenaufrufe
auch richtig zuordnen kann, müssen folgende Bedingungen erfüllt sein:
Die Methoden müssen selbstverständlich den gleichen Namen besitzen.
Der Datentyp des Rückgabewertes muss bei allen Methoden identisch sein.
Die einzelnen Methoden müssen durch Anzahl und Datentyp der Parameter eindeutig zu unterscheiden sein. Das heißt, wenn die Anzahl der Parameter gleich ist, müssen sie sich mindestens an
einer Stelle in ihren Datentypen unterscheiden.
Auf den Punkt gebracht bedeutet das, die Methodensignatur muss innerhalb der Klasse eindeutig sein.
133
Probekapitel aus "Programmieren lernen mit Visual C# 2005", Microsoft Press. Klicken Sie hier um das Buch zu kaufen.
Beispielcode zu diesem Kapitel finden sie auf der Website zu diesem Buch und der Reihe "Richtig Einsteigen"
Datei: 08.doc, Seite134
31. Oktober 2006
Kapitel 8
Methoden
8.7 Übungen zu diesem Kapitel
In diesem Abschnitt finden Sie einige Übungen zu diesem Kapitel. Die richtigen Antworten und Lösungen finden Sie wie immer auf der Website www.vsxpress.de.
Übung 8.1
Erstellen Sie eine Methode, die den Mittelwert aus drei Ganzzahlen berechnet und das Ergebnis als
double-Wert zurückgibt. Die Argumente sollen dabei als Werttypen übergeben werden.
Übung 8.2
Wie unterscheidet sich die Parameterübergabe an eine Methode bei Verwendung von ref und out?
Übung 8.3
Ändern Sie die Methode aus der ersten Übung so ab, dass sie eine beliebige Anzahl an Argumenten
entgegennimmt.
8.8 Zusammenfassung
In diesem Kapitel haben Sie gesehen, welche Regeln für die Erstellung von Methoden gelten und wie Sie
Visual C# 2005 Express Edition beim Schreiben von Methoden unterstützt:
Methoden helfen, ein Problem in überschaubare Teilaufgaben zu zerlegen.
Methoden können nur innerhalb einer Klasse definiert werden und müssen eine eindeutige Signatur besitzen. Unter einer Signatur versteht man die Kombination von Rückgabewert, Name und
Parameter einer Methode.
Damit IntelliSense eine Kurzbeschreibung der Methode anzeigen kann, müssen Sie vor der Methodendefinition einen speziellen Kommentarblock einfügen. Das Gerüst wird von der IDE automatisch erstellt, wenn Sie drei Schrägstriche eintippen.
Die Zugriffsmodifizierer public und private entscheiden über die Sichtbarkeit einer Methode. Damit
eine Methode auch außerhalb ihrer Klasse aufgerufen werden kann, muss sie als public definiert
werden.
Für die Namen von Methoden wird die Pascal-Schreibweise verwendet.
Die Parameter werden standardmäßig als Wert übergeben. Soll lediglich der Verweis auf eine Variable übergeben werden, muss dem Parameter das Schlüsselwort ref vorangestellt werden (sowohl
in der Definition als auch beim Aufruf). Alternativ kann mit dem Schlüsselwort out für einen Parameter festgelegt werden, dass er auch einen Verweis auf eine nicht initialisierte Variable akzeptiert.
134
Probekapitel aus "Programmieren lernen mit Visual C# 2005", Microsoft Press. Klicken Sie hier um das Buch zu kaufen.
Beispielcode zu diesem Kapitel finden sie auf der Website zu diesem Buch und der Reihe "Richtig Einsteigen"
Datei: 08.doc, Seite135
31. Oktober 2006
8.8 Zusammenfassung
In einer Methodendefinition kann dem letzten Parameter das Schlüsselwort params vorangestellt
werden. Dadurch wird der Parameter zu einem optionalen Parameter, dem eine Parameterliste
übergeben werden kann.
Methodenstubs sind leere Codegerüste für Methoden, die die IDE automatisch aus einem Methodenaufruf erzeugen kann.
Die IDE kann aus einer markierten Codepassage eine Methode erzeugen. Dabei werden die benötigten Parameter automatisch erkannt. Die Codepassage wird dann aus dem Code entfernt und
durch einen entsprechenden Methodenaufruf ersetzt.
Der Gültigkeitsbereich einer Variablen ist der Bereich eines Programms, in dem die Variable aufgerufen werden kann. Damit eine Variable in der gesamten Klasse sichtbar wird, muss sie außerhalb
der Methoden deklariert werden. Variablen die innerhalb einer Methode deklariert sind, können
nur in der Methode selbst benutzt werden. Zusätzlich gibt es noch Schleifenvariablen, die innerhalb
einer Schleifenbedingung deklariert werden. Ihr Gültigkeitsbereich beschränkt sich auf den Anweisungsblock der Schleife.
Wenn mehrere Methoden den gleichen Namen und Rückgabetyp, aber unterschiedliche Parameterdefinitionen besitzen, spricht man von einer Methodenüberladung. Eine bekannte Methode, die
gleich mehrfach überladen ist, ist zum Beispiel WriteLine().
III – Konzepte der OOP
135
Probekapitel aus "Programmieren lernen mit Visual C# 2005", Microsoft Press. Klicken Sie hier um das Buch zu kaufen.
Beispielcode zu diesem Kapitel finden sie auf der Website zu diesem Buch und der Reihe "Richtig Einsteigen"
