Unterprogramme

• Unterprogramme oder Routinen:
  • Folgen von Anordnungen, die unter einem Namen aufgerufen werden können
  • in Java immer als Methoden einer Klasse zugeordnet
  • bekommen Eingabedaten durch eine Menge von Variablen (Parameterliste), deren Werte vom Aufrufer übergeben werden
  • geben als Ergebnis einen Wert zurück
  • können darüber hinaus Änderungen durchführen, die auch im aufrufenden Programm sichtbar sein können (Seiteneffekte)
  • können eigene Variablen (lokale Variablen) definieren, die zu Beginn und nach dem Beenden der Routine keinen Wert haben
  • jedes Programm hat eigenen Speicherbereich (Stack) für seine lokalen Variablen
• Beispiel:
  • Routine hypot

    • double hypot(double a, double b) {
        double ergebnis = Math.sqrt(a*a + b*b);
        return ergebnis;
      }
      

  • zwei Parameter a, b als Eingabewerte
  • Ergebniswert vom Typ double
  • lokale Variable ergebnis
  • keine Seiteneffekte
• Parameter:
  • werden im Unterprogramm wie lokale Variable benutzt
  • aufrufendes Programm ersetzt die Parameter durch Ausdrücke der geeigneten Typen
  • Werte werden für die Routine kopiert (call by value)
• Rückgabewert:
  • Wert wird zum Aufrufer zurückgegeben mit
    • return AUSDRUCK;
  • "Pseudo-Datentyp" void = kein Rückgabewert, zurückkehren mit return;
  • Wert kann vom Aufrufer ignoriert werden, z.B.

    • double verdopple(double a) {
         return 2*a;
      }
      
      b = verdopple(4.0);
      verdopple(3.2);
      

• Seiteneffekte:
  • Änderungen durch Routine im aufrufenden Programm
  • Beispiele: Veränderungen an Datenfeldern, an Dateien, an der Systemuhr usw.
  • können schwer zu durchschauende Abhängigkeiten bewirken
• Ablauf eines Unterprogramms im Detail:
  1. Parametervariablen des Unterprogramms werden in seinem Stack angelegt
  2. Werte werden vom Aufrufer in die Parametervariablen kopiert
  3. Unterprogramm wird ausgeführt
  4. beim return wird der Wert des Ergebnisses in Hilfsvariable beim Aufrufer kopiert
  5. Programmausführung geht beim Aufrufer weiter
• Beispiel:
  • double k1 = 4.0
    double k2 = 3.0;
    double hypotenuse;
    hypotenuse = hypot(k1, k2);
• Parameterübergabe bei einfachem Datentyp:
  • Beispiel:

    • void erhoehe(int i) {
        i++;
      }
      
      int a = 3;
      erhoehe(a);
      System.out.println(a);      // Ergebnis: 3
      

  • keine Änderung von a, da nur der Wert von a kopiert wurde.
  • im Bild:
    
• Parameterübergabe bei Referenztyp:
  • Beispiel:

    • void erhoehe(int[] intArray) {
        for (int i=0; i<intArray.length; i++) {
          intArray[i]++;
        }
      }
      
      int[] a = {3,6,9};
      erhoehe(a);
      System.out.println(a[0]);    // Ergebnis: 4
      

  • keine Änderung an a, nämlich der Referenz, sondern Änderung am Objekt, auf das a verweist.
  • im Bild:
    
• Sichtweisen auf eine Methode:
  • Schnittstelle
    • alles, was von "außen" sichtbar ist
    • Name, Parameterliste und Rückgabewert
  • Implementierung
    • Anweisungen der Methode
    • "Innenleben"
  • Auftrennung erleichtert Programmierung
    • korrekte Funktionsweise (Implementierung) testen
    • danach nur noch Schnittstelle wichtig
• Überladen von Methoden
  • gleicher Name für Methoden mit verschiedenen Parametern
  • Beispiel:

    • double sin(double d)
      Complex sin(Complex z)
      

  • Compiler wählt passende Methode nach Parametertypen
• Aufgaben:
  • Aufgabe 6