Grundlagen Teil 2 - Eigene Methoden

Bereits im ersten Abschnitt haben wir die WriteLine() Methode kennengelernt, jedoch damals einfach hingenommen, dass uns diese Methode einen Text in der Konsole ausgibt. Kurz danach befassten wir uns mit der Methode ReadLine(), welche uns im Gegensatz dazu einen Text zurück gab.
Ganz allgemein ausgedrückt ist eine Methode ein Stück Programmcode, dass nach Wunsch aufgerufen werden kann.
Dies ist vor allem praktisch, wenn etwas öfter benötigt wird. Stellen wir uns ein Programm vor, indem öfter mehrere bestimmte Zeilen ausgegeben werden soll. Allerdings ist es nicht möglich dies mit einer Schleife zu lösen, da es nicht hintereinander passieren soll, sondern an unterschiedlichen Stellen im Programmcode.
Das grundlegende Ziel von Methoden ist es Programmcode wiederverwendbar zu machen.

Bevor wir nun darauf eingehen, wie eine eigene Methode zu programmieren ist, werden wir nochmal den Code betrachten, der von Visual C# beim erstellen eines neuen projektes erzeugt wird.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Projekt1
{
      class Program
      {
            static void Main(string[] args)
            {

            }
      }
}

Damals haben wir static void Main(string[] args) einfach hingenommen, dahinter versteckt sich grundlegend betrachtet nichts anders als eine Methode. Der eigentliche Name der Methode ist Main. Was die Begriffe static, void und das string Datenfeld (Array) in den runden Klammern bedeuten, werden wir noch später hören. Die Main Methode hat jedoch eine Besonderheit. Da es die Methode ist, die bei einem Programmstart aufgerufen wird (Groß und Kleinschreibung ist relevant).
Zwar ist es offensichtlich, der Vollständigkeit halber seih hier erwähnt, dass die Methode Main aus dem Code zwischen den geschwungenen Klammern besteht. Nun betrachten wir den einfachsten Fall einer Methode.

Methoden ohne Parameter und Rückgabewert

Bei dieser Art wird keine Variable an die Methode übermittelt, wie es zum Beispiel bei WriteLine(string) passiert. Es gibt auch keinen Rückgabewert wie bei ReadLine(), welche einen string als Rückgabewert besitzt (ReadLine() repräsentiert einen string).
Eine Methode ohne Parameter ist also einfach ausgedrückt, eine Methode ohne Variablen zwischen den runden Klammern. Mit dem Schlüsselwort void vor dem Namen der Methode, wird angegeben, dass diese Methode keinen Rückgabewert besitzt. In das Deutsche übersetzt, bedeutet void nichts anderes als leer.
Zu beachten ist, dass eine Methode niemals in einer anderen Methode definiert werden darf.
Methoden sind immer in den geschwungenen Klammern von class Projekt1 (Projekt1 kann variieren) zu definieren. Was es mit class Projekt1 auf sich hat, werden wir erst im nächsten Abschnitt behandeln.

Eine Programm mit einer Methode ohne Parameter oder Rückgabewert, welche den Namen meineMethode hat würde folgendermaßen aussehen:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Projekt1
{
      class Program
      {
            static void Main(string[] args)
            {

            }

            static void meineMethode()
            {
                  Code;
            }
      }
}

Hier ist wieder static am Beginn der Methodendefinition, dies ist für unseren zukünftigen Beispiele in diesem Abschnitt notwendig, da Main auch static ist, dies soll uns allerdings momentan nicht weiter kümmern. Ein Aufruf einer Methode ohne Parameter verhält sich ähnlich wie der von Console.ReadLine(), jedoch ist es hier nicht notwendig einen Klassennamen (Console) davor zu schreiben.

Methodenaufruf erfolgen mit der folgenden Programmzeile:

meineMethode();

Wenn diese Zeile in die Main Methode geschrieben wird, wird der Code ausgeführt der in der Methode meineMethode programmiert ist.

Übungsbeispiel

Um das Verständnis zu verbessern ist es nun die Aufgabe ein Programm mit zwei Methoden ohne Parameter oder Rückgabewert zu schreiben und diese Aufzurufen, um den darin enthaltenen Code auszuführen.

Angabe

Für die Lösung hier klicken. Bei Fragen und Problemen, bitte das Forum benutzen.

Lösung:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Projekt1
{
      class Program
      {
            static void Main(string[] args)
            {
                  textAusgabe2();
                  textAusgabe1();
                  Console.ReadLine();
            }

            static void textAusgabe1()
            {
                  Console.WriteLine("Ausgabe 1");
            }

            static void textAusgabe2()
            {
                  Console.WriteLine("Ausgabe 2");
            }
      }
}

Methoden mit Parametern

Als Beispiel wurde hier schon WriteLine() genannt, da dieser Methode ein string übergeben wird, welcher in der Konsole ausgegeben wird. Daher wissen wir schon wie eine Methode aufgerufen wird, welche Parameter besitzt.
Allerdings nicht wie eine Methode diesen Typs definiert wird.
Dies gestaltet sich recht einfach. Dazu wird eine Variable beim definieren der Methoden zwischen den Klammern deklariert(definiert). Ein Beispiel dazu wäre es wenn der Methode ein string übergeben werden soll.
Dazu schreibt man string variabelenname zwischen die runden Klammern der Methode. Danach lässt sich diese Variable ganz normal in den geschwungenen Klammern der Methode verwenden. Um ein einfaches Beispiel zu zeigen, folgt nun ein Programm, welches eine Methode aufruft und dieser einen string übergibt, welcher durch die Methode der Konsole ausgegeben wird.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Projekt1
{
      class Program
      {
            static void Main(string[] args)
            {
                  meineMethode("Text der in der Konsole ausgegeben werden soll!");
                  Console.ReadLine();
            }

            static void meineMethode(string ausgabe)
            {
                  Console.WriteLine(ausgabe);
            }
      }
}

Statt der string Variable könnte natürlich auch eine int Variable übergeben werden, um damit etwas auszurechnen und auszugeben.

Etwas das wir bis jetzt noch nicht hatten, ist die Möglichkeit mehr als eine Variable an eine Methode zu übergeben. Dazu ist es notwendig mehrere Variabeln in den runden Klammern der Methode zu deklarieren und mit einem Beistrich zu trennen. Allerdings gilt es immer darauf zu achten, dass beim Aufrufen einer Methode immer sämtliche Variablen einen korrekten wert übergeben bekommen. Beim Aufruf sind die Variablen wieder mit Beistrich zu trennen.

Eine Methode mit einer string und einer int Variable würde folgendermaßen aussehen:

static void meineMethode(string variable1, int variable2)
{
      Code;
}

Übungsbeispiel Methoden mit Parameter

Das jetzige Übungsbeispiel ist es ein Programm zu schreiben, welches eine Methode enthält mit dem Name zeigeErgebnis. Dieser Methoden werden drei int Variablen übergeben, die danach zu Addieren sind um anschließend das Ergebnis auszugeben.

Angabe

Für die Lösung hier klicken. Bei Fragen und Problemen, bitte das Forum benutzen.

Lösung:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Projekt1
{
      class Program
      {
            static void Main(string[] args)
            {
                  int zahl1 = Convert.ToInt32(Console.ReadLine());
                  int zahl2 = Convert.ToInt32(Console.ReadLine());
                  int zahl3 = Convert.ToInt32(Console.ReadLine());
                  zeigeErgebnis(zahl1,zahl2,zahl3);
                  Console.ReadLine();
            }

            static void zeigeErgebnis(int wert1, int wert2, int wert3)
            {
                  int ergebnis = wert1 + wert2 + wert3;
                  Console.WriteLine(ergebnis);
            }
      }
}

Methoden mit Rückgabewert

Die letzte Art die wir betrachten sind Methoden mit Rückgabewert. Eine uns schon bekannte Methode ist ReadLine(), diese gibt uns einen string zurück. Angegeben wird der Rückgabewert einer Methode, durch das Wort vor dem Methodennamen. In den letzten Methoden kam hier void zum Einsatz.
Je nach dem Variablentyp, welcher zurück gegeben werden soll, ist void mit string, int oder einem anderen Variablentypen zu ersetzen. Des Weiteren ist es vonnöten gezielt anzugeben, welcher Wert / Variable zurückgegeben werden soll, dies erfolgt durch das Schlüsselwort return dem Wert / Variable und einem Strichpunkt.

Ein Programmauszug könnte folgendermaßen aussehen:

static string meineMethode()
{
      return "Text";
}

Bei diesem Beispiel würde jedesmal bei einem Aufruf der string "Text" zurück gegeben werden. Verwendet wird dies genauso wie bei ReadLine().
Mann muss darauf achten, dass es bei Methoden, welche nicht void sind immer ein return vorhanden sein muss und dies auch immer erreichbar sein muss. Wenn ein return z.B.: in einer if - Abfrage steht, ist darauf zu achten, dass im else ein weiteres return vorhanden ist. Außerdem ist auch auf den richtigen Typ zu achten.
Wenn der Rückgabetyp int ist, ist es nicht erlaubt return "text"; zu verwenden, da es sich um einen string handelt.

Übungsbeispiel Methode mit Rückgabewert und Paramter

Diesmal gilt es ein Programm zu schreiben welches folgender Angabe abläuft:

Angabe

Für die Lösung hier klicken. Bei Fragen und Problemen, bitte das Forum benutzen.

Lösung1:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Projekt1
{
      class Program
      {
            static void Main(string[] args)
            {
                  int zahl1 = Convert.ToInt32(Console.ReadLine());
                  int zahl2 = Convert.ToInt32(Console.ReadLine());
                  string rechenzeichen = Console.ReadLine();

                  int ergebnis = rechner(zahl1,zahl2,rechenzeichen);
                  Console.WriteLine(ergebnis);

                  Console.ReadLine();
            }

            static int rechner(int wert1, int wert2, string rechenzeichen)
            {
                  int ergebnis = 0;

                  switch(rechenzeichen)
                  {
                        case "+":
                              ergebnis = wert1 + wert2;
                              break;
                        case "-":
                              ergebnis = wert1 - wert2;
                              break;
                        default:
                              break;
                  }

                  return ergebnis;
            }
      }
}

Lösung2:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Projekt1
{
      class Program
      {
            static void Main(string[] args)
            {
                  int zahl1 = Convert.ToInt32(Console.ReadLine());
                  int zahl2 = Convert.ToInt32(Console.ReadLine());
                  string rechenzeichen = Console.ReadLine();

                  Console.WriteLine(rechner(zahl1,zahl2,rechenzeichen));

                  Console.ReadLine();
            }

            static int rechner(int wert1, int wert2, string rechenzeichen)
            {
                  if(rechenzeichen == "+")
                  {
                        return wert1 + wert2;
                  }
                  else if(rechenzeichen == "-")
                  {
                        return wert1 - wert2;
                  }
                  else
                  {
                        return 0;
                  }
            }
      }
}