Was ist Parameterübergabe? Was ist sein Nutzen?

1 Übersicht

1 Was ist Parameterübergabe?

Der Prozess der Übergabe von Daten an formale Parameter beim Aufruf einer Methode wird als Parameterübergabe bezeichnet. In Programmiersprachen gibt es zwei Übertragungsarten: Übertragung durch Wert und Übertragung durch Referenz. Es muss betont werden , dass die beiden hier genannten Übermittlungsmethoden nicht auf die in Java verwendeten beschränkt sind, sondern Übermittlungsmethoden sind, die in einer Vielzahl von Programmiersprachen einschließlich Java vorkommen.

2. Variablentyp

In Java nennen wir Variablen, die auf Basistypdaten zeigen, primitive Variablen, und Variablen, die auf Objekte verweisen, werden als Referenz bezeichnet Variable.

2. Wertübergabe

1. Was ist Wertübergabe?

Übergeben Sie eine Kopie der Variablen an die Methode. Operationen an Variablen innerhalb der Methode werden nicht in Variablen außerhalb der Methode widergespiegelt.

2. Ursprüngliche Variable

    public void change(int b) {
        b = 7;
    }

    @Testpublic void testBasic() {int a = 9;
        change(a);
        System.out.println(a);
    }

Tatsächliche Ausgabe: 9

Bei der Übergabe von Parametern erhält die Variable b gemäß den Regeln der Wertübergabe eine Kopie von a, die ebenfalls auf den Literalwert „9“ zeigt:

Als nächstes weisen Sie innerhalb der Methode b den Wert 7 zu, sodass b auf 7 zeigt. Da a und b zwei unabhängige Variablen sind, besteht keine Referenz-zu-Referenz-Beziehung zwischen ihnen und einem stillen Punkt zu 9:

3.String

    public void change(String str01) {
        str01 = "baidu";
    }

    @Testpublic void testString() {
        String str = new String("www.baidu.com");
        change(str);
        System.out.println(str);
    }

Tatsächliche Ausgabe: www.baidu.com

Bei der Übergabe von Parametern übergibt str eine Kopie von sich selbst an str01, sodass str01 auch auf zeigt Der Heap zum Speichern des Objekts „www.baidu .com“:

Weisen Sie str01 innerhalb der Methode einen Wert zu, also str01 zeigt auf den String-Konstantenpool „baidu“ im Methodenbereich, str zeigt immer noch auf „www.baidu.com“ im Heap, str und str01 zeigen auf unterschiedliche Objekte und beeinflussen sich nicht gegenseitig:

Hier ist Folgendes zu beachten: Java entwirft String als unveränderliches Objekt, das heißt, sobald sich der im String-Objekt enthaltene Literalwert ändert, Java erstellt ein neues Objekt und verweist die Variable auf das neue Objekt.

4.StringBuilder

    public void change(StringBuilder builder01) {
        builder01.append(" World!");
    }

    @Testpublic void testStringBuilder() {
        StringBuilder builder = new StringBuilder("Hello");
        change(builder);
        System.out.println(builder);
    }

Tatsächliche Ausgabe: Hallo Welt!

Nachdem die Parameterübertragung abgeschlossen ist, erhält die Variable builder01 eine Kopie der Builder-Variable. Die Kopie und die Originalvariable verweisen auf dasselbe Objekt im Heap:

Innerhalb der Methode zeigt der Variablen-Builder nicht auf ein neues Objekt, sondern immer noch auf dasselbe Objekt wie der Builder. Wenn der Builder also auf dasselbe Objekt im Heap zugreift, Die Daten ändern sich:

Benutzerdefinierter Typ

public class MyInner {public int a;
}public class Test{public void change(MyInner in01) {
        in01.a = 1;
    }

    @Testpublic void testDemain() {
        MyInner in = new MyInner();
        in.a = 9;
        change(in);
        System.out.println(in.a);
    }

}

Tatsächliche Ausgabe: 1

Der Ausführungsprozess ist der gleiche wie der von StringBuilder und wird hier nicht noch einmal beschrieben. Nehmen wir einige Änderungen am obigen Code vor, wie folgt:

public class MyInner {public int a;
}public class Test{public void change(MyInner in01) {
        in01=new MyInner();//使in01指向一个新的对象in01.a = 1;
    }

    @Testpublic void testDemain() {
        MyInner in = new MyInner();
        in.a = 9;
        change(in);
        System.out.println(in.a);
    }

}

实际输出：9

参数传递完成时，in01与in指向同一个对象，in01对对象的操作等同于in对对象的操作，接着在方法内部执行"in01=new MyInner();"，这样in01就指向了一个新的对象，in01所有的操作都与in无关了：

综合以上的运行结果与分析，可知java参数传递方式符合值传递。

 三 引用传递

1.什么是引用传递？

将变量自身的内存地址传入方法中，方法中的变量指向方法外的变量，在方法中对变量的操作就是对方法外变量的操作。

2.自定义类型

public class MyInner {public int a;
}public class Test{public void change(MyInner in01) {
        in01=new MyInner();//使in01指向一个新的对象in01.a = 1;
    }

    @Testpublic void testDemain() {
        MyInner in = new MyInner();
        in.a = 9;
        change(in);
        System.out.println(in.a);
    }

}

实际输出：9

如果采用引用传递，传递完成以后，in01指向in，对in01的操作就是对in的操作，in01指向对象2，那么in也指向对象2，输出1，与实际不符，所以不是采用引用传递。

不再一一分析其他变量类型，分析后可以发现，java在传递参数时采用的不是引用传递，而是值传递。

简单讲，值传递时方法内外是两个拥有同一指向的变量，引用传递时方法内外是同一个变量。

Das obige ist der detaillierte Inhalt vonWas ist Parameterübergabe? Was ist sein Nutzen?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!