Java-Aufruf per Referenz

Die Definition des Call-by-Reference in Java legt nahe, dass wir Parameter als Referenz verwenden. Wir senden die Argumentreferenz als Parameter an die Funktion, die diese verwenden wird. Wir liefern beide Argumente als tatsächliche und formale Parameter. Diese beziehen sich auf den genauen Standort. Das heißt, wenn Änderungen an einer bestimmten Funktion vorgenommen werden, werden diese Änderungen beim Aufruf des Prozesses in den tatsächlichen Parametern widergespiegelt. Es ist nicht erforderlich, es explizit anzugeben oder aufzurufen. Die Adresse der Variablen wird gesendet, was bedeutet, dass diese tatsächlichen Variablen die Funktion aufrufen.

WERBUNG Beliebter Kurs in dieser Kategorie JAVA MASTERY - Spezialisierung | 78 Kursreihe | 15 Probetests

Starten Sie Ihren kostenlosen Softwareentwicklungskurs

Webentwicklung, Programmiersprachen, Softwaretests und andere

Syntax

Im Folgenden finden Sie eine Möglichkeit, Call-by-Reference in Java zu implementieren:

void function_name(datatype1, datatype2); //Function declaration
int main()
{
Datatype declaration;
Function Call(datatype1, datatype2);
}
Function_name ()
{
// Function definition
}

Erklärung: Die obige Syntax deklariert zunächst eine Funktion. Im Gegensatz zu C gibt es in Java keine spezielle Bestimmung für die Übernahme der Variablen an einer bestimmten Adresse. Java verwendet Call-by-Value, das auch die Referenzvariablen übergibt.

Wie funktioniert Call by Reference in Java?

Die Grundfunktionalität von Call by Reference besteht darin, dass wir auf die Adresse der Variablen verweisen. Wenn sich also an der Adresse der Variablen eine Änderung ergibt, wird diese überall dort angezeigt, wo die Funktion aufgerufen wird, die sie verwendet. Der folgende Code hilft Ihnen, diese Funktionalität besser zu verstehen.

Code:

Void inc(int );
Public static voidmain(string args[]) {
int a = 10;
System.out.println("Before function was called the Value of a = ", a);
void inc();
System.out.println("After function is called Value of a = ", a);
}
Void inc(intx) {
int x = x + 1;
}

Hier haben wir die Funktion inc mit einer Variablen deklariert. Danach haben wir eine Variable deklariert. Die Variable nimmt den definierten Wert an. Aber im weiteren Verlauf rufen wir die Funktion „inc“ auf. Die Funktion „inc“ wird aufgerufen und zeigt bei jedem Aufruf auf den Speicherort der Variablen „a“. Es wird eine Kopie der Referenzvariablen erstellt und sobald Werte vorhanden sind, werden diese an die verwendeten Methoden übergeben. Diese Referenz verweist auf die Adresse unserer Variablen „a“. Dieser Wert wird erhöht und beim Aufruf der Funktion wird der Wert von dieser Adresse übernommen. In diesem Fall ist es 11, da die Inc-Funktion den Wert um 1 erhöht. Der Wert wird im Hauptteil gedruckt. Wir können auch eine Kopie der Referenzvariablen erstellen. Wenn ein neues Objekt oder eine neue Variable als Referenz erstellt wird, hat dies keine Auswirkungen, da die Primäradresse dieselbe bleibt.

Beispiele zur Implementierung von Java Call by Reference

Wir können uns dazu noch ein paar Beispiele ansehen, die uns helfen, es besser zu verstehen:

Beispiel #1

Austauschen von Nummern in Java mithilfe von Call by Reference. Der folgende Code ist ein Beispiel, in dem wir zwei Nummern mithilfe von Call-by-Reference austauschen können:

Code:

public class EduByReference {
public static void main(String[] args) {
int num1 = 55;
int num2 = 85;
System.out.println("The values before swapping are: number1 = " + num1 + " and number2 = " + num2);
// Calling the function to swap
swapByReference(num1, num2);
System.out.println("\nThe numbers before and after swapping will be same in main:");
System.out.println("Once the swapping is done, the values will be back to original: num1 = " + num1 + " and num2 is " + num2);
}
public static void swapByReference(int num1, int num2) {
System.out.println("Before swapping in function locally, num1 = " + num1 + " num2 = " + num2);
// Swapping number1 and number2
int temp = num1;
num1 = num2;
num2 = temp;
System.out.println("After swapping in function locally, num1 = " + num1 + " num2 = " + num2);
}
}

Ausgabe:

Erklärung: Das obige Programm vertauscht zwei Zahlen. Wir haben zwei ganzzahlige Variablen a und b mit den Werten 55 bzw. 85 genommen. Anschließend rufen wir die Funktion swapByReference(a, b) auf. Hier in dieser Funktion erhalten wir diese Variablen vom Hauptserver. Die Funktion nimmt die Werte von a und b und vertauscht dann die Werte dieser beiden Variablen. Zum Austauschen haben wir eine andere Variable verwendet, „c“. Sobald dies erledigt ist, gibt diese Funktion die Werte 85 und 55 zurück. Wir sehen, dass die Werte im Wesentlichen die gleichen bleiben wie zuvor. Dies ist die Verwendung eines Call-by-Reference. Sobald die Funktion aufgerufen wird, wird der ursprüngliche Wert unverändert gespeichert und die Werte werden für die Funktion geändert. Die ursprünglichen Werte bleiben erhalten. Die Ausgabe der obigen Funktion sieht wie folgt aus.

Sobald die Arbeit mit der Funktion abgeschlossen ist, werden die ursprünglichen Werte aufgrund der Adresse der Variablen beibehalten. Die Variablen haben ihre Position nicht verändert.

Beispiel #2

Hinzufügen von zwei Nummern mithilfe von Call-by-Reference in Java:

Code:

public class EduAddByReference{
int d=50;
public void add(int d){
d=d+100;//These changes will happen locally, that means it will be reflected only in this function
System.out.println("The value in function after performing addition is " + d);
}
public static void main(String args[]){
EduAddByReference edad=new EduAddByReference();
System.out.println("before change "+edad.d);
edad.add(500);
System.out.println("after change "+edad.d);
}
}

Ausgabe:

Erklärung: Das obige Programm ist ein weiteres Beispiel für eine Call-by-Referenz in Java. Hier im Wesentlichen haben wir die Funktion EduAddByReference() aufgerufen. Diese Funktion übernimmt die Nummer aus der Hauptnummer und fügt sie hinzu. Diese Ausgabe wird in der Funktion gedruckt. Dieser Wert für die Variable bleibt für diese Funktion lokal. Sobald die Steuerung der Funktion an die Hauptfunktion übergeben wird, wird die Variable erneut ausgegeben, die den ursprünglichen Wert hat. Sie können die folgende Ausgabe überprüfen, die uns dabei helfen wird, dieses Programm besser zum Laufen zu bringen.

Fazit

Der Call by Reference in Java ruft die Funktionen auf und verwendet die Adresse eines Operanden oder einer Variablen, um die Daten zu überprüfen. Der Wert ändert sich lokal und bleibt nur bis zum Gültigkeitsbereich der Funktion bestehen. Der Aufruf per Referenz hilft dabei, die ursprünglichen Werte beizubehalten und sie bei Bedarf zu ändern. Es kann immer dann verwendet werden, wenn eine Variable lokal eine Operation ausführen soll. Es behält die Originalität einer Variablen.

Das obige ist der detaillierte Inhalt vonJava-Aufruf per Referenz. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!