252-0027 Einführung in die Programmierung I 3.0 Funktionen

(1)

252-0027

Einführung in die Programmierung I 3.0 Funktionen

Thomas R. Gross

Department Informatik ETH Zürich

(2)

Uebersicht

§ 3.1 Parameter

§ 3.2 Return

§ 3.3 String

§ 3.4 Math Bibliothek

§ 3.5 Funktionen

§ 4.0 Klassen

Copyright (c) Pearson 2013. and Thomas R Gross 2016

(3)

Rückblick

3

(4)

if/else , return Beispiel

§ Schreiben Sie eine Methode quadrant die für ein Paar von reellen Zahlen den Quadranten liefert in dem dieser Punkt

liegt.

§ Bespiel: quadrant(-4.2, 17.3) liefert 2

§ Fällt der Punkt auf eine der Achsen des Koordinatensystems liefere 0.

x+

x-

y+

y-

quadrant 1 quadrant 2

quadrant 3 quadrant 4

(5)

if/else , return Lösung

public static int quadrant(double x, double y) { if ((x==0) || (y==0))

return 0;

else if (x>0)

return (y>0) ? 1 : 4;

else

return (y>0) ? 2 : 3;

}

(6)

C Ueberbleibsel

§ Der ? Operator ist ein Ueberbleibsel von C (test) ? value1 : value2

§ Wenn test true ergibt, ist das Ergebnis dieses Ausdrucks value1, sonst value2

§ Beispiel

max = (a>b) ? a : b;

§ Nicht so effizient wie man denkt aber kompakt

16

(7)

Inkrement und Dekrement

Kurzform Aequivalente ausführlichere Version

variable++; variable = variable + 1;

variable--; variable = variable - 1;

variable wird verwendet und dann verändert

Beispiel

int x = 2;

int y;

y = x++; int temp = x;

x = temp + 1; // x now stores 3 y = temp; // y now stores 2

(8)

Inkrement und Dekrement Puzzles

int x = 1;

int y = 0; int z = 0;

y = x++;

z = x++ + x++;

§ Wert x? 4

§ Wert y? 1

§ Wert z? 5

int a = 1;

a = a++;

§ Wert a? 1

int y = 10;

x = y-- - y--;

§ Wert x? 1

§ Wert y? 8 ₂₀

(9)

Warum ist a == 1?

Kurzform Aequivalente ausführlichere Version

variable++; variable = variable + 1;

variable--; variable = variable - 1;

variable wird verwendet und dann verändert

Beispiel

int x = 2;

int y;

x = x++; int temp = x;

x = temp + 1; // x now stores 3 x = temp; // x now stores 2

(10)

Weitere Kurzformen

§ Erlauben Verwendung des Wertes einer Variable gefolgt von einer Modifikation (Zuweisung)

Kurzform Aequivalente ausführlichere Version variable += value; variable = variable + value;

variable -= value; variable = variable - value;

variable *= value; variable = variable * value;

variable /= value; variable = variable / value;

variable %= value; variable = variable % value;

§ Modifikation mit beliebigen Werten (nicht nur 1)

(11)

Weitere Kurzformen

Beispiele

x += 3; // x = x + 3;

note -= 0.5; // note = note - 0.5;

number *= 2; // number = number * 2;

Warnung:

x += 1; // x = x + 1;

x =+ 1; // x = + 1;

(12)

Die Java Math Klasse

Method name Description

Math.abs(value₎ absolute value Math.ceil(value₎ _{rounds up} Math.floor(value₎ rounds down

Math.log10(value₎ logarithm, base 10 Math.max(value1_, value2₎ larger of two values Math.min(value1_, value2₎ smaller of two values Math.pow(base_, exp₎ base to the exp power

Math.random() random double between 0 and 1 Math.round(value₎ nearest whole number

Math.sqrt(value₎ square root Math.sin(value₎

Math.cos(value₎ Math.tan(value₎

sine/cosine/tangent of an angle in radians

Math.toDegrees(value₎ Math.toRadians(value₎

convert degrees to radians and back

Constant Description Math.E 2.7182818...

Math.PI 3.1415926...

(13)

Aufruf von Math Methoden

Math.methodName(parameters)

§ Beispiele:

double squareRoot = Math.sqrt(121.0);

System.out.println(squareRoot); // 11.0 int absoluteValue = Math.abs(-50);

System.out.println(absoluteValue); // 50 System.out.println(Math.min(3, 7) + 2); // 5

(14)

Math Fragen

§ Was ist das Ergebnis dieser Ausdrücke:

§ Math.abs(-1.23)

§ Math.pow(3, 2)

§ Math.pow(10, -2)

§ Math.sqrt(121.0) - Math.sqrt(256.0)

§ Math.round(Math.PI) + Math.round(Math.E)

§ Math.ceil(6.022) + Math.floor(15.9994)

§ Math.abs(Math.min(-3, -5))

(15)

Besonderheiten von Math Methoden

§ Nicht alle Math Methoden lieferen einen int Wert den wir erwarten (könnten), manche z.B. liefern einen double Wert.

int x = Math.pow(10, 3); // ERROR: incompatible types

§ Andere Aspekte der reellen Zahlen und des Typs double werden wir später kennen lernen

(16)

Typ Umwandlungen

§ Ausser impliziten Umwandlungen gibt es die Möglichkeit, explicit eine Umwandlung vorzunehmen.

§ implizit: double f = 1.0 / 4;

§ explizite Umwandlungen heissen "cast" oder "type cast"

§ type cast: Umwandlung von einem Typ in den anderen.

§ Um int in double umzuwandeln damit / das gewünschte Ergebnis liefert

§ Um einen double Wert in einen int Wert zu verwandeln

(17)

Typ Umwandlungen

§ Syntax:

(type) expression

§ Beispiele:

double result = (double) 19 / 5; // 3.8 int result2 = (int) result; // 3

int x = (int) Math.pow(10, 3); // 1000

(18)

Typ Umwandlungen

§ (type) ist ein Operator

§ Der "cast operator"

§ Für alle Basistypen verfügbar

(19)

Bemerkungen über explizite Umwandlungen

§ Typ Umwandlungen hat hohe Präzedenz und der Cast

Operator bezieht sich nur auf den (Teil)Ausdruck direkt neben sich.

§ double x = (double) 1 + 1 / 2; // 1.0

§ double y = 1 + (double) 1 / 2; // 1.5

§ Mit Klammern kann man die Reihenfolge der Auswertung verändern.

§ double average = (double) (a + b + c) / 3;

§ Umwandlungen zu double sind auch implizit möglich.

§ double average = 1.0 * (a + b + c) / 3;

(20)

Die Java Random Klasse

random {adj}

zufällig

willkürlich [wahllos]

zufallsbedingt Zufalls-

dem Zufall überlassen (aus E-D Wörterbuch)

35

(21)

Die Java Random Klasse

§ Die Random Klasse liefert uns einen Zufallszahlengenerator

§ Pseudozufallszahlen.

§ Klasse Random ist auch in java.util.

import java.util.*;

nextInt() returns a random integer

nextInt(max) returns a random integer in the range [0, max) in other words, 0 to max-1 inclusive

nextDouble() returns a random real number in the range [0.0, 1.0)

(22)

Die Java Random Klasse

§ Beispiel:

import java.util.*;

Random rand = new Random();

int randomNumber = rand.nextInt(10); // 0-9

nextInt() returns a random integer

nextInt(max) returns a random integer in the range [0, max) in other words, 0 to max-1 inclusive

nextDouble() returns a random real number in the range [0.0, 1.0)

(23)

Erzeugen von Zufallszahlen

§ Häufig brauchen wir (ganze) Zufallszahlen zwischen 1 und N

int n = rand.nextInt(20) + 1; // 1-20 inclusive

§ Um eine ganze Zahl in irgendeinem Interval [min, max] zu bekommen (inklusiv Grenzen):

name.nextInt(size of range) + min

mit (size of range) gleich (max - min + 1)

§ Beispiel: Eine zufällige ganze Zahl zwischen 4 und 10 einschliesslich:

int n = rand.nextInt(7) + 4;

(24)

Fragen zu Random

Mit dieser Deklaration, wie würden Sie erhalten:

Random rand = new Random();

§ Eine zufällige ganze Zahl zwischen 1 und 47 einschliesslich?

int random1 = rand.nextInt(47) + 1;

§ Eine zufällige ganze Zahl zwischen 23 und 30 einschliesslich?

int random2 = rand.nextInt(8) + 23;

§ Eine zufällige ganze gerade Zahl zwischen 4 and 12 einschliesslich?

int random3 = rand.nextInt(5) * 2 + 4;

(25)

Random und andere Basistypen

§ Die Methode nextDouble liefert eine reelle Zahl (double) zwischen 0.0 und 1.0

§ Beispiel: eine zufällige Note zwischen 1.0 and 6.0:

double randomGrade = rand.nextDouble() * 5.0 + 1.0;

§ Jede Menge von Werten kann auf die ganzen Zahlen abgebildet werden

(26)

Random und andere Basistypen

§ Jede Menge von Werten kann auf die ganzen Zahlen abgebildet werden

§ Code um zufällig Schere-Stein-Papier zu spielen:

int r = rand.nextInt(3);

if (r == 0) {

System.out.println("Schere");

} else if (r == 1) {

System.out.println("Stein");

} else { // r == 2

System.out.println("Papier");

}

(27)

Frage zu Random

§ Schreiben Sie ein Programm um das Rollen zweier Würfel (mit je 6 Seiten) zu simulieren bis die Summe der Würfel 7 ergibt.

2 + 4 = 6 3 + 5 = 8 5 + 6 = 11 1 + 1 = 2 4 + 3 = 7

Sie haben nach 5 Versuchen gewonnen!

(28)

Lösung

// Rolls two dice until a sum of 7 is reached.

import java.util.*;

public class Dice {

public static void main(String[] args) { Random rand = new Random();

int tries = 0;

int sum = 0;

while (sum != 7) {

// roll the dice once

int roll1 = rand.nextInt(6) + 1;

int roll2 = rand.nextInt(6) + 1;

sum = roll1 + roll2;

System.out.println(roll1 + " + " + roll2 + " = " + sum);

tries++;

}

System.out.println("Sie haben nach " + tries + " Versuchen gewonnen!");

} }

(29)

do/while Lösung

// Rolls two dice until a sum of 7 is reached.

import java.util.*;

public class Dice {

public static void main(String[] args) { Random rand = new Random();

int tries = 0;

int sum;

do {

int roll1 = rand.nextInt(6) + 1; // one roll int roll2 = rand.nextInt(6) + 1;

sum = roll1 + roll2;

System.out.println(roll1 + " + " + roll2 + " = " + sum);

tries++;

} while (sum != 7);

System.out.println("Sie haben nach " + tries + " Versuchen gewonnen!");

} }

(30)

3.5 (Mehr über) Funktionen

45

(31)

Beispiel aus den Uebungen

§ Sie erinnern sich (vielleicht):

public static void main (String[] args) { int f = 0;

int g = 1;

for (int i= 0; i < 15; i++ ) { System.out.print(" " + f);

f = f + g;

g = f - g;

}

System.out.println();

} ⁴⁶

(32)

§ Output: 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377

47

(33)

f = 0;

g = 0;

loop {

f_new = f + g;

g_new = f_new – g;

f = f_new; g = g_new;

}

48

f_1 = f _0 + g_0;

g_1 = f_1 – g_0;

f_2 = f _1 + g_1;

g_2 = f_2 – g_1;

(34)

f = 0;

g = 1;

loop {

f_new = f + g;

}

49

f_1 = f _0 + g_0;

g_1 = f_1 – g_0;

f_2 = f _1 + f_1 – g_0;

g_2 = f_2 – (f_1 – g_0);

f_3 = f _2 + g_2;

g_3 = f_3 – g_2;

(35)

f = 0;

g = 1;

loop {

f_new = f + g;

}

50

f_1 = f _0 + g_0;

g_1 = f_1 – g_0;

f_2 = f _1 + f_1 – g_0;

g_2 = f_2 – (f_1 – g_0);

f_3 = f _2 + f_2 – (f_1 – g_0);

g_3 = f_3 – (f_2 – (f_1 – g_0));

(36)

f = 0;

g = 1;

loop {

f_new = f + g;

}

51

f_1 = f _0 + g_0; // 1 g_1 = f_1 – g_0; // 0 f_2 = f _1 + f_1 – g_0;

g_2 = f_2 – (f_1 – g_0);

f_3 = f _2 + f_2 – (f_1 – g_0);

g_3 = f_3 – (f_2 – (f_1 – g_0));

(37)

f = 0;

g = 1;

loop {

f_new = f + g;

}

52

f_1 = f _0 + g_0; // 1 g_1 = f_1 – g_0; // 0 f_2 = f _1 + 0;

g_2 = f_2 – 0; // f_1 f_3 = f _2 + f_2 – 0;

g_3 = f_3 – (f_2 – 0);

(38)

f = 0;

g = 1;

loop {

f_new = f + g;

}

53

f_1 = f _0 + g_0; // 1 g_1 = f_1 – g_0; // 0 f_2 = f _1 + 0;

g_2 = f_2 – 0; // f_1 f_3 = f _2 + f_1;

g_3 = f_3 – (f_2 – 0);

(39)

f = 0;

g = 1;

loop {

f_new = f + g;

}

54

f_1 = f _0 + g_0; // 1 g_1 = f_1 – g_0; // 0 f_2 = f _1 + 0;

g_2 = f_2 – 0; // f_1 f_3 = f _2 + f_1;

g_3 = f_3 – (f_2 – 0);

f_4 = f_3 + g_3

(40)

f = 0;

g = 1;

loop {

f_new = f + g;

}

55

f_1 = f _0 + g_0; // 1 g_1 = f_1 – g_0; // 0 f_2 = f _1 + 0;

g_2 = f_2 – 0; // f_1 f_3 = f _2 + f_1;

g_3 = f_3 – (f_2 – 0);

f_4 = f_3 + f_3 – (f_2 – 0);

(41)

f = 0;

g = 1;

loop {

f_new = f + g;

}

56

f_1 = f _0 + g_0; // 1 g_1 = f_1 – g_0; // 0 f_2 = f _1 + 0;

g_2 = f_2 – 0; // f_1 f_3 = f _2 + f_1;

g_3 = f_3 – (f_2 – 0);

f_4 = f_3 + f _2 + f_1 – (f_2 – 0);

(42)

f = 0;

g = 1;

loop {

f_new = f + g;

}

57

f_1 = f _0 + g_0; // 1 g_1 = f_1 – g_0; // 0 f_2 = f _1 + 0;

g_2 = f_2 – 0; // f_1 f_3 = f _2 + f_1;

g_3 = f_3 – (f_2 – 0);

f_4 = f_3 + f _2 + f_1 – f_1;

(43)

f = 0;

g = 1;

loop {

f_new = f + g;

}

58

f_1 = f _0 + g_0; // 1 g_1 = f_1 – g_0; // 0 f_2 = f _1 + 0;

g_2 = f_2 – 0; // f_1 f_3 = f _2 + f_1;

g_3 = f_3 – (f_2 – 0);

f_4 = f_3 + f _2;

(44)

Ein anderes Programm

public static void main (String[] args) { int f = 0;

for (int i = 2; i < 15; i++ ) { System.out.print(f + " ");

f = fct(i-1) + fct(i-2);

}

} 60

(45)

Ein anderes Programm

public static int fct (int arg) { if (arg==0) { return 0; }

else if (arg == 1) { return 1; }

else { return (fct(arg-1) + fct(arg-2)); } }

61

(46)

In Zeitlupe

:: 0 ::

level = 0 arg = 1

level = 0 arg = 1 return = 1 level = 0 arg = 0

level = 0 arg = 0 return = 0 :: 1 ::

level = 0 arg = 2 level = 1 arg = 1

level = 1 arg = 0 return = 0 level = 0 arg = 2 return = 1 level = 0 arg = 1

level = 0 arg = 1 return = 1 :: 2 ::

level = 0 arg = 3 level = 1 arg = 2

level = 2 arg = 1

level = 2 arg = 0 return = 0

63 level = 1 arg = 2 return = 1

level = 1 arg = 1

level = 1 arg = 1 return = 1 level = 0 arg = 3 return = 2 level = 0 arg = 2

level = 1 arg = 1

level = 1 arg = 0 return = 0 level = 0 arg = 2 return = 1

:: 3 ::

level = 0 arg = 4

…

level = 0 arg = 3 return = 2 :: 5 ::

(47)

Mit Ausgabe von Informationen zum Fortschritt

public static int fct (int level, int arg) { int x;

for (int j=0; j<level; j++) [ System.out.print(" ");}

System.out.println("level = " + level + " arg = " + arg);

if (arg==0) { x = 0; }

else if (arg == 1) { x = 1; }

else { x = fct(level+1, arg-1) + fct(level+1, arg-2); } for (int j=0; j<level; j++) { System.out.print(" ");}

System.out.println("l… = " + level + " a.. = " + arg + " r… = " + x);

return x;

}

64

(48)

Mit Ausgabe von Informationen zum Fortschritt

public static void main (String[] args) {

int f = 0;

for (int i = 2; i < 15; i++ ) {

System.out.println(" :: " + f + " ::");

f = fct(0, i-1) + fct(0, i-2);

}

65

(49)

Analyse

§ Problem: berechne Reihe

§ Gegeben durch for Schleife

§ Lösung: saubere Formulierung der Reihe

§ f_i = f_i-1 + f_i-2

§ Berechnung von f_i aus f_i-1 und f_i-2

§ Direkte Umsetzung in (rekursives) Programm

§ (direkte) Rekursion: Eine Methode ruft sich selber auf

§ Es muss (mindestens) eine Alternative geben, die nicht wieder die

Methode aufruft ₆₆

(50)

Analyse

§ Lösung hat 2 Teile

§ Die Methode fct ruft sich selber auf (Rekursion)

§ Direkt

return (fct(arg-1) + fct(arg-2));

§ Es muss (mindestens) eine Alternative geben, die nicht wieder die Methode aufruft (Basis)

§ Hier zwei Fälle die unterschieden werden

if (arg==0) { return 0; }

else if (arg == 1) { return 1; } ⁶⁷