Unterschiede
Hier werden die Unterschiede zwischen der gewählten und der aktuellen Version gezeigt.
| start:info:11if:07_methoden 09.01.2009 07:59 | start:info:11if:07_methoden 23.10.2013 10:12 aktuell | ||
|---|---|---|---|
| Zeile 14: | Zeile 14: | ||
| **Beispiel:** mehrfache Auswertung der Funktion | **Beispiel:** mehrfache Auswertung der Funktion | ||
| - | <acm>f(x, n) = x^(2n) + n^2 - nx</acm> | + | <acm>f(x) = x^2 + 2x - 4</acm> |
| ===== Deklaration von Methoden ===== | ===== Deklaration von Methoden ===== | ||
| Zeile 21: | Zeile 21: | ||
| <code java> | <code java> | ||
| - | public <Rückgabetyp> <Methodenname> ( <Parameterliste> ) { | + | <Berechtigung> <Rückgabetyp> <Methodenname> ( <Parameterliste> ) { |
| <Anweisungen> | <Anweisungen> | ||
| } | } | ||
| </code> | </code> | ||
| + | |||
| + | **Berechtigung** | ||
| + | - ''public'' (default): Öffentlich, also auch für Objekte aus anderen Klassen zugänglich und ausführbar. | ||
| + | - ''private'': nicht öffentlich, nur Objekte dieser Klasse können die Methode ausführen. | ||
| + | - ''protected'': (später) | ||
| + | |||
| **Rückgabetyp:**\\ | **Rückgabetyp:**\\ | ||
| Das ist der Datentyp des Ergebnisses, das die Methode zurückliefern soll. | Das ist der Datentyp des Ergebnisses, das die Methode zurückliefern soll. | ||
| - | Soll die Methode keinen Wert zurückliefern, verwenden wir hier ''void''. | + | Man kann hier alle (Daten-)Typen, die man kennt, wählen. Falls keine Rückgabe erwünscht ist wählt man ''void''. |
| **Methodenname:**\\ | **Methodenname:**\\ | ||
| Zeile 35: | Zeile 41: | ||
| **Parameterliste:**\\ | **Parameterliste:**\\ | ||
| - | Eine Kommaliste von Variablendeklarationen. | + | Eine Kommaliste von Variablendeklarationen (in runden Klammern). |
| + | Falls keine Parameter vorhanden sind, dann kommt nur "''()''". (runde Klammer auf und wieder zu) | ||
| Die darin aufgeführten Variablen heißen //formale Parameter//. | Die darin aufgeführten Variablen heißen //formale Parameter//. | ||
| + | |||
| + | Anschließend kommt der "Rumpf" der Methode (also die eigentliche Implementierung mit ihren Anweisungen). | ||
| ===== Parameterübergabe und -rückgabe ===== | ===== Parameterübergabe und -rückgabe ===== | ||
| - | Der **Methodenkopf** für die Berechnung von <acm>f(x, n) = x^(2n) + n^2 - nx</acm> könnte | + | Der **Methodenkopf** für die Berechnung von <acm>f(x) = x^2 + 2x - 4</acm> könnte |
| lauten: | lauten: | ||
| <code java> | <code java> | ||
| - | public static double f(double x, int n) | + | public static double f(double x) |
| </code> | </code> | ||
| Zeile 65: | Zeile 74: | ||
| <code java> | <code java> | ||
| - | public static double f(double x, int n) { | + | public static double f(double x) { |
| - | double produkt = 1.0; | + | double ergebnis = x*x + 2*x -4; |
| - | for (int i=0; i<2*n ; i++) { | + | return ergebnis; |
| - | produkt = produkt * x; | + | |
| - | } | + | |
| - | return produkt + n*n - n*x; | + | |
| } | } | ||
| </code> | </code> | ||
| Zeile 78: | Zeile 84: | ||
| Wie eine Methode aus BlueJ aufgerufen wird wissen wir bereits. Wie aber wird nun eine Methode aus dem Programm heraus aufgerufen? Recht simpel: | Wie eine Methode aus BlueJ aufgerufen wird wissen wir bereits. Wie aber wird nun eine Methode aus dem Programm heraus aufgerufen? Recht simpel: | ||
| - | **Syntax:** | + | ^ ^ Methode ohne Rückgabe ^ Methode mit Rückgabetyp ^ |
| - | + | ^ **Syntax:**| <code java> | |
| - | <code java> | + | |
| Methodenname( Parameterliste ); | Methodenname( Parameterliste ); | ||
| - | </code> | + | </code> | <code java> |
| + | rueckgabe = Methodenname( Parameterliste ); | ||
| + | </code>| | ||
| + | ^ Beispiele | <code java> | ||
| + | public void sachTach(String name) { | ||
| + | System.out.println("Tach " + name); | ||
| + | } | ||
| + | </code> wird wie folgt aufgerufen: <code java> | ||
| + | sachTach("Peter"); | ||
| + | </code>| <code java> | ||
| + | public int laenge(String name) { | ||
| + | return name.length(); | ||
| + | } | ||
| + | </code> wird wie folgt aufgerufen (Bsp.): <code java> | ||
| + | int i = laenge("Peter"); //also i = 5 | ||
| + | </code> | | ||
| + | |||
| + | ''i'' muss hier den selben Typ wie den Rückgabetypen der Methode haben, also ''int''. | ||
| - | Dabei sollte man Folgendes im Hinterkopf behalten: | + | Folgendes sollte man auch noch im Hinterkopf behalten: |
| * Ein Methodenaufruf ist ein elementarer Ausdruck (wie ein Zuweisung, Variablendeklaration, Ausgabe...). | * Ein Methodenaufruf ist ein elementarer Ausdruck (wie ein Zuweisung, Variablendeklaration, Ausgabe...). | ||
| Zeile 101: | Zeile 123: | ||
| return x; | return x; | ||
| } else { | } else { | ||
| - | return x; | + | return y; |
| } | } | ||
| } | } | ||
| - | public double max(double x, double y) f | + | public double max(double x, double y) { |
| if (x>y) { | if (x>y) { | ||
| return x; | return x; | ||
| } else { | } else { | ||
| - | return x; | + | return y; |
| } | } | ||
| } | } | ||
| Zeile 116: | Zeile 138: | ||
| Dabe unterscheidet Java Methoden gleichen Namens... | Dabe unterscheidet Java Methoden gleichen Namens... | ||
| - | * anhand der Zahl der Parameter, | + | * anhand der **Zahl der Parameter**, |
| - | * anhand des Typs Typs der Parameter und | + | * anhand des **Typs der Parameter** und |
| - | * anhand der Position der Parameter. | + | * anhand der **Position der Parameter**. |
| Der Methodenkopf wird in diesem Zusammenhang auch **Signatur**((Unterschrift, also eine Art Erkennungsmerkmal)) genannt. | Der Methodenkopf wird in diesem Zusammenhang auch **Signatur**((Unterschrift, also eine Art Erkennungsmerkmal)) genannt. | ||
| Zeile 124: | Zeile 146: | ||
| ===== Rekursive Methoden ===== | ===== Rekursive Methoden ===== | ||
| - | Man darf in Methoden andere Methoden, aber auch sich selbst (also die eigene Methode) aufrufen. Dies nennt man **Rekursion**. Rekursion ist in Java erlaubt, d.h. Methoden dürfen sich selbst aufrufen! | + | Man darf in Methoden andere Methoden, aber auch sich selbst (also die eigene Methode) aufrufen. Diese letztgenannte Art nennt man **Rekursion**. Rekursion ist in Java erlaubt, d.h. Methoden dürfen sich selbst aufrufen! |
| **Beispiel: Methode zur Berechnung der Fibonacci-Zahlen Fi:** | **Beispiel: Methode zur Berechnung der Fibonacci-Zahlen Fi:** | ||
| Zeile 150: | Zeile 172: | ||
| </code> | </code> | ||
| + | ====== Aufgaben ====== | ||
| + | |||
| + | ^ ^ mit Rückgabe ^ ohne Rückgabe ^ | ||
| + | ^mit Parameter | | | | ||
| + | ^ohne Parameter | | | | ||
| + | - Erstelle die obige Tabelle in denen du je ein Beispiel zu den 4 möglichen Methodenköpfen (Signaturen) angibst. | ||
| + | - Was berechnet/macht die Methode ''max(int x, int y)''? | ||
| + | - Programmiere eine Methode ''min(int x, int y)''. | ||
| + | - Erstelle eine Klasse die den Benutzer nach drei Variablen a, b und c fragt und anschließend eine Methode ''quadFkt(double a, double b, double c)'' aufruft, die dann den Funktionswert von <acm>f(x) = ax^2 + bx + c</acm> berechnet. | ||
| + | - Programmiere eine Methode ''tausche(int x, int y)'', die den Inhalt zweier Variablen vertauscht. | ||
