Call by Value: Unterschied zwischen den Versionen
K |
Hauer (Diskussion | Beiträge) |
||
| Zeile 18: | Zeile 18: | ||
Die Methode <code>caller()</code> deklariert eine <code>int</code> Variable <code>i</code> mit dem Wert 5. Beim Aufruf von <code>callee(int a)</code> wird die übergebene Variable <code>i</code> nun zuerst zum Wert 5 aufgelöst. Dann wird die Funktion <code>callee(int a)</code> mit dem Wert 5 aufgerufen. Der Aufruf <code>callee(i)</code> ist also in diesem Falle nicht zu unterscheiden von einem Aufruf <code>callee(5)</code>. Hier sieht man zudem den Grund für das Verhalten von '''Call by Value''': | Die Methode <code>caller()</code> deklariert eine <code>int</code> Variable <code>i</code> mit dem Wert 5. Beim Aufruf von <code>callee(int a)</code> wird die übergebene Variable <code>i</code> nun zuerst zum Wert 5 aufgelöst. Dann wird die Funktion <code>callee(int a)</code> mit dem Wert 5 aufgerufen. Der Aufruf <code>callee(i)</code> ist also in diesem Falle nicht zu unterscheiden von einem Aufruf <code>callee(5)</code>. Hier sieht man zudem den Grund für das Verhalten von '''Call by Value''': | ||
| − | + | Eine Funktion, welche primitive Daten als Parameter erwartet, kann mit konstanten Werten wie <code>callee(5)</code> aufgerufen werden. Der Aufruf kann in diesem Fall keinen Einfluss auf die 5 haben, da der Ausdruck '''5''' konstant ist. | |
| − | Was tatsächlich passiert, ist, dass beim Aufruf einer Funktion ein neuer [[Stack#Stackframe | Stackframe]] für diesen Aufruf auf den [[Stack]] gelegt wird und die lokalen Parametervariablen innerhalb dieses Stackframes mit den übergebenen Werten initialisiert werden. Ein konstanter Aufruf von <code>callee(int a)</code> mit der Zahl 5 wäre also praktisch nicht zu unterscheiden von einer Methode, die folgendermaßen aussieht: | + | Was tatsächlich passiert, ist, dass beim Aufruf einer Funktion ein neuer [[Stack#Stackframe | Stackframe]] für diesen Aufruf auf den [[Stack]] gelegt wird und die lokalen Parametervariablen innerhalb dieses Stackframes mit den übergebenen Werten initialisiert werden. Ein '''konstanter''' Aufruf von <code>callee(int a)</code> mit der Zahl 5 wäre also praktisch nicht zu unterscheiden von einer Methode, die folgendermaßen aussieht: |
| − | <source lang=" | + | <source lang="java"> |
| + | public static callee(){ | ||
int a = 5; | int a = 5; | ||
a = a + 5; | a = a + 5; | ||
}</source> | }</source> | ||
| + | |||
| + | Da man jedoch eine Funktion für verschiedene Zwecke wieder verwenden will, versieht man Funktionen mit von außen veränderbaren Parametern, um eine allgemeine Lösung für verschiedene Probleme bereit stellen zu können. | ||
| + | |||
| + | Möchte man im Beispiel oben, den Wert der Variablen '''a''' außerhalb der Funktion ändern, benötigt die Funktion eine [[Rückgabe]], das heißt die Funktion muss eine Eingabe erhalten, etwas berechnen und das Ergebnis der Berechnung ''explizit'' zurück geben. | ||
| + | |||
| + | <source lang="java"> | ||
| + | public static void caller(){ | ||
| + | int a = 5; | ||
| + | a = callee(5); | ||
| + | } | ||
| + | |||
| + | public static void callee(int a){ | ||
| + | return a + 5; | ||
| + | } | ||
Version vom 7. Februar 2016, 17:18 Uhr
Als Call by Value bezeichnet man den Mechanismus der Parameterübergabe von primitiven Datentypen. Sein Pendant ist der Mechanismus des Call by Reference.
Dabei wird beim Aufruf einer Funktion der Wert einer Variable zuerst aufgelöst und dann direkt an die aufrufende Methode übergeben. Da die Parameter einer Funktion lokal auf dem Stack der Methode liegen, sind diese unabhängig von denen, die beim Aufruf der Methode verwendet wurden. Änderungen an den Parametervariablen haben demnach keinen Einfluss auf die Werte der übergebenen Variablen innerhalb der aufrufenden Methode.
Verwendung
Immer wenn eine Methode aufgerufen wird, werden übergebene Variablen zuerst aufgelöst und dann der resultierende Wert übergeben. Nehmen wir als Beispiel folgende zwei statische Methoden:
public static void caller(){
int i = 5;
callee(i);
}
public static void callee(int a){
a = a + 5;
}
Die Methode caller() deklariert eine int Variable i mit dem Wert 5. Beim Aufruf von callee(int a) wird die übergebene Variable i nun zuerst zum Wert 5 aufgelöst. Dann wird die Funktion callee(int a) mit dem Wert 5 aufgerufen. Der Aufruf callee(i) ist also in diesem Falle nicht zu unterscheiden von einem Aufruf callee(5). Hier sieht man zudem den Grund für das Verhalten von Call by Value:
Eine Funktion, welche primitive Daten als Parameter erwartet, kann mit konstanten Werten wie callee(5) aufgerufen werden. Der Aufruf kann in diesem Fall keinen Einfluss auf die 5 haben, da der Ausdruck 5 konstant ist.
Was tatsächlich passiert, ist, dass beim Aufruf einer Funktion ein neuer Stackframe für diesen Aufruf auf den Stack gelegt wird und die lokalen Parametervariablen innerhalb dieses Stackframes mit den übergebenen Werten initialisiert werden. Ein konstanter Aufruf von callee(int a) mit der Zahl 5 wäre also praktisch nicht zu unterscheiden von einer Methode, die folgendermaßen aussieht:
public static callee(){
int a = 5;
a = a + 5;
}
Da man jedoch eine Funktion für verschiedene Zwecke wieder verwenden will, versieht man Funktionen mit von außen veränderbaren Parametern, um eine allgemeine Lösung für verschiedene Probleme bereit stellen zu können.
Möchte man im Beispiel oben, den Wert der Variablen a außerhalb der Funktion ändern, benötigt die Funktion eine Rückgabe, das heißt die Funktion muss eine Eingabe erhalten, etwas berechnen und das Ergebnis der Berechnung explizit zurück geben.
public static void caller(){
int a = 5;
a = callee(5);
}
public static void callee(int a){
return a + 5;
}
