Wie kann ich in Java ein Referenzübergabeverhalten trotz seiner Eigenschaft als Wertübergabe erreichen?

Referenzübergabe vs. Wertübergabe in Java

Java ist eine Wertübergabesprache, d. h., wenn Argumente an Methoden übergeben werden werden Kopien der Originalvariablen erstellt. Dies stellt die Datenintegrität sicher und verhindert unbeabsichtigte Änderungen. Es gibt jedoch Szenarien, in denen es wünschenswert sein kann, die Originalvariablen anstelle der Kopien zu ändern.

Übergabe als Referenzäquivalent in Java

In C als Referenz übergeben Ermöglicht die Übergabe von Variablen anhand ihrer Speicheradresse und ermöglicht so Änderungen an den ursprünglichen Werten. Während in Java ein expliziter Referenzübergabemechanismus fehlt, gibt es mehrere Techniken, die einen ähnlichen Effekt erzielen können:

1. Klassenmitgliedsvariable:

Wenn die Variable ein Klassenmitglied ist, können Sie eine Instanz der Klasse an eine Methode übergeben. Änderungen, die an der Mitgliedsvariablen innerhalb der Methode vorgenommen werden, werden im Originalobjekt widergespiegelt.

2. Den geänderten Wert zurückgeben:

Anstatt ihn als Referenz zu übergeben, können Sie den Wert ändern und von der Methode zurückgeben. Der Aufrufer kann dann den geänderten Wert wieder der ursprünglichen Variablen zuweisen.

3. Klasse oder statische Variable:

Wenn die Variable als Klasse oder statische Variable deklariert ist, kann auf sie global zugegriffen und sie geändert werden, auch innerhalb von Methoden.

4. Array-Trick:

Sie können ein Array mit einem einzelnen Element erstellen und es als Argument übergeben. Änderungen am Array-Element innerhalb der Methode ändern effektiv den Wert der ursprünglichen Variablen.

Beispiel:

Betrachten Sie den folgenden Java-Codeausschnitt, wo wir wollen Ändern Sie die an die Methode play() übergebene Variable „toyNumber“:

public class XYZ {
    public static void main(String[] args) {
        int toyNumber = 5;
        XYZ temp = new XYZ();
        temp.play(toyNumber);
        System.out.println("Toy number in main: " + toyNumber);
    }

    void play(int toyNumber) {
        System.out.println("Toy number in play: " + toyNumber);
        toyNumber++;
        System.out.println("Toy number in play after increment: " + toyNumber);
    }
}

Durch die Verwendung einer der oben beschriebenen Techniken können wir die gewünschte Ausgabe erzielen, bei der die ursprüngliche Variable „toyNumber“ in main() geändert wird:

Wahl 1 (Klassenmitgliedsvariable):

class Toy {
    int toyNumber;
}

public class XYZ {
    public static void main(String[] args) {
        Toy toy = new Toy();
        toy.toyNumber = 5;
        XYZ temp = new XYZ();
        temp.play(toy);
        System.out.println("Toy number in main: " + toy.toyNumber);
    }

    void play(Toy toy) {
        System.out.println("Toy number in play: " + toy.toyNumber);
        toy.toyNumber++;
        System.out.println("Toy number in play after increment: " + toy.toyNumber);
    }
}

Wahl 2 (Rückgabe des geänderten Werts):

public class XYZ {
    public static void main(String[] args) {
        int toyNumber = 5;
        XYZ temp = new XYZ();
        toyNumber = temp.play(toyNumber);
        System.out.println("Toy number in main: " + toyNumber);
    }

    int play(int toyNumber) {
        System.out.println("Toy number in play: " + toyNumber);
        toyNumber++;
        System.out.println("Toy number in play after increment: " + toyNumber);
        return toyNumber;
    }
}

Wahl 3 (Klasse oder statische Variable):

class XYZ {
    static int toyNumber = 5;

    public static void main(String[] args) {
        XYZ temp = new XYZ();
        temp.play();
        System.out.println("Toy number in main: " + toyNumber);
    }

    void play() {
        System.out.println("Toy number in play: " + toyNumber);
        toyNumber++;
        System.out.println("Toy number in play after increment: " + toyNumber);
    }
}

Wahl 4 (Array-Trick):

public class XYZ {
    public static void main(String[] args) {
        int[] toyNumber = {5};
        XYZ temp = new XYZ();
        temp.play(toyNumber);
        System.out.println("Toy number in main: " + toyNumber[0]);
    }

    void play(int[] toyNumber) {
        System.out.println("Toy number in play: " + toyNumber[0]);
        toyNumber[0]++;
        System.out.println("Toy number in play after increment: " + toyNumber[0]);
    }
}

Fazit:

Obwohl Java eine Pass-by-Value-Sprache ist, gibt es mehrere Techniken, die eingesetzt werden können, um ein Pass-by-Reference-ähnliches Verhalten zu erreichen. Die Wahl der Technik hängt vom jeweiligen Szenario und den Anforderungen ab.

Das obige ist der detaillierte Inhalt vonWie kann ich in Java ein Referenzübergabeverhalten trotz seiner Eigenschaft als Wertübergabe erreichen?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!