\begin{slide}{Unterprogramme}

zu große Programme (Bildschirmseite!)
zerlegen in (weitgehend) unabhängige Einheiten:
\emph{Unterprogramme.}

\bigskip
Unterprogramm ist
\begin{itemize}
\item
  benannter Block 

  (= Folge von Deklarationen und Anweisungen)
\item
  mit Schnittstelle

  (Datentransport bei Beginn und Ende der Ausführung)
\end{itemize}

\end{slide}

\begin{slide}{Unterprogramme (Beispiele)}

Schnittstelle festlegen:
\begin{verbatim}
// liefert true genau dann, wenn die 
// Collatz-Folge von x die Länge len hat
static boolean collatz_test (int x, int len) { ...
}
\end{verbatim}
Unterprogramm benutzen:
\begin{verbatim}
static void solve (int len) {
  for (int start = 0; start < 1000; start++) {
    if (collatz_test (start, len) {
        System.out.println (start);
    }
  }
}
\end{verbatim}
\end{slide}


\begin{slide}{Unterprogramme (Implementierung)}

\begin{verbatim}
// hat Collatz-Folge von x die Länge len?
static boolean collatz_test (int x, int len) {
  int count = 0; // Deklaration mit Initialisierung
  while (x > 1) {
    if (0 == x % 2) { 
      x = x / 2;
    } else {
      x = 3 * x + 1;    
    }
    count++;
  }
  return len == count;
}
\end{verbatim}
\end{slide}


\begin{slide}{Übung 22. 11.}

\begin{itemize}
\item
  Unterprogramme \verb|collatz_test, solve|
  aus Vorlesung ausprobieren.

  Testfälle für \verb|collatz_test| entwerfen und ausführen.
\item
  Unterprogramme \verb|collatz_test, solve|
  sollen weiteres Argument \verb|top| erhalten,
  mit dem das maximale Element der Folge getestet werden kann.

  Erst Schnittstelle und  Testfälle entwerfen,
  dann implementieren und Tests ausführen.

  Dann autotool-Aufgabe CollatzIQ lösen.
\end{itemize}

\end{slide}

\begin{slide}{Syntax u. Semantik von Unterprogrammen}

\begin{small}
\begin{verbatim}
static Typ Name ( Liste der formalen Parameter ) Block
\end{verbatim}
\end{small}

\begin{verbatim}
mit  Typ => int, String, .. ; 
     formaler Parameter=> Typ Name
\end{verbatim}
  
es gibt zwei Arten von Unterprogrammen:
\begin{itemize} \itemsep 0pt
\item
  \emph{Funktion} 

  liefert \emph{Wert} vom angegebenen Typ

  Funktionsaufruf ist \emph{Ausdruck}
\item
  \emph{Prozedur} liefert \emph{keinen} Wert

  (ausgedrückt durch Ergebnis-\glqq Typ\grqq\ \verb|void|)

  (engl. \emph{void} $=$ wertlos, leer, ungültig)

  Prozedur-Aufruf ist \emph{Anweisung}
\end{itemize}

\end{slide}

\begin{slide}{Semantik von \texttt{return}}

ist besondere Anweisung in Unterprogrammen,
\begin{itemize}
\item
  in Prozeduren: \verb|return;| beendet (sofort) Ausführung der Prozedur
\item
  in Funktionen: \verb|return a;| beendet (sofort) Ausführung der Funktion,
  Rückgabewert ist Wert von \verb|a|
\end{itemize}
Beachte: 
\begin{itemize}
\item
  \verb|return| in Prozeduren kann entfallen

  (dann Rückkehr nach Block-Ende),
\item
  \verb|return a| in Funktionen ist vorgeschrieben.
\end{itemize}

\end{slide}

\begin{slide}{Unterprogramme und Typen}

\begin{itemize}
\item
  Für jedes Unterprogramm müssen die Typen der Argumente
  und des Resultats festgelegt werden.
\item
  Bei jeder Verwendung eines Unterprogramms prüft der Compiler (!),
  ob die Typen der verwendeten Argumente und des Resultats
  mit der Deklaration übereinstimmen.
\item
  Die Prüfung findet nur einmal statt: zur Compile-Zeit ---
  ist also zur Laufzeit  \emph{nicht} mehr nötig.
\item
  möglichst frühe und möglichst strenge Typ-Prüfung
  verhindert Laufzeitfehler und ermöglicht schnellere Programm-Ausführung.
\end{itemize}


\end{slide}


\begin{slide}{Nutzen von Unterprogrammen/Schnittstellen}

\begin{itemize}
\item
  in größeren Software-Projekten geschehen
\begin{quote}
  Schnittstelle, Test-Entwurf, Implementierung, Test
\end{quote}
zu verschiedenen Zeitpunkten, von verschiedenen Personen
  (Abteilungen, Firmen) 
  
  $\Rightarrow$ Modularisierung, Wiederverwendung
\item
  auch in kleinen Projekten:

  Verwendung von vorgefertigten Unterprogrammen
  (Bibliotheken) 

  Kenntnis der Schnittstelle reicht für Benutzung.
\end{itemize}

\end{slide}

\begin{slide}{Re-Faktorisierung}

re-faktorisieren: \glqq hinterher (anders) zerlegen\grqq

bereits benutzte Software besser strukturieren,
damit man sie besser warten und wiederverwenden kann.

\bigskip 
Beispiel:

  ein Unterprogramm,
  das einen Schritt der inneren Schleife
  der Collatz-Folge berechnet:
\begin{verbatim}
static int step (int x) { ... }
\end{verbatim}
  Beispiel-Werte: \verb|step(5) = 16; step (8)=4;|
 
  dann einen geeigneten Unterprogramm-Aufruf
  in \verb|collatz_test| einsetzen.


\end{slide}
