Informatik - Benutzer-Homepage-Server der TH...

Seite 1

Informatik

Funktionen

Th Letschert

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;


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


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


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


Schrittweise Verfeinerung Beispiel: Primfaktorzerlegung

Th Letschert

package hallo;


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


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); } }}

Informatik - Benutzer-Homepage-Server der TH...

Documents

Transcript of Informatik - Benutzer-Homepage-Server der TH...