Pass-By-Value als Mechanismus zur Parameterübergabe in Java
1. Einführung
Die beiden am weitesten verbreiteten Arten, Argumente an Methoden zu übergeben, sind "Wertübergabe" und "Referenzübergabe". Verschiedene Programmiersprachen verwenden diese Konzepte auf unterschiedliche Weise. As far as Java is concerned, everything is strictly Pass-by-Value.
In diesem Tutorial werden wir veranschaulichen, wie Java Argumente für verschiedene Typen übergibt.
2. Pass-by-Value vs Pass-by-Reference
Beginnen wir mit einigen der verschiedenen Mechanismen zum Übergeben von Parametern an Funktionen:
-
Wert
-
Referenz
-
Ergebnis
-
Wert-Ergebnis
-
name
Die beiden häufigsten Mechanismen in modernen Programmiersprachen sind "Pass-by-Value" und "Pass-by-Reference". Bevor wir fortfahren, wollen wir zunächst Folgendes besprechen:
2.1. Pass-by-Value
Wenn ein Parameter als Wert übergeben wird, verarbeiten der Aufrufer und die Methode callee zwei verschiedene Variablen, die Kopien voneinander sind. Änderungen an einer Variablen ändern die andere nicht.
Dies bedeutet, dass beim Aufrufen einer Methodeparameters passed to the callee method will be clones of original parameters. Änderungen an der Callee-Methode keine Auswirkungen auf die ursprünglichen Parameter in der Aufrufermethode haben.
2.2. Pass-by-Reference
Wenn ein Parameter als Referenz übergeben wird, bearbeiten der Aufrufer und der Angerufene dasselbe Objekt.
Dies bedeutet, dassthe unique identifier of the object is sent to the method., wenn eine Variable als Referenz übergeben wird, alle Änderungen an den Instanzmitgliedern des Parameters dazu führen, dass diese Änderung am ursprünglichen Wert vorgenommen wird.
3. Parameterübergabe in Java
Die Grundbegriffe in jeder Programmiersprache sind "Werte" und "Referenzen". In Java werdenPrimitive variables store the actual values, whereas Non-Primitives store the reference variables which point to the addresses of the objects they’re referring to. Sowohl Werte als auch Referenzen im Stapelspeicher gespeichert.
Argumente in Java werden immer als Wert übergeben. Während des Methodenaufrufs wird im Stapelspeicher eine Kopie jedes Arguments erstellt, unabhängig davon, ob es sich um einen Wert oder eine Referenz handelt, die dann an die Methode übergeben wird.
Bei Grundelementen wird der Wert einfach in den Stapelspeicher kopiert und an die Methode callee übergeben. Bei nicht-primitiven Elementen verweist eine Referenz im Stapelspeicher auf die tatsächlichen Daten, die sich im Heap befinden. Wenn wir ein Objekt übergeben, wird die Referenz im Stapelspeicher kopiert und die neue Referenz an die Methode übergeben.
Lassen Sie uns dies nun anhand einiger Codebeispiele in Aktion sehen.
3.1. Primitive Typen übergeben
Die Java-Programmiersprache enthälteight primitive data types. Primitive variables are directly stored in stack memory. Whenever any variable of primitive data type is passed as an argument, the actual parameters are copied to formal arguments and these formal arguments accumulate their own space in stack memory.
Die Lebensdauer dieser formalen Parameter ist nur so lange gültig, wie diese Methode ausgeführt wird. Bei der Rückkehr werden diese formalen Argumente aus dem Stapel gelöscht und verworfen.
Versuchen wir es anhand eines Codebeispiels zu verstehen:
public class PrimitivesUnitTest {
@Test
public void whenModifyingPrimitives_thenOriginalValuesNotModified() {
int x = 1;
int y = 2;
// Before Modification
assertEquals(x, 1);
assertEquals(y, 2);
modify(x, y);
// After Modification
assertEquals(x, 1);
assertEquals(y, 2);
}
public static void modify(int x1, int y1) {
x1 = 5;
y1 = 10;
}
}Versuchen wir, die Aussagen im obigen Programm zu verstehen, indem wir analysieren, wie diese Werte im Speicher gespeichert sind:
-
Die Variablen "x”" und "y”" in der Hauptmethode sind primitive Typen und ihre Werte werden direkt im Stapelspeicher gespeichert
-
Wenn wir die Methodemodify() aufrufen, wird für jede dieser Variablen eine genaue Kopie erstellt und an einer anderen Stelle im Stapelspeicher gespeichert
-
Änderungen an diesen Kopien wirken sich nur auf sie aus und lassen die ursprünglichen Variablen unverändert
3.2. Objektreferenzen übergeben
In Java werden alle Objekte dynamisch im Heap-Bereich unter der Haube gespeichert. Diese Objekte werden aus Referenzen referenziert, die als Referenzvariablen bezeichnet werden.
Ein Java-Objekt wird im Gegensatz zu Primitiven in zwei Schritten gespeichert. Die Referenzvariablen werden im Stapelspeicher gespeichert, und das Objekt, auf das sie sich beziehen, wird in einem Heapspeicher gespeichert.
Immer wenn ein Objekt als Argument übergeben wird, wird eine exakte Kopie der Referenzvariablen erstellt, die auf dieselbe Position des Objekts im Heapspeicher verweist wie die ursprüngliche Referenzvariable.
As a result of this, whenever we make any change in the same object in the method, that change is reflected in the original object. Wenn wir der übergebenen Referenzvariablen jedoch ein neues Objekt zuweisen, wird es nicht im ursprünglichen Objekt wiedergegeben.
Versuchen wir dies anhand eines Codebeispiels zu verstehen:
public class NonPrimitivesUnitTest {
@Test
public void whenModifyingObjects_thenOriginalObjectChanged() {
Foo a = new Foo(1);
Foo b = new Foo(1);
// Before Modification
assertEquals(a.num, 1);
assertEquals(b.num, 1);
modify(a, b);
// After Modification
assertEquals(a.num, 2);
assertEquals(b.num, 1);
}
public static void modify(Foo a1, Foo b1) {
a1.num++;
b1 = new Foo(1);
b1.num++;
}
}
class Foo {
public int num;
public Foo(int num) {
this.num = num;
}
}Lassen Sie uns die Aussagen im obigen Programm analysieren. Wir haben Objektea andb inmodify() method übergeben, die den gleichen Wert1 haben. Anfänglich verweisen diese Objektreferenzen auf zwei unterschiedliche Objektpositionen in einem Heap-Bereich:
Wenn diese Referenzena andb in der Methodemodify() übergeben werden, werden Spiegelkopien der Referenzena1 andb1 erstellt, die auf dieselben alten Objekte verweisen:
Wenn wir in dermodify() -Smethod die Referenza1 ändern, ändert sich das ursprüngliche Objekt. Als Referenz habenb1, we jedoch ein neues Objekt zugewiesen. Es zeigt jetzt auf ein neues Objekt im Heapspeicher.
Änderungen anb1 spiegeln nichts im ursprünglichen Objekt wider:
4. Fazit
In diesem Artikel wurde untersucht, wie die Parameterübergabe bei Primitiven und Nicht-Primitiven behandelt wird.
Wir haben gelernt, dass die Übergabe von Parametern in Java immer "Pass-by-Value" ist. Der Kontext ändert sich jedoch abhängig davon, ob es sich um Grundelemente oder Objekte handelt:
-
Bei primitiven Typen werden die Parameter als Wert übergeben
-
Bei Objekttypen ist die Objektreferenz eine Wertübergabe
Die in diesem Artikel verwendeten Codefragmente befinden sich inover on GitHub.