Upload
others
View
1
Download
0
Embed Size (px)
Citation preview
Seite 2
Funktionen
FunktionMathematik:
Zuordnung Argumentwert(e) => Ergebniswerte Beispiel: f(x,y) = 2*x+y
Informatik / Programmierung: Zusammenfassung von Anweisungen die
➢ von Argumentwerten abhängen (können) und➢ einen Ergebniswert produzieren (können)
oft zur Berechnung mathematischer Funktionen eingesetztBeispiele:
Th Letschert
static int max(int x, int y) { return x > y ? x : y;}
static double mal2(int x) { return x*2;}
Seite 3
Funktionen
FunktionsdefinitionFunktions-Kopf
➢ Funktions-Name➢ Funktions-Parameter,
(auch formale Funktions-Argumente)
Funktions-Körper
Funktions-Ergebnis
Funktionsanwendung, FunktionsaufrufFunktions-Name
Funktions-Argumente, (auch aktuelle Funktions-Parameter)
Th Letschert
Name Parameter
KörperErgebnis
Kopf
x = mal2(5)
Name Argument
static double mal2(int x) {
return x*2;}
Funktionsdefinition
Funktionsverwendung (Aufruf)
Seite 4
Funktionen
Beispiel Bestimmung des größten von drei Werten a, b, c
Th Letschert
package hallo;
import javax.swing.JOptionPane;
public class Maximum {
static double max(double x, double y, double z) { double max = x > y ? x: y; max = z > max ? z : max; return max; }
public static void main(String[] args) {
String aS = JOptionPane.showInputDialog("Bitte 1-te Zahl eingeben"); String bS = JOptionPane.showInputDialog("Bitte 2-te Zahl eingeben"); String cS = JOptionPane.showInputDialog("Bitte 3-te Zahl eingeben");
double a = Double.parseDouble(aS); double b = Double.parseDouble(bS); double c = Double.parseDouble(cS);
JOptionPane.showMessageDialog(null, "Maximum: " + max(a,b,c)); }
}
Seite 5
Funktionen
Funktion max als Gehilfe von main
Th Letschert
String aS = JOptionPane.showInputDialog("Bitte 1-te Zahl eingeben");String bS = JOptionPane.showInputDialog("Bitte 2-te Zahl eingeben");double a = Double.parseDouble(aS);double b = Double.parseDouble(bS);JOptionPane.showMessageDialog(null, "Maximum: " + max(a,b));
35
3 5a b
static int max(int x, int y) { return x > y ? x : y;}
x y
Los max,jetzt bist Du
dran!
rrrzzz,rrrzzzzz
main
max
Ausgabedaten
„3“ „5“aS bS
Parameter
Ergebnis
Eingabedaten
aktuelle Aktion
Seite 6
Funktionen
Lokale Variablen und Anweisungen
Eine Funktion kann beliebig viele Variablendefinitionen und Anweisungen enthalten. Mit return oder der letzten Anweisung endet sie.
Th Letschert
static double max(double a, double b, double c, double d) { double max1 = a; double max2 = c;
if ( a < b) { max1 = b; } if ( c < d ) { max2 = d; } return max1 > max2 ? max1 : max2;}
Funktionsdefinition mit lokalen Variablen und Anweisungen
Seite 7
Funktionen
Überladung: Funktionen mit unterschiedlichen Parametern dürfen den gleichen Namen tragen
– Ein Funktionsname kann mit mehreren „Bedeutungen“ überladen werden. Die Funktionen werden an Hand ihrer Parameter unterschieden.
– Sie sollten ähnliche Wirkungen haben.
Th Letschert
Mehrere Maximum-Funktionen
static double max(double a, double b) { return a > b ? a : b;}
static double max(double a, double b, double c) { return max(a, max(b, c));}
static double max(double a, double b, double c, double d) { return max(a, max(b, c, d));}
Seite 8
Funktionen
Überladung: Funktionen mit unterschiedlichen Parametern dürfen den gleichen Namen tragen
– Die Funktionen werden anhand ihrer Parameter unterschieden.
Th Letschert
Unterscheidung der Funktionen
static double max(double a, double b) { return a > b ? a : b;}
static double max(double a, double b, double c) { return max(a, max(b, c));}
static double max(double a, double b, double c, double d) { return max(a, max(b, c, d));}
Seite 9
Funktionen
Funktionen ohne Ergebnis und/oder ohne ArgumenteKein Ergebnis: Funktion gibt Daten ausKein Argument: Funktion liest Daten ein
Th Letschert
package hallo;
import javax.swing.JOptionPane;
public class Blubber {
static double liesZahlWert() { String zahlString = JOptionPane.showInputDialog("Bitte Wert eingeben"); return Double.parseDouble(zahlString); }
static void gibWertAus(double wert) { JOptionPane.showMessageDialog(null, wert); }
static double f(double x, double y) { return 2*x+y; }
public static void main(String args[]) { double x = liesZahlWert(); double y = liesZahlWert(); gibWertAus(f(x,y)); }}
Kein ArgumentKein Ergebnis
Seite 10
Funktionen
Funktionen zur Strukturierung von Programmen einsetzen !
Durch den Einsatz von Funktionen kann ein Programm in unabhängig von einander
planbare, verstehbare, testbare
Teile aufgegliedert werden
Th Letschert
Seite 11
Funktionen
Rekursion
Funktionen können sich selbst aufrufen.Das Prinzip ist aus der Mathematik bekannt. Beispiel : Fakultätsfunktion
n! = 1 falls n = 0(n-1)!*n falls n > 0
oderfak(n) = 1 falls n = 0fak(n) = fak(n-1)*n falls n > 0
Th Letschert
Seite 12
Funktionen
Rekursion
Beispiel : Fakultätsfunktion in Java
Th Letschert
static int fak(int x) { return x == 0 ? 1 : fak(x-1)*x;}
static int fak(int x) { if (x == 0) { return 1; } else { return fak(x-1) * x; }}
oder
Seite 13
Funktionen
Indirekte Rekursion
Funktion ruft sich selbst indirekt über eine andere auf
Beispiel : Gerade / Ungerade
Th Letschert
static boolean odd(int n) { return (n == 0) ? false : even(n-1);}
static boolean even(int n) { return (n == 0) ? true : odd(n-1);}
Seite 14
Programmentwurf mit Funktionen: Schrittweise Verfeinerung
Schrittweise VerfeinerungProgrammentwicklung durch systematisches Ausarbeiten (Verfeinern) von Teilaufgaben.
Prinzip:Schreibe zuerst den Aufruf + Spezifikation einer benötigten Funktiondann die Definition dieser FunktionWobei innerhalb von dieser (eventuell) weitere Funktionen
zuerst aufgerufen und dann späterdefiniert werden.
Th Letschert
Seite 15
Programmentwurf mit Funktionen: Schrittweise Verfeinerung
Schrittweise VerfeinerungBeispiel: Primfaktorzerlegung
Th Letschert
static void faktorisiere(int n) { for (int i = 2; i < n; i++) {
if (teilt(n, i) && prim(i)) {System.out.println(i);
} }}
Start: Beginne mit einer Funktion, delgiere Aufgaben an noch zu schreibende Funktionen.
Spezifikation (Plan) der noch zu schreibenden Funktionen
static boolean prim(int n) { return //? ist n eine primZahl ?;}
static boolean teilt(int x, int y) { return //? ist y ein Teiler von x ?;}
Seite 16
Programmentwurf mit Funktionen: Schrittweise Verfeinerung
Schrittweise VerfeinerungBeispiel: Primfaktorzerlegung
Th Letschert
Verfeinerung von prim
Verfeinerung von teilt
static boolean prim(int n) { if (n == 2) { return true; } for (int i=2; i<n; i++) { if (teilt(i, n)) { return false; } } return true;}
static boolean teilt(int x, int y) { return x % y == 0;}
Seite 17
Programmentwurf mit Funktionen: Schrittweise Verfeinerung
Schrittweise Verfeinerung Beispiel: Primfaktorzerlegung
Th Letschert
package hallo;
import javax.swing.JOptionPane;
public class Faktorisierung { static boolean prim(int n) { if (n == 2) { return true; } for (int i = 2; i < n; i++) { if (teilt(i, n)) { return false;} } return true; }
static boolean teilt(int x, int y) { return x % y == 0; }
static void faktorisiere(int n) { System.out.println("primfaktoren von "+n); for (int i = 2; i < n; i++) { if (teilt(n, i) && prim(i)) { System.out.println(i); } } }
public static void main(String[] args){ String zahlString = JOptionPane.showInputDialog("Bitte Wert eingeben"); int zahl = Integer.parseInt(zahlString);
faktorisiere(zahl); }}
Seite 18
Programmentwurf mit Funktionen: Schrittweise Verfeinerung
Schrittweise VerfeinerungTop-Down Verfahren der Programmentwicklung
Vom Gesamtplan
– Leite Pläne für Komponenten ab:Spezifikation von Funktionen
– Verknüpfe Komponenten:Schreibe Algorithmen die diese Funktionen nutzen
– Verfahre genauso mit den KomponentenVerfeinere die spezifizierten Funktionen
Th Letschert
Seite 19
Programmentwurf
Zwei Grundverfahren der ProgrammentwicklungTop-Down
Von einem exakten Plan des Gesamtsystems leite exakte Pläne der Komponenten ab. Tue dies so lange bis alle Komponenten einfach sind und implementiert werden können.
Bottom-upVon einem vagen Plan des Gesamtsystems leite Pläne von Komponenten ab und implementiere diese.Konstruiere das Gesamtsystem aus den Komponenten – wenn möglich, ansonsten modifiziere Komponenten / Plan des Gesamtsystems.
Beide Verfahren werden nicht in Reinform eingesetzt sondern nach Bedarf und Möglichkeiten gemischt. (Top-Down, wenn möglich, Bottom-up wenn nötig)
Th Letschert
Seite 20
Programmentwurf
Komponenten = Schnittstelle / Spezifikation + ImplementierungEntwurf
Strukturierung eines (Software-) Systems in Komponenten
Komponenten-Gedanke Komponenten sind Entwicklungs- und Wartungseinheiten Sie haben Entwickler / Betreuer und Kunden / Benutzer (Entwickler anderer Komponenten)
Schnittstelle / Spezifikation und Implementierung Entwickler beschäftigen sind mit der Schnittstelle / Spezifikation und der
Implementierung Kunden / benutzer wollen / sollen sich nur mit der Schnittstelle /
Spezifikation auseinandersetzen.
Funktionen sind der älteste und immer noch ein extrem wichtiger Komponenten-Typ in der Software-Entwicklung.
Th Letschert
Seite 21
Programmentwurf
Funktionen: Spezifikation + ImplementierungFunktionen: Spezifikation und ImplementierungBeispiel:
Th Letschert
/** * Stellt fest ob eine Zahl ist. * @param n : die zu untersuchende Zahl * @return ist n eine Primzahl */static boolean prim(int n) {
if (n == 2) { return true; } for (int i = 2; i < n; i++) { if (teilt(i, n)) { return false; } } return true;}
Komponente
Schnittstelle / Spezifikation
Implementierung
Die Komponente wird durch einen strukturierten Kommentar beschrieben (spezifiziert). Dies erlaubt es ihren Benutzern - sie korrekt zu verwenden - ohne langwierig die Implementierung studieren zu müssen.
Seite 22
Programmentwurf
Funktionen: Spezifikation + ImplementierungFunktionen: Spezifikation und ImplementierungBeispiel:
Th Letschert
Die Definition geeigneter Komponenten und deren Spezifikation ist ein zentrales Anliegen des Software-Engineerings.
/** * Faktorisierung einer Zahl. * Diese Funktion gibt alle Primfaktoren einer übergebenen Zahl aus. * @param n : die zu zerlegende Zahl */static void faktorisiere(int n) {
System.out.println("primfaktoren von "+n); for (int i = 2; i < n; i++) { if (teilt(n, i) && prim(i)) { System.out.println(i); } }}