Archief - [PROG][JAVA] Galgje.java

eniac zei:

Mnee. Pass-by-reference bestaat niet in Java, het is strikt pass-by-value.

Vrij verwarrend en wordt op scholen vaak verkeerdelijk aangeleerd als pass-by-reference, maar is het dus niet.

Klik om te vergroten...

killgore zei:

ehm, die quote die jij geeft zegt dat de REFERENTIE wordt gekopieerd (net zoals dit in c++ en zo ook gebeurd), niet het object zelf . De referentie zelf wordt pass-by-value gedaan (logisch ook), het object wordt niet gekopieerd.

Klik om te vergroten...

Car aCar = new Car("myCar");
changeCar(aCar);
// hier aangekomen tijdens de uitvoering van het programma zal aCar nog steeds de "myCar" car zijn.
...

private static void changeCar(Car car) {
	car = new Car("changedCar");
}

forloRn_ zei:

Dat is gewoonweg fout. Pass by reference wilt gewoon zeggen dat je een reference naar een object doorgeeft in plaats van het object zelf. De parameter car van changeCar(Car car) is gewoon een lokale variabele van de method, die bij de aanroep van de method een reference naar aCar als waarde krijgt. Verander je de waarde van car, dan gaat aCar daar natuurlijk geen last van hebben; roep je daarentegen methods aan op car, dan wijzigt het object wel, omdat car en aCar naar hetzelfde object wijzen.
Wat je hierboven beschrijft is een reference by reference doorgeven.

Klik om te vergroten...

forloRn_ zei:

Dat is gewoonweg fout. Pass by reference wilt gewoon zeggen dat je een reference naar een object doorgeeft in plaats van het object zelf.

Klik om te vergroten...

[BAT] Hydra;9404803 zei:

Het is niet omdat java met referenties naar objecten werkt, dat het doorgeven van zulke referenties (pass by) zoiezo by reference gebeurt.

edit: Om vlug te zien of iets pass by value of pass by reference werkt:

Ken aan de doorgegeven parameter een nieuw object toe, als buiten de methode het object dat doorgegeven is veranderd is, ben je met pass by reference bezig, anders niet.

In java geldt dit dus niet:

Code:

Car aCar = new Car("myCar");
changeCar(aCar);
// hier aangekomen tijdens de uitvoering van het programma zal aCar nog steeds de "myCar" car zijn.
...

private static void changeCar(Car car) {
	car = new Car("changedCar");
}

in c++ kan je door gebruik te maken van pointers de car wel laten veranderen.

Klik om te vergroten...

import java.io.*;

class Test {
	private int var = 0;
	public static void main(String[] args){
		Test t = new Test();
		t.print();
		testje(t);
		t.print();
	}
	
	public void setVar(int a)
	{
		var= a;
	}

	public void print() {
		System.out.println(""+var);
	}
	
	public static void testje(Test ref)
	{
		ref.setVar(-1);
	}
}

killgore zei:

Hiermee bewijs je niets hoor . Enkel dat de referentie zelf pass-by-value is, zoals ik al eerder zei. Het object zelf wordt niet gekopiëerd. Doe dit in C++ met pointers en je komt volledig het zelfde resultaat (want de pointer ZELF wordt gekopiëerd, het object waarnaar hij wijst niet).

Probeer deze code eens en je zal zien dat ik gelijk heb:

Code:

import java.io.*;

class Test {
	private int var = 0;
	public static void main(String[] args){
		Test t = new Test();
		t.print();
		testje(t);
		t.print();
	}
	
	public void setVar(int a)
	{
		var= a;
	}

	public void print() {
		System.out.println(""+var);
	}
	
	public static void testje(Test ref)
	{
		ref.setVar(-1);
	}
}

Dat is nu wat pass-by-reference wilt zeggen. Je kopieert enkel de referentie, niet het object, als je dus een wijziging op het object doet zal het object "globaal" wijzigen. Jouw code deed een bewerking op de referentievariabele, nl een nieuw adres toekennen, dit heeft niets met het object zelf te maken .

Klik om te vergroten...

[BAT] Hydra;9405345 zei:

In c++ kan je kiezen of je aan pass-by-value of pass-by-reference doet, in java niet, in java kan je enkel aan pass-by-value doen.

Met mijn voorbeeld toon ik wel iets aan. Op deze pagina staat ook uitgelegd: http://www.jguru.com/faq/view.jsp?EID=430996

Klik om te vergroten...

MilM zei:

Het probleem van miscommunicatie zit hem in het feit dat objecten by reference worden doorgegeven en de argumenten zelf by value.

Aangezien de argumenten by value doorgegeven worden, is java strikt gezien inderdaad by value.
Maar het is meer dna normaal dat men in een objecttaal vanuit het standpunt van een object gaat gaan kijken.

Pass by value is instinctief volgens mij een slechte benaming voor talen als java.

Er zijn 4 mogelijke combinaties (argumenten by reference/value; objecten by reference/value) en het zou dan ook veel beter zijn om beiden in de benaming te betrekken dan enkel hoe de argumenten doorgegeven worden.

--> het lijkt me toch duidelijk dat met pass-by-* enkel het doorgeven (pass) van een variable als argument in een methode wordt bedoeld?

Bijvoorbeeld in het geval van java 'by referencevalue' (referentiewaarde) of 'by value - reference' (waarde van de referentie).

Want voor veel meer situaties, zeker voor beginnelingen, is het van belang hoe het object wordt doorgegeven (by reference) en niet het argument zelf (by value).

Klik om te vergroten...

MilM zei:

"Een object wordt doorgegeven door een kopie (waarde) van de referentie van het object".
Er is niets mis met deze zin imo

Klik om te vergroten...

forloRn_ zei:

'k Zie [BAT]Hydra zijn of haar punt wel ondertussen. 't Is nu eenmaal zo dat een reference in Java iets anders is dan een reference in C++. Dereferencing (expliciet met * op een pointer of impliciet met een reference) kan nu eenmaal niet in Java.

'k Vind dat het de discussie hier niet waard is. In elk boek over Java leer je dat primitives doorgegeven worden by value, en objecten by reference, en ik denk dat de meesten onder ons wel weten wat daar precies mee bedoeld wordt.

Klik om te vergroten...

MilM zei:

Het probleem van miscommunicatie zit hem in het feit dat objecten by reference worden doorgegeven en de argumenten zelf by value.

Aangezien de argumenten by value doorgegeven worden, is java strikt gezien inderdaad by value.
Maar het is meer dna normaal dat men in een objecttaal vanuit het standpunt van een object gaat gaan kijken

Klik om te vergroten...

killgore zei:

Als men over de objecten spreekt (en dat is praktisch altijd zo) is java pass-by-reference.

Klik om te vergroten...

private void CallMe(int i)
{
    i = 100;  //i is assigned a value of 100
}

public void TestCall()
{
   int i = 10;
   CallMe(i);
   MessageBox.Show(i.ToString());  // The changed value is not reflected and the
                            //MessageBox shows 10 and not 100.
}

private void CallMe(ref int i)
{
    i = 100;  //i is assigned a value of 100
}

public void TestCall()
{
   int i = 10;
   CallMe(ref i);
   MessageBox.Show(i.ToString());  // The changed value is reflected and the
                            //MessageBox now shows 100.
}