252-0027 Einführung in die Programmierung I 3.0 Funk;onen

(1)

252-0027

Einführung in die Programmierung I 3.0 Funk;onen

Thomas R. Gross

Department Informa;k ETH Zürich

(2)

Uebersicht

!  3.1 Parameter

!  3.2 Return

2

(3)

Nochmal zur Uebung 2

!  Sie erinnern sich …

---

| |

| +++++++ |

| +++++++++++++++++++++ |

| +++++++ |

| |

| | ---

3

(4)

Viele Lösungen

public static void flag_simple() { line();

for (int i=0; i<2; i++) redarea();

for (int i=0; i<3; i++) cross();

for (int i=0; i<3; i++) core();

for (int i=0; i<3; i++) cross();

for (int i=0; i<2; i++) redarea();

line();

}

public static void line() { for (int i=0; i< 35; i++) System.out.print("-");

System.out.println();

}

public static void redarea() { System.out.print("|");

for (int i=0; i<33; i++) System.out.print(" ");

System.out.println("|");

} ₄

public static void cross() { System.out.print("|");

for (int i=0; i<7; i++) System.out.print("+");

}

(5)

Eine grössere Flagge

---

| |

| ++++++++++++++ |

| ++++++++++++++++++++++++++++++++++++++++++ |

| ++++++++++++++ |

| |

| | ---

5

(6)

Eine grössere Flagge

public static void flag_by_2() { line_large();

for (int i=0; i<2*2; i++) redarea_large();

for (int i=0; i<3*2; i++) cross_large();

for (int i=0; i<3*2; i++) core_large();

for (int i=0; i<3*2; i++) cross_large();

for (int i=0; i<2*2; i++) redarea_large();

line_large();

}

public static void line_large() { for (int i=0; i< 35*2-2; i++) System.out.print("-");

System.out.println();

}

public static void redarea_large() { System.out.print("|");

for (int i=0; i<33*2; i++) System.out.print(" ");

} ⁶

public static void cross_large() { System.out.print("|");

for (int i=0; i<7*2; i++) System.out.print("+");

}

(7)

Noch grössere Flaggen

!  Diese "Lösung" lässt nur eine Verdoppelung zu …

!  Was wenn wir auch andere Grössen wollen

!  OK, kein echtes Thema für println-basierte Programme aber es geht uns ja um das Prinzip

!  Wir brauchen einen Weg, die Ausgabe Anweisungen der gewünschten Grösse anzupassen

!  Parametrisierung: mit (veränderbaren) Parametern versehen

7

(8)

Parametrisierung

!  Parameter: Ein Wert den eine aufgerufene Methode von der aufrufenden Methode erhält.

!  Aufrufende Methode: "caller"

!  Sta_ flag_simple, flag_by_2, entwickle flag so dass Flaggen verschiedener Grössen gezeichnet werden können.

!  Wenn wir eine Methode deklarieren dann geben wir an dass diese Methode einen Parameter braucht, der die Grösse bes`mmt.

!  Wenn wir die Method aufrufen dann geben wir den Vergrösserungsfaktor an.

(9)

Parametrisierung

main 1 flag

flag 2

---

| |

| +++++++ |

| +++++++++++++++++++++ |

| +++++++ |

| |

| | ---

---

| |

| ++++++++++++++ |

| ++++++++++++++++++++++++++++++++++++++++++ |

| ++++++++++++++ |

| |

| | ---

(10)

Parameterdeklara`onen

Gibt an dass eine Methode einen Parameter braucht um ausgeführt werden zu können

public static void name ( type name ) { statement(s);

}

!  Beispiel:

public static void echoPin(int code) {

System.out.println(”Die Geheimnummer ist: " + code);

}

name: Parameter Variable

(11)

Parameterdeklara`onen

Gibt an dass eine Methode einen Parameter braucht um ausgeführt werden zu können

public static void name ( type name ) { statement(s);

}

!  Beispiel:

public static void echoPin(int code) {

System.out.println(”Die Geheimnummer ist: " + code);

}

!  Wenn echoPin aufgerufen wird dann muss der Aufrufer einen int Wert angeben.

(12)

Wert(e) für Parameter

Beim Aufruf einer Methode müssen Werte für die Parameter angegeben werden.

name (expression);

!  Beispiel:

public static void main(String[] args) { echoPin(42);

echoPin(12345);

}

!  Output

Die Geheimnummer ist: 42 Die Geheimnummer ist: 12345

(13)

Parameter und Schleifen

!  Ein Parameter kann die Anzahl der Itera`onen (Ausführungen des Rumpfes) einer Schleife kontrollieren

public static void main(String[] args) { printPunkt(3);

}

public static void printPunkt(int times) { for (int i = 1; i <= times; i++) {

System.out.println(“.");

}

Output: …

(14)

Wie werden Parameter übergeben?

!  Uebergeben: vom Aufrufer zur augerufenen Methode

!  Wenn eine Methode aufgerufen wird dann:

!  Der Wert wird in der Parameter Variable gespeichert

!  Die Anweisungen der Methode werden ausgeführt (mit diesem Wert für die Parameter Variable).

!  Der Wert den der Aufrufer übergibt kann durch eine Variable gegeben sein

!  Der Wert kann durch einen Ausdruck berechnet werden

(15)

Wie werden Parameter übergeben?

public static void main(String[] args) { printPunkt(3);

printPunkt(7);

}

public static void printPunkt(int times) { for (int i = 1; i <= times; i++) {

System.out.println(“.");

} }

3 7

(16)

Mögliche Fehler

!  Wenn eine Methode einen Parameter erwartet dann muss dieser auch übergeben werden.

printPunkte(); // ERROR: parameter value required

!  Der Wert muss den rich`gen Typ hben

printPunkte(3.7); // ERROR: must be of type int Die Regeln für Umwandlungen gelten auch hier

(17)

Mehrere Parameter

!  Eine Methode kann mehrere Parameter erwarten (durch , getrennt in Deklara`on und im Aufruf)

!  Wenn die Methode aufgerufen wird muss ein Wert für jeden Parameter angegeben werden

!  Deklara`on:

public static void name (type name, ..., type name) { statement(s);

}

!  Aufruf: name (value, value, ..., value);

(18)

Beispiel mit mehreren Parametern

public static void main (String[] args) { Scanner console = new Scanner(System.in);

System.out.print("Input lower bound: ");

int low = console.nextInt();

System.out.print("Input upper bound: ");

int up = console.nextInt();

printOdd(low, up);

printOdd(-up, -low);

}

public static void printOdd(int from, int to) { for (int i=from; i<=to; i++) {

if (i%2==1) { System.out.println(i);

} } }

(19)

Wie werden Parameter übergeben?

!  Wenn eine Methode aufgerufen wird:

!  Der übergebene Wert wird in der Parameter Variable gespeichert

!  Die Anweisungen der Methode werden ausgeführt (mit diesem Wert für die Parameter Variable).

!  Der Wert, den der Aufrufer übergibt, kann durch eine Variable gegeben sein

!  Der Wert der Variable wird verwendet

!  Die aufgerufene Methode erhält den Wert und hat keine Kenntnis wie der Wert berechnet wurde

!  Insbesondere kennt die aufgerufene Methode nicht die Variablen des Aufrufers

(20)

Uebergabe von Werten (“Value seman`cs”)

!  Wenn ein Parameter durch eine Variable V eines Basistyps (int, double,boolean) bes`mmt wird dann wird der Wert dieser Variable kopiert (“value seman;cs”):

!  Veränderungen der Parameter Variable in der aufgerufenen Methode haben keine Auswirkung auf V.

(21)

Uebergabe von Werten (“Value seman`cs”)

public static void strange(int x) { x = x + 1;

System.out.println("1. x = " + x);

}

public static void main(String[] args) { int x = 23;

strange(x);

System.out.println("2. x = " + x);

...

}

Output:

1. x = 24 2. x = 23

(22)

Ergebnis Rückgabe

!  Parameter erlauben Kommunika`on vom Aufrufer zur aufgerufenen Methode

!  Bisher waren die Methoden sehr einfach und druckten Text

!  Methoden können aber mehr –

!  Ein Rückgabewert (“return value”) erlaubt der aufgerufenen Methode dem Aufrufer einen Wert zu übermi_eln

27

(23)

Rückgabe eines Wertes

!  Ein Rückgabewert muss deklariert werden

public static type name(parameters) { statements;

...

return expression;

}

!  Es gelten die selben Regeln für type wie bei der Deklara`on von Variablen und Parametern

(24)

Rückgabe Anweisung

!  Das return Statement (Rückgabe Anweisung) wertet einen Ausdruck aus .

! Der Wert wird dann an den Aufrufer “zurückgegeben”

! Der Ausdruck muss einen Wert des Typs type (der Methoden Deklara`on) ergeben.

! Die Ausführung der return Anweisung beendet die aufgerufene Methode.

(25)

Rückgabeanweisung (“return”)

!  return: Liefere einen Wert ab als das Ergebnis dieser Methode

!  “sende” das Ergebnis zum Aufrufer

!  Das Gegenstück zu Parametern:

!  Parameters schicken Werte in die aufgerufene Methode, vom Aufrufer

!  Rückgabewerte schicken Werte aus der Methode zum Aufrufer

!  Ein Methodenaufruf kann Teil eines Ausdrucks sein.

(26)

Rückgabeanweisung (“return”)

main

abs(-42) -42

round(2.71) 2.71

42

3

(27)

Rückgabe eines Wertes

Beispiel:

// Returns the slope of the line between the given points.

public static double slope(int x1, int y1, int x2, int y2) { double dy = y2 - y1;

double dx = x2 - x1;

return dy / dx;

}

slope(1, 3, 5, 11) liefert 2.0

(28)

return ohne einen Wert

Wenn eine Methode keinen Wert zurück liefert dann braucht ein return Statement keinen Wert zu schicken.

.

public static void printPoint(int x, int y) {

System.out.println(“x = “ + x + “ y = “ + y) ; return;

}

In dem Fall kann man das return Statement auch weglassen (meine Empfehlung)

(29)

Weitere Beispiele

Ein return Statement kann auch einen (arithme`schen oder booleschen) Ausdruck verwenden

public static double fToC(double degreesF) { return 5.0 / 9.0 * (degreesF - 32);

}

(30)

Mögliche Fehler: Resultat nicht gespeichert

!  Ein return Statement schickt einen Wert an den Aufrufer

!  Namen, die in der aufgerufenen Methode verwendet werden, sind belanglos (für den Aufrufer)

(31)

Was ist hier nicht rich`g?

public static void main(String[] args) { slope(0, 0, 6, 3);

System.out.println("The slope is " + result); // ERROR:

} // result not defined public static double slope(int x1, int x2, int y1, int y2) { double dy = y2 - y1;

double result = dy / dx;

return result;

}

(32)

Den Fehler vermeiden

!  return schickt den Wert der Variable zurück zum Aufrufer.

!  Der zurückgegebene Wert muss gespeichert werden – oder in einem Ausdruck verwendet werden.

!  Der Compiler generiert keine Warnung oder Fehlermeldung wenn dies vergessen wird.

(33)

Den Fehler vermeiden

public static void main(String[] args) { double s = slope(0, 0, 6, 3);

System.out.println("The slope is " + s);

}

public static double slope(int x1, int x2, int y1, int y2) {

double dy = y2 - y1;

double result = dy / dx;

return result;

}

(34)

return Anweisungen

!  Eine Methode kann mehrere return Anweisungen enthalten.

!  Sinnvoll für Fallunterscheidungen

!  Eine Methode die einen Rückgabewert deklariert muss eine (oder mehrere) return Anweisung(en) enthalten

40

(35)

if/else mit return

// Returns the larger of the two given integers.

public static int max(int a, int b) { if (a > b) {

return a;

} else {

return b;

} }

!  Methoden können ein return Statement in durch if/else kontrollierten Blöcken enthalten

!  Das return am Ende eines Pfades liefert den Rückgabewert für diese Methode.

(36)

if/else mit return

!  Die Ausführung eines return Statements beendet die aufgerufene Methode.

!  Einem return sollten keine weiteren Anweisungen folgen

!  Alle Pfade durch eine Methode müssen ein return Statement enthalten

!  Wenn die Methode einen Rückgabewert deklariert hat

(37)

44

(38)

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

(39)

if/else, return Beispiellösung

public static int quadrant(double x, double y) { if (x > 0 && y > 0) {

return 1;

} else if (x < 0 && y > 0) { return 2;

} else if (x < 0 && y < 0) { return 3;

} else if (x > 0 && y < 0) { return 4;

} else { // at least one coordinate equals 0 return 0;

} }

(40)

if/else, return weitere Beispiele

!  Schreiben Sie eine Methode countFactors die die Anzahl der Faktoren (Teiler) einer Zahl liefert.

!  countFactors(24) liefert 8 da

1, 2, 3, 4, 6, 8, 12, und 24 alle Teiler von 24 sind.

(41)

if/else, return weitere Beispiele

!  Lösung:

// Returns how many factors the given number has.

public static int countFactors(int number) { int count = 0;

for (int i = 1; i <= number; i++) { if (number % i == 0) {

count++; // i is a factor of number }

}

return count;

}

(42)

Sichtbarkeit von Variablennamen

!  "Scope"

!  1. Approxima`on

!  Weitere Aspekte in späteren Vorlesungen

49

(43)

Scope (Sichtbarkeitsbereich)

scope: Der Teil eines Programm in dem eine Variable sichtbar ist.

!  Variable müssen deklariert sein bevor sie sichtbar sind

!  Deklara`onen müssen eindeu`g sein

! Sichtbar von Deklara`on bis zum Ende des Blocks (der durch { } angegeben wird)

! Eine Variable die in einer for Schleife deklariert wurde kann nur im Rumpf der Schleife verwendet werden.

! Eine Variable die in einer Methode deklariert wurde exis`ert nur in der Methode.

(44)

Scope (Sichtbarkeitsbereich)

public static void example() { int x = 3;

for (int i = 1; i <= 10; i++) { System.out.println(x+i);

} // i no longer exists here System.out.println(x);

} // x ceases to exist here

x's scope

i's scope

(45)

Folgen der Sichtbarkeitsregeln

! Variable ohne überlappenden Sichtbarkeitsbereich können den selben Namen haben.

for (int i = 1; i <= 100; i++) { System.out.print("/");

}

for (int i = 1; i <= 100; i++) { // OK System.out.print("\\");

}

int i = 5; // OK: outside of loop's scope

(46)

Folgen der Sichtbarkeitsregeln

! Eine Variable kann in einem Sichtbarkeitsbereich nicht mehrmals deklariert werden.

for (int i = 1; i <= 100 * line; i++) {

int i = 2; // ERROR: overlapping scope System.out.print("/");

}

i = 4; // ERROR: outside scope

!  Eine Variable kann nicht ausserhalb ihres Sichtbarkeitsbe- reiches verwendet werden

(47)

Sichtbarkeitsregeln für Parameter Variable

! Die selben Regeln gelten für Parameter Variable

(48)

Scope (Sichtbarkeitsbereich)

public static void function(int k) { int x = 3;

int y = k+x;

System.out.println(y);

} // k ceases to exist here

k's scope

y's scope

(49)

Scope (Sichtbarkeitsbereich)

public static void function(int k) { int x = 3;

int y = anotherfct(k+x);

System.out.println(y);

} // k ceases to exist here

public static void anotherFct(int x) { int y= 5;

System.out.println(x+5);

}

k's scope

(50)

Aufruf einer Methode …

!  Wenn eine Methode aufgerufen wird so wird automa`sch Platz für ihre Variablen geschaﬀen

!  Lokale Variable: Deklariert in der Methode

!  Parameter Variable: Deklariert in der Methodendeklara`on

!  Wenn ein Block ausgeführt wird (in dem Variable deklariert sind) dann wird zu Beginn der Ausführung des Blocks Platz für die Variable/n geschaﬀen.

(51)

String Literals

!  string: Eine Folge von Buchstaben

!  Nur eine Zeile, ggf. mit Ersatzdarstellungen

!  Können auch einen Namen bekommen.

String name = "text";

String name = expression;

!  Examples:

String name = ”Robin Williams";

int x = 3;

int y = 5;

String point = "(" + x + ", " + y + ")";

(52)

Stringparameter

public class StringParameters {

public static void main(String[] args) { sayHello(”Mark");

String friend = ”Peter";

sayHello(friend);

}

public static void sayHello(String name) { System.out.println("Welcome, " + name);

} }

(53)

Stringparameter

public class StringParameters {

public static void main(String[] args) { sayHello(”Mark");

String friend = ”Peter";

sayHello(friend);

}

public static void sayHello(String name) { System.out.println("Welcome, " + name);

} }

Output:

Welcome, Mark Welcome, Peter

(54)

Strings

!  Strings erlauben Zugriﬀ auf die Buchstaben die den Text ausmachen.

!  Weil Strings wich`g sind werden sie vom Compiler besonders behandelt

!  Wir ha_en schon bei int und double gesehen dass prak`sche Ueberlegungen die Programmierer zwingen, sich um Details zu kümmern

!  Auch Strings erfahren eine Sonderbehandlung

(55)

Elemente eines Strings

!  Auf die einzelnen Buchstaben eines Strings wird mit einen Index zugegriﬀen (Basis 0) :

String name = ”B. Dylan";

!  Index des ersten Buchstaben: 0

!  Index des letzten Buchstabens: 1 weniger als die Länge des Strings

!  Die einzelnen Buchstaben sind Werte des (Basis) char (später mehr)

! Strings sind keine Arrays (Felder).

index 0 1 2 3 4 5 6 7

character B . D y l a n

(56)

Strings

!  Zugriﬀ auf Elemente eines Strings erfolgt mit (vordeﬁnierten) Methoden

!  Aufruf dieser Methoden in Punktnotaòn (Dot Notaòn) (“dot notaòn”)

String s = “hello”;

s.method(parameterValues);

!  Führe Methode method für s aus, “wende method auf s an”, rufe method für s auf

63

(57)

String Methoden

! Beispiel

String writer = ”S. Beckett";

System.out.println(writer.length()); // 10

Method name Description

indexOf(str) index where the start of the given string appears in this string (-1 if not found) length() number of characters in this string substring(index1, index2)

or

substring(index1)

the characters in this string from index1 (inclusive) to index2 (exclusive);

if index2 is omitted, grabs till end of string toLowerCase() a new string with all lowercase letters toUpperCase() a new string with all uppercase letters

(58)

String weitere Beispiele

// index 0123456789012 String s1 = "Alice Munro";

String s2 = "Doris Lessing";

System.out.println(s1.length()); // 11 System.out.println(s1.indexOf("e")); // 4 System.out.println(s2.substring(6, 9)); // ”Les"

String s3 = s2.substring(1, 7);

System.out.println(s3.toLowerCase()); // ”oris l”

! Mit diesem String

// index 012345678901234567890123456789012 String class = ”Einfuehrung in die Programmierung";

Wie würden Sie das Wort ”die” extrahieren ?

(59)

String Literale

! Methoden wie substring und toLowerCase

konstruieren und liefern einen neuen String zurück, sie

modiﬁzieren nicht den String für den sie aufgerufen wurden.

String s = ”Hello World";

s.toUpperCase();

System.out.println(s); // Hello World

!  Um den Wert zu verändern muss dieser wieder einer Variablen zugewiesen werden:

String s = "Hello World";

s = s.toUpperCase();

System.out.println(s); // HELLO WORLD

(60)

Scanner Methoden

!  Jede Methode wartet bis der Benutzer die Eingabe mit der

"ENTER" (oder "RETURN") Taste abschliesst.

!  Der eingegebene Wert kann weiter verarbeitet werden.

System.out.print("Wie alt sind Sie? "); // prompt int alter = console.nextInt();

System.out.println("Ihre Eingabe " + alter);

!  "prompt" (Auﬀorderung): Text der angibt welche Eingabe erwartet wird.

Method Description

nextInt() reads an int from the user and returns it nextDouble() reads a double from the user

next() reads a one-word String from the user nextLine() reads a one-line String from the user

(61)

! Scanner's next Methode liest ein Wort als String.

Scanner console = new Scanner(System.in);

System.out.print("What is your name? ");

String name = console.next();

name = name.toUpperCase();

System.out.println(name + " has " + name.length() + " letters and starts with " + name.substring(0, 1));

Output:

What is your name? Chamillionaire

CHAMILLIONAIRE has 14 letters and starts with C

Strings as user input

(62)

! Die Methode nextLine liest eine Zeile als String.

System.out.print("What is your address? ");

String address = console.nextLine();