Java “referans yoluyla” veya “değerine göre” mi?

Java'nın hep referans olduğunu düşündüm .

Ancak, olmadığını iddia eden birkaç blog yayını (örneğin, bu blog ) gördüm .

Yaptıkları ayrımı anladığımı sanmıyorum.

Açıklama nedir?

Java her zaman değerlidir . Ne yazık ki, bir nesnenin değerini geçtiğimizde, ona bir referans aktarıyoruz . Bu yeni başlayanlar için kafa karıştırıcı.

Bu böyle devam ediyor:

public static void main(String[] args) {
    Dog aDog = new Dog("Max");
    Dog oldDog = aDog;

    // we pass the object to foo
    foo(aDog);
    // aDog variable is still pointing to the "Max" dog when foo(...) returns
    aDog.getName().equals("Max"); // true
    aDog.getName().equals("Fifi"); // false
    aDog == oldDog; // true
}

public static void foo(Dog d) {
    d.getName().equals("Max"); // true
    // change d inside of foo() to point to a new Dog instance "Fifi"
    d = new Dog("Fifi");
    d.getName().equals("Fifi"); // true
}

Yukarıdaki örnekte aDog.getName()yine de dönecektir "Max". Değeri aDogolan mainişlevinde değiştirilmez fooile Dog "Fifi"nesne referans değeri geçtiği şekilde. Referans olarak geçildiyse, aDog.getName()in mainçağrıldıktan "Fifi"sonra geri döner foo.

Aynı şekilde:

public static void main(String[] args) {
    Dog aDog = new Dog("Max");
    Dog oldDog = aDog;

    foo(aDog);
    // when foo(...) returns, the name of the dog has been changed to "Fifi"
    aDog.getName().equals("Fifi"); // true
    // but it is still the same dog:
    aDog == oldDog; // true
}

public static void foo(Dog d) {
    d.getName().equals("Max"); // true
    // this changes the name of d to be "Fifi"
    d.setName("Fifi");
}

Yukarıdaki örnekte, nesnenin adı içinde ayarlandığından, çağrıldıktan Fifisonra köpeğin adıdır . O Herhangi operasyonlar gerçekleştirdiği üzerindeki tüm pratik amaçlar için, bunlar üzerinde gerçekleştirilir, şekildedir , ama öyle değil değişkenin değerini değiştirmek mümkün kendisi.foo(aDog)foo(...)foodaDogaDog

Sadece başvurulan fark benim yazı .

Java Spec, Java'daki her şeyin önemsiz olduğunu söyler. Java'da "referans by pass" diye bir şey yoktur.

Bunu anlamanın anahtarı şudur:

Dog myDog;

olduğu olmayan bir köpek; aslında bir köpeğin göstergesidir .

Bunun anlamı,

Dog myDog = new Dog("Rover");
foo(myDog);

esasen oluşturulan nesnenin adresini yönteme geçirirsiniz.Dogfoo

(Esasen Java işaretçileri doğrudan adresler olmadığı için söylüyorum, ancak bu şekilde düşünmek en kolayı)

DogNesnenin bellek adresi 42'de olduğunu varsayalım. Bu, yönteme 42 ilettiğimiz anlamına gelir.

Yöntem şu şekilde tanımlanmışsa

public void foo(Dog someDog) {
    someDog.setName("Max");     // AAA
    someDog = new Dog("Fifi");  // BBB
    someDog.setName("Rowlf");   // CCC
}

neler olduğuna bakalım.

• parametre someDog42 değerine ayarlanır
• "AAA" satırında
  • someDogkadar takip edilir Dogiçin bu puan ( Dogadresinde nesne 42)
  • o Dog(adresinde 42 az bir) Max ismini değiştirmek istenir
• "BBB" satırında
  • yeni Dogoluşturulur. Diyelim ki o adres 74'te
  • parametreyi someDog74'e atarız
• "CCC" satırında
  • someDog Dogişaret ettiği yere işaret eder ( Dog74 adresindeki nesne)
  • o Dog(adresinde 74 az bir) Rowlf ismini değiştirmek istenir
• sonra geri dönüyoruz

Şimdi yöntemin dışında neler olduğunu düşünelim:

Değişti myDogmi?

Anahtar var.

Bunun myDoggerçek bir işaretçi değil , bir işaretçi olduğunu akılda tutarak Dogcevap HAYIR. myDoghala 42 değerine sahiptir; hala orijinali gösteriyor Dog(ancak "AAA" satırı nedeniyle adının şimdi "Max" olduğunu unutmayın - hala aynı Köpek; myDogdeğerinin değişmediğini.)

Bir adresi takip etmek ve sonunda ne olduğunu değiştirmek son derece geçerlidir ; ancak bu değişkeni değiştirmez.

Java tam olarak C gibi çalışır. Bir işaretçi atayabilir, işaretçiyi bir yönteme geçirebilir, yöntemdeki işaretçiyi izleyebilir ve işaretlenen verileri değiştirebilirsiniz. Ancak, bu işaretçinin işaret ettiği yeri değiştiremezsiniz.

C ++, Ada, Pascal ve doğrudan referansı destekleyen diğer dillerde, aslında iletilen değişkeni değiştirebilirsiniz.

Java, referans by pass anlambilimine foosahip olsaydı, yukarıda tanımladığımız yöntem , BBB hattına myDogatandığında nereye işaret ettiğini değiştirmiş olurdu someDog.

Referans parametrelerini aktarılan değişken için takma adlar olarak düşünün. Bu takma ad atandığında, aktarılan değişken de olur.

Java, bağımsız değişkenleri her zaman değere göre iletir, başvuru olarak DEĞİL.

Bunu bir örnekle açıklayayım :

public class Main {

     public static void main(String[] args) {
          Foo f = new Foo("f");
          changeReference(f); // It won't change the reference!
          modifyReference(f); // It will modify the object that the reference variable "f" refers to!
     }

     public static void changeReference(Foo a) {
          Foo b = new Foo("b");
          a = b;
     }

     public static void modifyReference(Foo c) {
          c.setAttribute("c");
     }

}

Bunu adım adım açıklayacağım:

1. fType adlı bir başvuruyu bildirme Foove ona Foobir özniteliğe sahip yeni bir nesne nesnesi atayın "f".

   Foo f = new Foo("f");

   

2. Yöntem tarafından, bir Fooad içeren türün bir başvurusu abildirilir ve başlangıçta atanır null.

   public static void changeReference(Foo a)

   

3. Yöntemi çağırdığınızda, changeReferencebaşvuruya abağımsız değişken olarak iletilen nesne atanır.

   changeReference(f);

   

4. bType adlı bir başvuruyu bildirme Foove ona Foobir özniteliğe sahip yeni bir nesne nesnesi atayın "b".

   Foo b = new Foo("b");

   

5. a = breferans için yeni bir atama yapar a, değil f , olan öznitelik nesnenin "b".

   

6. Siz modifyReference(Foo c)yöntemi çağırdığınızda , bir başvuru coluşturulur ve özniteliğe sahip nesne atanır "f".

   

7. c.setAttribute("c");kendisine işaret eden nesnenin niteliğini değiştirir cve ona fişaret eden nesnenin aynısıdır .

   

Umarım şimdi nesneleri bağımsız değişken olarak geçirmenin Java'da nasıl çalıştığını anlarsınız :)

Bu, Java'nın referans ile geçme veya değere göre geçme hakkında bir sonraki tartışmanızda sadece gülümseyeceğiniz noktaya kadar nasıl çalıştığına dair bazı bilgiler verecektir :-)

Birinci adım lütfen özellikle diğer programlama dillerinden geliyorsanız 'p' "_ _ _ _ _ _ _" ile başlayan kelimeyi aklınızdan silin. Java ve 'p' aynı kitapta, forumda ve hatta txt'de yazılamaz.

İkinci adım, bir Nesneyi bir yönteme geçirdiğinizde, Nesnenin kendisini değil, Object başvurusunu ilettiğinizi unutmayın.

• Öğrenci : Shifu, bu Java'nın referans yoluyla olduğu anlamına mı geliyor?
• Shifu : Çekirge, Hayır.

Şimdi bir Object'in başvurusunun / değişkeninin ne yaptığını / ne olduğunu düşünün:

1. Bir değişken, JVM'ye başvurulan nesneye bellekte (Yığın) nasıl ulaşacağını söyleyen bitleri tutar.
2. Bir yönteme argüman iletirken, referans değişkeni DEĞİLDİR, ancak referans değişkendeki bitlerin bir kopyasıdır . Böyle bir şey: 3bad086a. 3bad086a, iletilen nesneye ulaşmanın bir yolunu temsil eder.
3. Yani sadece 3bad086a'yı geçiyorsunuz, referansın değeri.
4. Referansın değerini değil, referansın kendisini geçiyorsunuz (nesneyi değil).
5. Bu değer aslında COPIED'dir ve yönteme verilir .

Aşağıda (lütfen bunu derlemeye / yürütmeye çalışmayın ...):

1. Person person;
2. person = new Person("Tom");
3. changeName(person);
4.
5. //I didn't use Person person below as an argument to be nice
6. static void changeName(Person anotherReferenceToTheSamePersonObject) {
7.     anotherReferenceToTheSamePersonObject.setName("Jerry");
8. }

Ne oluyor?

• Değişken kişi 1 numaralı satırda oluşturulur ve başlangıçta null olur.
• Yeni bir Kişi Nesnesi, 2. satırda bellekte saklanır ve değişken kişiye Kişi nesnesine başvuru verilir. Yani adresi. 3bad086a diyelim.
• Nesnenin adresini tutan değişken kişi # 3 satırındaki işleve iletilir.
• 4. satırda sessizliğin sesini dinleyebilirsiniz
• 5. satırdaki yorumu kontrol edin
• Bir yöntem yerel değişkeni - anotherReferenceToTheSamePersonObject - oluşturulur ve sonra sihir # 6 satırında gelir:
  • Değişken / başvuru kişisi bitler halinde kopyalanır ve işlevin içindeki anotherReferenceToTheSamePersonObject öğesine iletilir .
  • Yeni Kişi örneği oluşturulmaz.
  • Hem " person " hem de " anotherReferenceToTheSamePersonObject " aynı 3bad086a değerine sahiptir.
  • Bunu denemeyin ama person == anotherReferenceToTheSamePersonObject doğru olur.
  • Her iki değişken de referansın KİMLİK KOPYALARINA sahiptir ve her ikisi de aynı Kişi Nesnesine, Öbekteki SAME Nesnesine ve KOPYA DEĞİLDİR.

Bir resim bin kelime değerinde bir olup:

AnotherReferenceToTheSamePersonObject oklarının değişken kişiye değil Object'e yönlendirildiğini unutmayın!

Eğer anlamadıysanız, bana güvenin ve Java'nın değere göre geçtiğini söylemenin daha iyi olduğunu unutmayın . O referans değeriyle geçmesi . Ah, daha da iyisi, değişken değerinin kopyalanmasıdır! ;)

Şimdi benden nefret etmekten çekinmeyin, ancak bunun göz önüne alındığında , yöntem argümanlarından bahsederken ilkel veri türlerini ve Nesneleri geçirme arasında bir fark olmadığını unutmayın .

Referans değerinin bitlerinin bir kopyasını her zaman geçirirsiniz!

• İlkel bir veri türü ise, bu bitler ilkel veri türünün değerini içerir.
• Bir Nesne ise, bitler JVM'ye Nesneye nasıl ulaşacağını söyleyen adresin değerini içerir.

Java bir pass-by-değeridir, çünkü bir yöntemin içinde başvurulan Nesneyi istediğiniz kadar değiştirebilirsiniz, ancak ne kadar denerseniz deneyin referans vermeyi sürdürecek iletilen değişkeni asla değiştiremezsiniz (p _ _ _ değil) _ _ _ _) ne olursa olsun aynı Nesne!

Yukarıdaki changeName işlevi, iletilen başvurunun gerçek içeriğini (bit değerleri) hiçbir zaman değiştiremez. Başka bir deyişle changeName, Kişinin başka bir Nesneye başvurmasını sağlayamaz.

Tabii ki kısa kesebilir ve sadece Java'nın by-value olduğunu söyleyebilirsiniz !

Java her zaman bunun istisnası değeriyle geçmesi olduğunu hiç .

Öyleyse, herkes bununla nasıl karıştırılabilir ve Java'nın referans olarak geçtiğine inanır veya Java'nın referans olarak geçerken bir örneği olduğunu düşünür? Anahtar nokta Java asla değerlerine doğrudan erişim sağlar kendileri nesneler içinde, herhangi bir koşul. Nesnelere tek erişim , o nesneye yapılan bir başvurudır . Java nesnelerine her zaman doğrudan yerine bir başvuru yoluyla erişildiğinden , bilgiçliksel olarak yalnızca nesnelere başvurulduğunda alanlar ve değişkenler ve yöntem bağımsız değişkenleri nesne olarak konuşmak yaygındır .Karışıklık, isimlendirmedeki bu (açık konuşmak gerekirse, yanlış) değişiklikten kaynaklanmaktadır.

Yani, bir yöntemi çağırırken

• İlkel bağımsız değişkenler ( int, longvb.) İçin by pass value, ilkel olanın gerçek değeridir (örneğin, 3).
• Nesneler için, pass by değeri, nesneye yapılan başvurunun değeridir .

Eğer varsa doSomething(foo)ve public void doSomething(Foo foo) { .. }iki Foos aynı nesnelere işaret eden referansları kopyaladıysanız .

Doğal olarak, bir nesneye bir referansın değerinden geçirilmesi, bir nesneyi referans olarak geçirmeye çok benzemektedir (ve pratikte ayırt edilemez).

Java, referansları değere göre geçirir.

Böylece, iletilen referansı değiştiremezsiniz.

Ben "referans by pass-by-value" hakkında tartışmak gibi süper hissediyorum değil gibi hissediyorum.

"Java her ne ise olursa olsun (referans / değer)" derseniz, her iki durumda da tam bir cevap sağlamazsınız. Hafızada neler olup bittiğini anlamada yardımcı olacak bazı ek bilgiler.

Java uygulamasına geçmeden önce yığın / yığın üzerinde çökme kursu: Değerler, bir kafeteryadaki tabak yığını gibi, düzenli ve güzel bir şekilde yığını açar ve kapatır. Yığındaki bellek (dinamik bellek olarak da bilinir) gelişigüzel ve düzensizdir. JVM mümkün olan her yerde yer bulur ve onu kullanan değişkenlere artık ihtiyaç duyulmadığından alanı boşaltır.

Tamam. İlk önce, yerel ilkel yığın yığınına gider. Yani bu kod:

int x = 3;
float y = 101.1f;
boolean amIAwesome = true;

bunun sonuçları:

Bir nesneyi beyan edip somutlaştırdığınızda. Gerçek nesne öbek üzerinde gider. Yığına ne oluyor? Öbek üzerindeki nesnenin adresi. C ++ programcıları buna bir işaretçi derler, ancak bazı Java geliştiricileri "işaretçi" kelimesine karşıdır. Her neyse. Sadece nesnenin adresinin yığının üzerinde olduğunu bilin.

Şöyle ki:

int problems = 99;
String name = "Jay-Z";

Bir dizi bir nesnedir, bu yüzden öbek üzerinde de gider. Dizideki nesneler ne olacak? Kendi yığın alanlarını alırlar ve her nesnenin adresi dizinin içine girer.

JButton[] marxBros = new JButton[3];
marxBros[0] = new JButton("Groucho");
marxBros[1] = new JButton("Zeppo");
marxBros[2] = new JButton("Harpo");

Peki, bir yöntemi çağırdığınızda neler geçiyor? Bir nesneyi iletirseniz, aslında geçtiğiniz şey nesnenin adresidir. Bazıları adresin "değeri" diyebilir ve bazıları bunun sadece nesneye referans olduğunu söyleyebilir. Bu, "referans" ve "değer" taraftarları arasındaki kutsal savaşın doğuşudur. Dediğiniz şey, aktarılan şeyin nesnenin adresi olduğunu anladığınız kadar önemli değildir.

private static void shout(String name){
    System.out.println("There goes " + name + "!");
}

public static void main(String[] args){
    String hisName = "John J. Jingleheimerschmitz";
    String myName = hisName;
    shout(myName);
}

Bir Dize oluşturulur ve bunun için yığın öbeğe ayrılır ve dizeye adres yığını üzerinde depolanır ve tanımlayıcı verilir hisName, çünkü ikinci Dize'nin adresi birinciyle aynıdır, yeni Dize oluşturulmaz ve yeni yığın alanı ayrılmaz, ancak yığın üzerinde yeni bir tanımlayıcı oluşturulur. Sonra çağırırız shout(): yeni bir yığın çerçevesi oluşturulur ve yeni bir tanımlayıcı nameoluşturulur ve zaten var olan Dize'nin adresi atanır.

Değer, referans mı? "Patates" diyorsun.

Sadece kontrastı göstermek için aşağıdaki C ++ ve Java snippet'lerini karşılaştırın:

C ++ ile: Not: Bozuk kod - bellek sızdırıyor! Ama konuyu gösteriyor.

void cppMethod(int val, int &ref, Dog obj, Dog &objRef, Dog *objPtr, Dog *&objPtrRef)
{
    val = 7; // Modifies the copy
    ref = 7; // Modifies the original variable
    obj.SetName("obj"); // Modifies the copy of Dog passed
    objRef.SetName("objRef"); // Modifies the original Dog passed
    objPtr->SetName("objPtr"); // Modifies the original Dog pointed to 
                               // by the copy of the pointer passed.
    objPtr = new Dog("newObjPtr");  // Modifies the copy of the pointer, 
                                   // leaving the original object alone.
    objPtrRef->SetName("objRefPtr"); // Modifies the original Dog pointed to 
                                    // by the original pointer passed. 
    objPtrRef = new Dog("newObjPtrRef"); // Modifies the original pointer passed
}

int main()
{
    int a = 0;
    int b = 0;
    Dog d0 = Dog("d0");
    Dog d1 = Dog("d1");
    Dog *d2 = new Dog("d2");
    Dog *d3 = new Dog("d3");
    cppMethod(a, b, d0, d1, d2, d3);
    // a is still set to 0
    // b is now set to 7
    // d0 still have name "d0"
    // d1 now has name "objRef"
    // d2 now has name "objPtr"
    // d3 now has name "newObjPtrRef"
}

Java'da,

public static void javaMethod(int val, Dog objPtr)
{
   val = 7; // Modifies the copy
   objPtr.SetName("objPtr") // Modifies the original Dog pointed to 
                            // by the copy of the pointer passed.
   objPtr = new Dog("newObjPtr");  // Modifies the copy of the pointer, 
                                  // leaving the original object alone.
}

public static void main()
{
    int a = 0;
    Dog d0 = new Dog("d0");
    javaMethod(a, d0);
    // a is still set to 0
    // d0 now has name "objPtr"
}

Java yalnızca iki tür geçişe sahiptir: yerleşik türler için değere ve nesne türleri için işaretçinin değerine göre.

Java, nesnelere başvuruları değere göre geçirir.

Temel olarak, Object parametrelerini yeniden atamak bağımsız değişkeni etkilemez, ör.

private void foo(Object bar) {
    bar = null;
}

public static void main(String[] args) {
    String baz = "Hah!";
    foo(baz);
    System.out.println(baz);
}

"Hah!"yerine yazdırılacaktır null. Bunun çalışmasının nedeni bar, değerinin bir kopyasıdır baz, bu sadece referanstır "Hah!". Gerçek referans kendisi olsaydı, o zaman fooyeniden olurdu bazetmek null.

Henüz kimsenin Barbara Liskov'dan bahsetmediğine inanamıyorum. O 1974 yılında CLU'yu tasarlanmış, o bu aynı terminoloji sorun koştu ve o dönem icat paylaşımı çağrıyı (olarak da bilinen nesne paylaşımı yoluyla çağrı ve obje tarafından çağrı değeridir değerle çağrısı" bu özel durum için) referans".

Meselenin özü bu kelime referans kelime olağan anlamından araçlar şey "referans olarak geçmektedir" ifadesinde bambaşka referans Java.

Genellikle Java başvurusunda bir nesneye aa başvurusu anlamına gelir . Ancak programlama dili teorisinden referans / değerle geçen teknik terimler , değişkeni tutan bellek hücresine yapılan bir referanstan bahsediyor , ki bu tamamen farklı bir şey.

Point pnt1 = new Point(0,0);Java'da her şey referanstır, bu nedenle şöyle bir şey olduğunda: Java aşağıdakileri yapar:

1. Yeni Point nesnesi oluşturur
2. Yeni Nokta başvurusu oluşturur ve bu başvuruyu önceden oluşturulan Point nesnesindeki noktaya (başvuruya) başlatır .
3. Buradan, Point nesnesi ömrü boyunca, o nesneye pnt1 referansı ile erişeceksiniz. Java'da nesneyi referansı ile değiştirdiğinizi söyleyebiliriz.
   

Java yöntem bağımsız değişkenlerini başvuru ile iletmez; onları değere göre geçer. Bu siteden örnek kullanacağım :

public static void tricky(Point arg1, Point arg2) {
  arg1.x = 100;
  arg1.y = 100;
  Point temp = arg1;
  arg1 = arg2;
  arg2 = temp;
}
public static void main(String [] args) {
  Point pnt1 = new Point(0,0);
  Point pnt2 = new Point(0,0);
  System.out.println("X1: " + pnt1.x + " Y1: " +pnt1.y); 
  System.out.println("X2: " + pnt2.x + " Y2: " +pnt2.y);
  System.out.println(" ");
  tricky(pnt1,pnt2);
  System.out.println("X1: " + pnt1.x + " Y1:" + pnt1.y); 
  System.out.println("X2: " + pnt2.x + " Y2: " +pnt2.y);  
}

Program akışı:

Point pnt1 = new Point(0,0);
Point pnt2 = new Point(0,0);

İlişkili iki farklı başvuru ile iki farklı Point nesnesi oluşturma.

System.out.println("X1: " + pnt1.x + " Y1: " +pnt1.y); 
System.out.println("X2: " + pnt2.x + " Y2: " +pnt2.y);
System.out.println(" ");

Beklenen çıktı olacağı gibi:

X1: 0     Y1: 0
X2: 0     Y2: 0

Bu satırda 'by-value' oyuna giriyor ...

tricky(pnt1,pnt2);           public void tricky(Point arg1, Point arg2);

Kaynaklar pnt1ve pnt2edilmektedir değer geçirilir artık senin referanslar bu zor yöntem ile hangi araçlara pnt1ve pnt2onların sahip copiesadlandırılmış arg1ve arg2.bu pnt1ve arg1 puan aynı nesneye. (Aynı için pnt2vearg2 )

İn trickyyöntemi:

 arg1.x = 100;
 arg1.y = 100;

Bir Sonraki trickyyöntem

Point temp = arg1;
arg1 = arg2;
arg2 = temp;

Burada, ilk yeni oluştur tempedecek Nokta referansı işaret gibi aynı yerde arg1referans. Sonra başvuruyu arg1, başvuru gibi aynı yeri işaret edecek şekilde arg2taşırsınız. Nihayet arg2edecek işaret gibi aynı yere temp.

Buradan kapsamı trickyyöntemine gitti ve referanslar artık erişiminiz yok: arg1, arg2, temp. Ancak önemli not, bu referanslarla 'hayatta' olduklarında yaptığınız her şeyin, üzerinde bulundukları nesneyi kalıcı olarak etkileyeceğidir. işaret .

Yani yöntemi uyguladıktan sonra tricky , , geri döndüğünüzde main, bu duruma sahipsiniz:

Şimdi, tamamen programın yürütülmesi olacak:

X1: 0         Y1: 0
X2: 0         Y2: 0
X1: 100       Y1: 100
X2: 0         Y2: 0

Java her zaman değere göre geçer, referansla geçilmez

Her şeyden önce, değere göre geçişin ve referansla geçişin ne olduğunu anlamamız gerekir.

Değere göre geç, aktarılan gerçek parametrenin değerinin belleğinde bir kopya yaptığınız anlamına gelir. Bu, gerçek parametrenin içeriğinin bir kopyasıdır .

Referansla geçiş (adrese göre geçiş de denir), gerçek parametrenin adresinin bir kopyasının saklandığı anlamına gelir .

Bazen Java referans olarak geçiş yanılsaması verebilir. Aşağıdaki örneği kullanarak nasıl çalıştığını görelim:

public class PassByValue {
    public static void main(String[] args) {
        Test t = new Test();
        t.name = "initialvalue";
        new PassByValue().changeValue(t);
        System.out.println(t.name);
    }

    public void changeValue(Test f) {
        f.name = "changevalue";
    }
}

class Test {
    String name;
}

Bu programın çıktısı:

changevalue

Adım adım anlayalım:

Test t = new Test();

Hepimizin bildiği gibi, yığın içinde bir nesne oluşturacak ve referans değerini tekrar t'ye döndürecektir. Örneğin, t değerinin 0x100234(gerçek JVM iç değerini bilmediğimizi varsayalım , bu sadece bir örnek).

new PassByValue().changeValue(t);

Fonksiyona t referansını iletirken, nesne testinin gerçek referans değerini doğrudan geçmeyecek, ancak t'nin bir kopyasını oluşturacak ve sonra fonksiyona iletecektir. Bu olduğundan değeri geçirerek , bu değişken değil, bunun yerine gerçek bir referans kopyasını geçer. T'nin değeri olduğunu söylediğimizden 0x100234, hem t hem de f aynı değere sahip olacak ve dolayısıyla aynı nesneyi gösterecektir.

Referans f'yi kullanarak işlevdeki herhangi bir şeyi değiştirirseniz, nesnenin var olan içeriği değiştirilir. Bu yüzden changevaluefonksiyonda güncellenen çıktıyı aldık .

Bunu daha net anlamak için aşağıdaki örneği göz önünde bulundurun:

public class PassByValue {
    public static void main(String[] args) {
        Test t = new Test();
        t.name = "initialvalue";
        new PassByValue().changeRefence(t);
        System.out.println(t.name);
    }

    public void changeRefence(Test f) {
        f = null;
    }
}

class Test {
    String name;
}

Bu atar NullPointerExceptionmı? Hayır, çünkü referansın sadece bir kopyasını geçer. Referans olarak geçilmesi durumunda, NullPointerExceptionaşağıda görüldüğü gibi a atılmış olabilir :

Umarım bu yardımcı olacaktır.

Referans, hangi dili kullanırsanız kullanın, temsil edildiğinde her zaman bir değerdir.

Kutu görünümünün dışına çıkarak, Meclis'e veya bazı düşük seviye bellek yönetimine bakalım. CPU düzeyinde , herhangi bir şeye yapılan bir başvuru , belleğe veya CPU kayıtlarından birine yazılırsa hemen bir değer olur. (Bu yüzden işaretçi iyi bir tanımdır. Aynı zamanda bir amacı olan bir değerdir).

Bellekteki verilerin bir Konumu vardır ve bu konumda bir değer vardır (bayt, sözcük, her neyse). Kurul biz bir vermek için uygun bir çözüme sahip Adı belli etmek Konum (aka değişken), ancak kod derleme yaparken, montajcı basitçe yerini Adı sadece IP adresleri ile tarayıcı cümledeki alan adları gibi belirlenen konuma sahip.

Çekirdeğe kadar, herhangi bir dilde herhangi bir şeye temsil etmeden referans vermek (hemen bir değer olduğunda) teknik olarak imkansızdır.

Diyelim ki bir Foo değişkenimiz var, Konumu bellekte 47. baytta ve Değeri 5. Başka bir değişken Ref2Foo var. , program tarafından açıkça oluşturulmamıştır. Eğer herhangi bir bilgi olmadan 5 ve 47'ye bakarsanız, sadece iki Değer göreceksiniz . Bunları referans olarak kullanırsanız, oraya ulaşmak 5için seyahat etmeliyiz:

(Name)[Location] -> [Value at the Location]
---------------------
(Ref2Foo)[223]  -> 47
(Foo)[47]       -> 5

Atlama tabloları bu şekilde çalışır.

Foo değerine sahip bir yöntemi / işlevi / yordamı çağırmak istiyorsak, dile ve çeşitli yöntem çağırma modlarına bağlı olarak değişkeni yönteme geçirmenin birkaç olası yolu vardır :

1. 5 CPU kayıtlarından birine (yani EAX) kopyalanır.
2. 5 PUSHd'yi yığına alır.
3. 47 CPU kaydından birine kopyalanır
4. 47 PUSHd yığına.
5. 223 CPU kayıtlarından birine kopyalanır.
6. 223 PUSHd'yi yığına alır.

Bir değerin üzerindeki her durumda - mevcut bir değerin bir kopyası - yaratıldı, şimdi onu ele almak için alıcı yöntemine bağlı. Yöntemin içine "Foo" yazdığınızda, EAX'tan okunur veya otomatik olarak kayıttan çıkarılır veya çift kayıttan çıkarılır, işlem dilin nasıl çalıştığına ve / veya Foo türünün ne gerektirdiğine bağlıdır. Bu, kayıt silme işlemini atlayana kadar geliştiriciden gizlenir. Bu nedenle başvuru , temsil edildiğinde bir değerdir , çünkü başvuru, işlenmesi gereken bir değerdir (dil düzeyinde).

Şimdi Foo'yu yönteme geçtik:

• Durum 1 ve 2'de Foo (Foo = 9 ) ' bir kopyasına sahip olduğunuz için yalnızca yerel kapsamı etkiler. Yöntemin içinden orijinal Foo'nun bellekte nerede olduğunu bile belirleyemiyoruz.
• 3. ve 4. durumda, varsayılan dil yapılarını kullanır ve Foo'yu ( Foo = 11) değiştirirseniz, Foo'yu global olarak değiştirebilir (dile bağlıdır, yani Java veya Pascal'ın var procedure findMin(x, y, z: integer;m'si gibi : integer);). Ancak, dil dereference sürecini atlatmanıza izin veriyorsa 47, diyelim 49. Bu noktada, eğer okursanız Foo değiştirilmiş gibi görünüyor, çünkü yerel işaretçiyi değiştirdiniz . Ve eğer bu Foo'yu yöntem ( Foo = 12) içinde değiştirirseniz , muhtemelen programın yürütülmesini FUBAR (aka. Segfault) çünkü beklenenden farklı bir belleğe yazacaksınız, hatta çalıştırılabilir tutmaya yönelik bir alanı bile değiştirebilirsiniz. program ve ona yazmak çalışan kodu değiştirir (Foo artık değil47 ). AMA Foo'nun değeri47global olarak değişmedi, sadece yöntemin içindeki olan, çünkü yöntemin 47bir kopyasıydı.
• 5. ve 6. durumda 223, yöntemin içinde değişiklik yaparsanız , 3. veya 4. ile aynı kargaşayı oluşturur (bir işaretçi, şimdi kötü bir değere işaret eder, bu yine işaretçi olarak kullanılır), ancak bu yine de yereldir 223 kopyalandığı için sorun . Ancak, referansı kaldırabiliyorsanız Ref2Foo(yani 223), sivri değere ulaşıp değiştirebiliyorsanız 47, örneğin, 49Foo'yu küresel olarak etkileyecektir , çünkü bu durumda yöntemlerin bir kopyası var, 223 ancak referans verilen 47sadece bir kez var ve bunu değiştiriyor için 49her yol açacaktır Ref2Fooyanlış değere çift referanslanması.

Önemsiz ayrıntılar, hatta referans yoluyla geçen diller bile nitelendirmek, değerlere işlevlere geçecektir, ancak bu işlevler, bunu kayıttan çıkarma amaçları için kullanmaları gerektiğini bilir. Bu değer olarak referans değeri, programcıdan gizlenir, çünkü pratik olarak işe yaramaz ve terminoloji sadece referans yoluyla geçer .

Sıkı geçiş değeri de işe yaramaz, bu, diziyle bir yöntemi bağımsız değişken olarak her çağırdığımızda 100 Mbaytlık bir dizinin kopyalanması gerektiği anlamına gelir, bu nedenle Java kesin olarak değere sahip olamaz. Her dil bu büyük diziye (değer olarak) bir başvuru iletir ve bu dizi yöntemin içinde yerel olarak değiştirilebiliyorsa veya yöntemin (Java'nın yaptığı gibi) diziyi genel olarak ( arayanın görünümü) ve birkaç dil referansın Değerinin değiştirilmesine izin verir.

Yani kısacası ve Java'nın kendi terminolojisinde, Java olduğunu pass-by-değeri nerede değeri bir ya: olabilmektedir gerçek değeri veya değer bir bir temsilidir referans .

Java değere göre bir çağrıdır

Nasıl çalışır

• Referans değerinin bitlerinin bir kopyasını her zaman geçirirsiniz!

• İlkel bir veri türü ise bu bitler ilkel veri türünün değerini içerir, Bu nedenle yöntemin içindeki üstbilginin değerini değiştirirsek, o zaman dışarıdaki değişiklikleri yansıtmaz.

• Bunun gibi bir nesne veri türü ise ) Foo foo = new Foo ( dosya kısayol gibi, varsayalım geçer nesnenin adresi bu durumda kopyasında o zaman bir metin dosyası var abc.txt de \ masaüstü: C ve biz kısa yolunu yapmak varsayalım Aynı dosyayı C: \ desktop \ abc-shortcut'ın içine koyun, böylece C: \ desktop \ abc.txt dosyasından dosyaya erişip 'Stack Overflow' yazıp dosyayı kapatıp dosyayı yeniden kısayoldan açtığınızda yazma 'programcılar için öğrenilecek en büyük çevrimiçi topluluktur' o zaman toplam dosya değişikliği olacaktır, 'Stack Overflow programcılar için öğrenilecek en büyük çevrimiçi topluluktur'bu da dosyayı açtığınız yerden önemli olmadığı anlamına gelir, aynı dosyaya her eriştiğimizde, buradaFoo bir dosya ve saklanan varsayalım foo olarak 123hd7h (orijinal adresi gibi : \ masaüstü \ abc.txt C adres ve) 234jdid (gibi kopyalanan adrese C: \ masaüstü \ abc-kısayol aslında dosya iç özgün adresini içerir). Daha iyi anlamak için kısayol dosyası ve hissettirin ..

Bunu kapsayan harika cevaplar zaten var. Ben c ++ referans Pass-by-value Java ile davranışları zıt çok basit bir örnek (bu derleme) paylaşarak küçük bir katkı yapmak istedim .

Birkaç nokta:

1. "Referans" terimi, iki ayrı anlama sahip aşırı yüklenmedir. Java'da basitçe bir işaretçi anlamına gelir, ancak "Referansla" bağlamında, içeri aktarılan orijinal değişken için bir tanıtıcı anlamına gelir.
2. Java, değere göre . Java (diğer diller arasında) C'nin soyundan gelir. C'den önce, FORTRAN ve COBOL gibi birkaç (ancak hepsi değil) önceki dil PBR'yi destekledi, ancak C desteklemedi. PBR bu diğer dillerin alt rutinler içinde geçirilen değişkenlerde değişiklik yapmasına izin verdi. Aynı şeyi başarmak için (yani fonksiyonların içindeki değişkenlerin değerlerini değiştirmek için), C programcıları değişkenlere fonksiyonlara yöneltti. Java gibi C'den esinlenen diller bu fikri ödünç aldı ve Java'nın işaretçileri Referanslar olarak adlandırması dışında C'nin yaptığı yöntemlere işaretçi aktarmaya devam ediyor. Yine, bu "Referans" kelimesinin "Referansla Geçiş" ten farklı bir kullanımıdır.
3. C ++ başvuruya izin verir , "&" karakterini (hem C hem de C ++ 'da "bir değişkenin adresini" belirtmek için kullanılan karakterle aynı olan) bir referans parametresi bildirerek . Örneğin, bir işaretçiyi başvuru ile iletirsek, parametre ve bağımsız değişken yalnızca aynı nesneyi işaret etmez. Aksine, bunlar aynı değişkendir. Biri farklı bir adrese veya null değerine ayarlanırsa diğeri de ayarlanır.
4. Aşağıdaki C ++ örneğinde , başvuru ile boş bir sonlandırılmış dizeye bir işaretçi geçiriyorum . Ve aşağıdaki Java örneğinde, bir String'e bir Java başvurusu geçiriyorum (yine, bir String'e gösterici ile aynı) değere göre. Yorumlarda çıktıya dikkat edin.

Referans örneğiyle C ++ geçişi:

using namespace std;
#include <iostream>

void change (char *&str){   // the '&' makes this a reference parameter
    str = NULL;
}

int main()
{
    char *str = "not Null";
    change(str);
    cout<<"str is " << str;      // ==>str is <null>
}

Java, örnek örneği ile "bir Java başvurusu" iletir

public class ValueDemo{

    public void change (String str){
        str = null;
    }

     public static void main(String []args){
        ValueDemo vd = new ValueDemo();
        String str = "not null";
        vd.change(str);
        System.out.println("str is " + str);    // ==> str is not null!!
                                                // Note that if "str" was
                                                // passed-by-reference, it
                                                // WOULD BE NULL after the
                                                // call to change().
     }
}

DÜZENLE

Birkaç kişi ya benim örneklerime bakmıyor ya da c ++ örneğini alamadıklarını gösteren yorumlar yazdı. Bağlantıyı kesmenin nerede olduğundan emin değilim, ancak c ++ örneğini tahmin etmek net değil. Aynı örneği pascal'da gönderiyorum çünkü pass-by-referansın pascal'da daha temiz göründüğünü düşünüyorum, ama yanlış olabilirim. İnsanları daha çok karıştırıyorum; Umarım değildir.

Pascal'de, referansla iletilen parametrelere "var parametreleri" denir. Aşağıdaki setToNil prosedüründe, lütfen 'ptr' parametresinden önce gelen 'var' anahtar kelimesine dikkat edin. Bu yordama bir işaretçi iletildiğinde , başvuru ile iletilir . Davranışı not edin: Bu yordam ptr değerini nil olarak ayarladığında (bu NULL için parola konuşur), argümanı nil olarak ayarlar - Java'da bunu yapamazsınız.

program passByRefDemo;
type 
   iptr = ^integer;
var
   ptr: iptr;

   procedure setToNil(var ptr : iptr);
   begin
       ptr := nil;
   end;

begin
   new(ptr);
   ptr^ := 10;
   setToNil(ptr);
   if (ptr = nil) then
       writeln('ptr seems to be nil');     { ptr should be nil, so this line will run. }
end.

DÜZENLEME 2

Ken Arnold, James Gosling (Java'yı icat eden kişi) ve David Holmes, bölüm 2, bölüm 2.6.5 tarafından yazılan "THE Java Programlama Dili" nden bazı alıntılar

Yöntemlere ilişkin tüm parametreler "değere göre" geçirilir . Başka bir deyişle, bir yöntemdeki parametre değişkenlerinin değerleri, invoker'ın argüman olarak belirtilen kopyalarıdır.

Nesneler için de aynı noktayı vurgulamaya devam ediyor. . .

Parametre bir nesne başvurusu olduğunda, nesnenin kendisi değil, nesnenin başvurusu olduğunu ve "değere göre" iletildiğini unutmayın .

Ve aynı bölümün sonuna doğru, java'nın sadece değere göre geçtiği ve asla referansla geçmediği konusunda daha geniş bir açıklama yapar.

Java programlama dili nesneleri referans olarak iletmez; bu değer nesne referansları geçer . Aynı başvurunun iki kopyası aynı gerçek nesneyi ifade ettiğinden, bir referans değişkeni üzerinden yapılan değişiklikler diğeri tarafından görülebilir. Tam olarak bir parametre geçirme modu vardır - değer -ve ile işleri basit tutmaya yardımcı olur.

Kitabın bu bölümünde Java'da parametre geçişi ve referans by-pass ve by-value arasındaki farkın büyük bir açıklaması vardır ve Java'nın yaratıcısıdır. Özellikle ikna olmadıysanız, kimseyi okumaya teşvik ederim.

Bence iki model arasındaki fark çok incedir ve gerçekten referans olarak kullandığınız yerde programlama yapmadıysanız, iki modelin farklı olduğu yerleri kaçırmak kolaydır.

Umarım bu tartışmayı çözer, ama muhtemelen çözmez.

DÜZENLE 3

Bu yazıya biraz takıntılı olabilirim. Muhtemelen Java üreticilerinin yanlışlıkla yanlış bilgi yaydığını hissediyorum. İşaretçiler için "referans" kelimesini kullanmak yerine, başka bir şey kullandılarsa, dingleberry diyelim, sorun olmazdı. "Java, pislikleri referans ile değil değere geçirir" diyebilirsiniz ve kimse karışmaz.

Bu nedenle sadece Java geliştiricilerinin sorunu var. "Referans" kelimesine bakarlar ve bunun tam olarak ne anlama geldiğini bildiklerini düşünürler, bu yüzden karşıt argümanı düşünmek bile zahmetine girmezler.

Her neyse, eski bir gönderide, gerçekten sevdiğim bir balon benzetmesi yapan bir yorum fark ettim. Öyle ki, noktayı göstermek için bir dizi karikatür yapmak için bazı küçük resimleri yapıştırmaya karar verdim.

Bir referansın değere göre iletilmesi - Referanstaki değişiklikler, arayanın kapsamına yansıtılmaz, ancak nesnedeki değişiklikler yapılır. Bunun nedeni, başvurunun kopyalanmasıdır, ancak hem orijinal hem de kopya aynı nesneye başvurur.

Referansla geç - Referansın bir kopyası yok. Tek referans hem arayan hem de çağrılan işlev tarafından paylaşılır. Referans veya Nesne verilerindeki herhangi bir değişiklik, arayanın kapsamına yansıtılır.

DÜZENLEME 4

Bu konuda, Java'da parametre geçişinin düşük düzeyli uygulamasını açıklayan yayınlar gördüm, bu da büyük ve çok yararlı olduğunu düşünüyorum çünkü soyut bir fikri somutlaştırıyor. Ancak, bana göre soru daha çok davranışın teknik uygulamasından çok dil spesifikasyonunda tarif edilen davranış hakkındadır. Bu, Java Dil Spesifikasyonu, bölüm 8.4.1'den alınmıştır :

Yöntem veya kurucu çağrıldığında (§15.12), gerçek argüman ifadelerinin değerleri , yöntemin veya kurucunun gövdesinin yürütülmesinden önce, her biri bildirilen türden yeni oluşturulan parametre değişkenlerini başlatır. DeclaratorId'de görünen Tanımlayıcı, resmi parametreye başvurmak için yöntem veya yapıcı gövdesinde basit bir ad olarak kullanılabilir.

Yani java, bir yöntemi uygulamadan önce iletilen parametrelerin bir kopyasını oluşturur. Üniversitede derleyici okuyan çoğu insan gibi ben de "Ejderha Kitabı" nı kullandım olduğunu derleyiciler kitabı. Bölüm 1'de "Değer değerine göre çağrı" ve "Referansa göre çağrı" ile ilgili iyi bir açıklamaya sahiptir. Değere göre çağrı açıklaması, Java Spesifikasyonları ile tam olarak eşleşir.

90'lı yıllarda derleyiciler okuduğumda, 1986'dan itibaren Java'yı yaklaşık 9 veya 10 yıl öncesine dayanan kitabın ilk baskısını kullandım. Ancak, 2007'den 2. Baskı'nın bir kopyasına rastladım aslında Java'dan bahseden ! "Parametre Geçiş Mekanizmaları" etiketli Bölüm 1.6.6, parametre geçişini oldukça iyi açıklamaktadır. Java'dan bahseden "Değere göre çağrı" başlığı altında bir alıntı:

Call-by-value'da, gerçek parametre değerlendirilir (eğer bir ifade ise) veya kopyalanır (bir değişkense). Değer, çağrılan prosedürün karşılık gelen resmi parametresine ait konuma yerleştirilir. Bu yöntem C ve Java'da kullanılır ve C ++ 'da ve diğer birçok dilde yaygın bir seçenektir.

Bildiğim kadarıyla, Java sadece çağrıya göre değer biliyor. Bu, ilkel veri türleri için bir kopyayla ve nesneler için nesnelere yapılan başvurunun bir kopyasıyla çalışacağınız anlamına gelir. Ancak bazı tuzaklar olduğunu düşünüyorum; örneğin, bu çalışmaz:

public static void swap(StringBuffer s1, StringBuffer s2) {
    StringBuffer temp = s1;
    s1 = s2;
    s2 = temp;
}


public static void main(String[] args) {
    StringBuffer s1 = new StringBuffer("Hello");
    StringBuffer s2 = new StringBuffer("World");
    swap(s1, s2);
    System.out.println(s1);
    System.out.println(s2);
}

Bu, Hello World'ü değil Hello World'ü dolduracaktır, çünkü takas işlevinde ana referanslar üzerinde hiçbir etkisi olmayan kopyaları kullanırsınız. Ancak nesneleriniz değişmezse, örneğin değiştirebilirsiniz:

public static void appendWorld(StringBuffer s1) {
    s1.append(" World");
}

public static void main(String[] args) {
    StringBuffer s = new StringBuffer("Hello");
    appendWorld(s);
    System.out.println(s);
}

Bu, Hello World'ü komut satırında dolduracaktır. StringBuffer'ı String olarak değiştirirseniz, String değişmez olduğu için yalnızca Hello üretir. Örneğin:

public static void appendWorld(String s){
    s = s+" World";
}

public static void main(String[] args) {
    String s = new String("Hello");
    appendWorld(s);
    System.out.println(s);
}

Ancak, String için şu şekilde bir sarmalayıcı oluşturabilirsiniz;

class StringWrapper {
    public String value;

    public StringWrapper(String value) {
        this.value = value;
    }
}

public static void appendWorld(StringWrapper s){
    s.value = s.value +" World";
}

public static void main(String[] args) {
    StringWrapper s = new StringWrapper("Hello");
    appendWorld(s);
    System.out.println(s.value);
}

edit: bu da String gibi değişmez nesneleri ile yapamaz orijinal nesne değiştirebilirsiniz çünkü iki dizeleri "ekleme" söz konusu olduğunda StringBuffer kullanmanın nedeni olduğuna inanıyorum.

Hayır, referans ile geçilmez.

Java, Java Dil Belirtimi'ne göre değere göre geçer:

Yöntem veya kurucu çağrıldığında (§15.12), gerçek argüman ifadelerinin değerleri , yöntemin veya kurucunun gövdesinin yürütülmesinden önce, her biri bildirilen türden yeni oluşturulan parametre değişkenlerini başlatır . DeclaratorId'de görünen Tanımlayıcı, resmi parametreye başvurmak için yöntem veya yapıcı gövdesinde basit bir ad olarak kullanılabilir .

Dört örnek yardımıyla anlayışımı açıklamaya çalışayım. Java, değere göre değerlidir ve başvuruya göre değil

/ **

Değere Göre Geçme

Java'da tüm parametreler değere göre iletilir; başka bir deyişle, bir yöntem bağımsız değişkeni atamak arayan tarafından görülemez.

* /

Örnek 1:

public class PassByValueString {
    public static void main(String[] args) {
        new PassByValueString().caller();
    }

    public void caller() {
        String value = "Nikhil";
        boolean valueflag = false;
        String output = method(value, valueflag);
        /*
         * 'output' is insignificant in this example. we are more interested in
         * 'value' and 'valueflag'
         */
        System.out.println("output : " + output);
        System.out.println("value : " + value);
        System.out.println("valueflag : " + valueflag);

    }

    public String method(String value, boolean valueflag) {
        value = "Anand";
        valueflag = true;
        return "output";
    }
}

Sonuç

output : output
value : Nikhil
valueflag : false

Örnek 2:

/ ** * * Değere Göre Geç * * /

public class PassByValueNewString {
    public static void main(String[] args) {
        new PassByValueNewString().caller();
    }

    public void caller() {
        String value = new String("Nikhil");
        boolean valueflag = false;
        String output = method(value, valueflag);
        /*
         * 'output' is insignificant in this example. we are more interested in
         * 'value' and 'valueflag'
         */
        System.out.println("output : " + output);
        System.out.println("value : " + value);
        System.out.println("valueflag : " + valueflag);

    }

    public String method(String value, boolean valueflag) {
        value = "Anand";
        valueflag = true;
        return "output";
    }
}

Sonuç

output : output
value : Nikhil
valueflag : false

Örnek 3:

/ ** Bu 'Pass By Value' Referansla Pass 'hissine sahiptir

Bazı insanlar ilkel türlerin ve 'String'in' değere göre geç 'olduğunu ve nesnelerin' referansla geç 'olduğunu söyler.

Ancak bu örnekten, referansı değer olarak geçirdiğimizi akılda tutarak, bunun sadece değere göre kesin olarak geçtiğini anlayabiliriz. yani: referans değere göre iletilir. Bu yüzden değişebilir ve yerel kapsamdan sonra hala geçerlidir. Ancak asıl referansı orijinal kapsamın dışında değiştiremeyiz. bunun anlamı bir sonraki PassByValueObjectCase2 örneği ile gösterilmiştir.

* /

public class PassByValueObjectCase1 {

    private class Student {
        int id;
        String name;
        public Student() {
        }
        public Student(int id, String name) {
            super();
            this.id = id;
            this.name = name;
        }
        public int getId() {
            return id;
        }
        public void setId(int id) {
            this.id = id;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        @Override
        public String toString() {
            return "Student [id=" + id + ", name=" + name + "]";
        }
    }

    public static void main(String[] args) {
        new PassByValueObjectCase1().caller();
    }

    public void caller() {
        Student student = new Student(10, "Nikhil");
        String output = method(student);
        /*
         * 'output' is insignificant in this example. we are more interested in
         * 'student'
         */
        System.out.println("output : " + output);
        System.out.println("student : " + student);
    }

    public String method(Student student) {
        student.setName("Anand");
        return "output";
    }
}

Sonuç

output : output
student : Student [id=10, name=Anand]

Örnek 4:

/ **

Örnek3'te (PassByValueObjectCase1.java) belirtilenlere ek olarak, gerçek başvuruyu orijinal kapsamın dışında değiştiremeyiz. "

Not: Kodunu yapıştırmıyorum private class Student. İçin sınıf tanımı StudentÖrnek3 ile aynıdır.

* /

public class PassByValueObjectCase2 {

    public static void main(String[] args) {
        new PassByValueObjectCase2().caller();
    }

    public void caller() {
        // student has the actual reference to a Student object created
        // can we change this actual reference outside the local scope? Let's see
        Student student = new Student(10, "Nikhil");
        String output = method(student);
        /*
         * 'output' is insignificant in this example. we are more interested in
         * 'student'
         */
        System.out.println("output : " + output);
        System.out.println("student : " + student); // Will it print Nikhil or Anand?
    }

    public String method(Student student) {
        student = new Student(20, "Anand");
        return "output";
    }

}

Sonuç

output : output
student : Student [id=10, name=Nikhil]

Java'da hiçbir zaman başvuru ile geçemezsiniz ve aşikar olan yollardan biri, bir yöntem çağrısından birden fazla değer döndürmek istemenizdir. Aşağıdaki kod bitini C ++ ile düşünün:

void getValues(int& arg1, int& arg2) {
    arg1 = 1;
    arg2 = 2;
}
void caller() {
    int x;
    int y;
    getValues(x, y);
    cout << "Result: " << x << " " << y << endl;
}

Bazen Java'da aynı kalıbı kullanmak istersiniz, ancak kullanamazsınız; en azından doğrudan değil. Bunun yerine böyle bir şey yapabilirsiniz:

void getValues(int[] arg1, int[] arg2) {
    arg1[0] = 1;
    arg2[0] = 2;
}
void caller() {
    int[] x = new int[1];
    int[] y = new int[1];
    getValues(x, y);
    System.out.println("Result: " + x[0] + " " + y[0]);
}

Önceki yanıtlarda açıklandığı gibi, Java'da diziye bir değer olarak bir işaretçi geçiriyorsunuz getValues. Bu yeterlidir, çünkü yöntem daha sonra dizi öğesini değiştirir ve kural olarak, 0 öğesinin dönüş değerini içermesini beklersiniz. Açıkçası bunu, kodunuzu gerekli olmayacak şekilde yapılandırmak veya dönüş değerini içerebilecek veya ayarlanmasına izin verecek bir sınıf oluşturmak gibi başka şekillerde de yapabilirsiniz. Ancak yukarıdaki C ++ ile kullanabileceğiniz basit desen Java'da mevcut değildir.

Spesifikasyonlardan daha fazla ayrıntı eklemek için bu cevaba katkıda bulunacağımı düşündüm.

İlk olarak, referansla geçiş ile değere göre geçiş arasındaki fark nedir?

Referans yoluyla geçme, çağrılan fonksiyonların parametresi, arayanların geçirilen argümanı ile aynı olacaktır (değer değil, kimlik - değişkenin kendisi).

Değere göre geçirme, çağrılan işlevlerin parametresi, arayanların geçirilen bağımsız değişkeninin bir kopyası olacağı anlamına gelir.

Veya wikipedia'dan, referansla pass konusunda

Referansa göre arama değerlendirmesinde (referansla by pass olarak da adlandırılır), bir işlev, değerinin bir kopyası yerine bağımsız değişken olarak kullanılan bir değişkene örtülü bir başvuru alır. Bu genellikle işlevin argüman olarak kullanılan değişkeni değiştirebileceği (yani atayabileceği) anlamına gelir - arayan tarafından görülecek bir şey.

Ve değer bazında

Call-by-value'da, argüman ifadesi değerlendirilir ve ortaya çıkan değer, [...] fonksiyonundaki ilgili değişkene bağlanır. İşlev veya prosedür parametrelerine değer atayabilirse, yalnızca yerel kopyası atanır [...].

İkincisi, Java'nın yöntem çağrılarında ne kullandığını bilmemiz gerekir. Java Dil Şartname devletler

Yöntem veya kurucu çağrıldığında (§15.12), gerçek argüman ifadelerinin değerleri , yöntemin veya kurucunun gövdesinin yürütülmesinden önce, her biri bildirilen türden yeni oluşturulan parametre değişkenlerini başlatır .

Böylece, bağımsız değişkenin değerini ilgili parametre değişkenine atar (veya bağlar).

Argümanın değeri nedir?

Let referans tipleri, düşünün Java Virtual Machine Şartname devletleri

Üç tür referans türü vardır : sınıf türleri, dizi türleri ve arabirim türleri. Değerleri, dinamik olarak oluşturulan sınıf örneklerine, dizilere veya arabirimleri uygulayan sınıf örneklerine veya dizilere referanstır.

Java Dil Şartname ayrıca devletler

Referans değerleri (genellikle sadece referanslar) bu nesnelere işaret eder ve hiçbir nesneye atıfta bulunmayan özel bir boş referanstır.

Bir argümanın değeri (bazı referans türlerinden) bir nesneye işaret eder. Bir değişkenin, başvuru türü döndürme türüne sahip bir yöntemin çağrılması ve bir örnek oluşturma ifadesinin ( new ...) hepsinin referans türü değerine çözümlendiğini unutmayın.

Yani

public void method (String param) {}
...
String var = new String("ref");
method(var);
method(var.toString());
method(new String("ref"));

tümü, bir Stringörneğe yapılan başvurunun değerini yöntemin yeni oluşturulan parametresine bağlar param. Bu, tam-değer-tanımının tanımladığı şeydir. Bu nedenle, Java by-pass-by değeridir .

Bir yöntemi çağırmak veya başvurulan nesnenin bir alanına erişmek için referansı takip edebilmeniz, konuşma ile tamamen ilgisizdir. Referansla pass tanımı

Bu genellikle işlevin argüman olarak kullanılan değişkeni değiştirebileceği (yani atayabileceği) anlamına gelir - arayan tarafından görülecek bir şey.

Java'da değişkeni değiştirmek, yeniden atamak anlamına gelir. Java'da, değişkeni yöntem içinde yeniden atarsanız, arayana fark edilmez. Değişkenin referans aldığı nesneyi değiştirmek tamamen farklı bir kavramdır.

İlkel değerler ayrıca burada Java Sanal Makine Spesifikasyonu'nda tanımlanmıştır . Türün değeri, uygun şekilde kodlanmış karşılık gelen integral veya kayan nokta değeridir (8, 16, 32, 64 vb. Bitler).

Java'da yalnızca başvurular iletilir ve değere göre iletilir:

Java bağımsız değişkenlerinin tümü değere göre iletilir (başvuru yöntem tarafından kullanıldığında kopyalanır):

İlkel türlerde Java davranışı basittir: Değer, ilkel türün başka bir örneğinde kopyalanır.

Nesneler söz konusu olduğunda aynıdır: Nesne değişkenleri, yalnızca "new" anahtar sözcüğü kullanılarak oluşturulan ve ilkel türler gibi kopyalanan Object'in adresini tutan işaretçilerdir (kovalar) .

Davranış ilkel türlerden farklı görünebilir: Kopyalanan nesne değişkeni aynı adresi içerdiğinden (aynı Nesneye). Nesnenin içeriği / üyeleri yine de bir yöntem içinde değiştirilebilir ve daha sonra dışarıya erişerek Nesnenin kendisinin referans olarak geçirildiği yanılsamasını verir.

"String" Nesneleri , "Nesnelerin referans olarak iletildiğini" söyleyen kentsel efsaneye iyi bir karşı örnek gibi görünüyor :

Aslında, bir yöntem kullanarak, argüman olarak iletilen bir Dizenin değerini asla güncelleyemezsiniz:

Bir String Nesnesi, karakterleri değiştirilemeyen final olarak belirtilen bir diziye göre tutar . Yalnızca nesnenin adresi "yeni" kullanılarak başka bir adresle değiştirilebilir. Değişkeni güncellemek için "yeni" kullanıldığında, değişken başlangıçta değere göre geçirildiğinden ve kopyalandığından Nesneye dışarıdan erişilmesine izin vermez.

Ayrım, ya da belki de orijinal posterle aynı izlenim altında olduğum gibi hatırladığım yol şudur: Java her zaman değere göre geçer. Java'daki tüm nesneler (Java'da, ilkel öğeler hariç her şey) referanstır. Bu referanslar değere göre iletilir.

Daha önce birçok kişinin belirttiği gibi, Java her zaman değerlidir

Farkı anlamanıza yardımcı olacak başka bir örnek ( klasik takas örneği ):

public class Test {
  public static void main(String[] args) {
    Integer a = new Integer(2);
    Integer b = new Integer(3);
    System.out.println("Before: a = " + a + ", b = " + b);
    swap(a,b);
    System.out.println("After: a = " + a + ", b = " + b);
  }

  public static swap(Integer iA, Integer iB) {
    Integer tmp = iA;
    iA = iB;
    iB = tmp;
  }
}

Baskılar:

Önce: a = 2, b = 3
Sonra: a = 2, b = 3

Bunun nedeni, iA ve iB'nin iletilen referanslarla aynı değere sahip yeni yerel referans değişkenleridir (sırasıyla a ve b'yi gösterir). Bu nedenle, iA veya iB referanslarını değiştirmeye çalışmak, bu yöntemin dışında değil, yalnızca yerel kapsamda değişecektir.

Java sadece değere göre geçer. Bunu doğrulamak için çok basit bir örnek.

public void test() {
    MyClass obj = null;
    init(obj);
    //After calling init method, obj still points to null
    //this is because obj is passed as value and not as reference.
}
private void init(MyClass objVar) {
    objVar = new MyClass();
}

Ben her zaman "kopya ile geçmek" olarak düşünüyorum. İlkel veya referans olsun, değerin bir kopyasıdır. Bir ilkel ise, değer olan bitlerin bir kopyasıdır ve bir Nesne ise, referansın bir kopyasıdır.

public class PassByCopy{
    public static void changeName(Dog d){
        d.name = "Fido";
    }
    public static void main(String[] args){
        Dog d = new Dog("Maxx");
        System.out.println("name= "+ d.name);
        changeName(d);
        System.out.println("name= "+ d.name);
    }
}
class Dog{
    public String name;
    public Dog(String s){
        this.name = s;
    }
}

Java PassByCopy çıktısı:

name = Maxx
name = Fido

İlkel sargı sınıfları ve Dizeler değiştirilemez, bu nedenle bu türleri kullanan herhangi bir örnek diğer türlerle / nesnelerle aynı şekilde çalışmaz.

Diğer bazı dillerden farklı olarak, Java, değere göre ve referansla geçiş arasında seçim yapmanıza izin vermez; tüm bağımsız değişkenler değere göre geçirilir. Bir yöntem çağrısı, bir yönteme iki tür değer iletebilir: ilkel değerlerin kopyaları (örn. İnt ve double değerleri) ve nesnelere başvuruların kopyaları.

Bir yöntem, ilkel tipte bir parametreyi değiştirdiğinde, parametrede yapılan değişikliklerin, çağıran yöntemdeki orijinal bağımsız değişken değeri üzerinde hiçbir etkisi yoktur.

Nesneler söz konusu olduğunda, nesnelerin kendileri yöntemlere aktarılamaz. Böylece nesnenin referansını (adresini) iletiyoruz. Bu referansı kullanarak orijinal nesneyi değiştirebiliriz.

Java nesneleri nasıl oluşturur ve depolar: Bir nesne oluşturduğumuzda, nesnenin adresini bir referans değişkeninde saklarız. Aşağıdaki ifadeyi analiz edelim.

Account account1 = new Account();

“Account account1” referans değişkeninin türü ve adı, “=” atama operatörüdür, “new” sistemden gerekli alan miktarını ister. Nesneyi oluşturan new anahtar sözcüğünün sağındaki yapıcı, new anahtar sözcüğü tarafından örtük olarak çağrılır. Oluşturulan nesnenin adresi ("sınıf örneği oluşturma ifadesi" olarak adlandırılan bir ifade olan sağ değerin sonucu), atama işleci kullanılarak sol değere (adı ve türü belirtilmiş bir başvuru değişkeni olan) atanır.

Bir nesnenin başvurusu değere göre iletilse de, bir yöntem yine de başvurulan nesneyle ortak başvuru yöntemini nesnenin başvurusunun kopyasını kullanarak çağırarak etkileşime girebilir. Parametrede saklanan başvuru, bağımsız değişken olarak iletilen başvurunun bir kopyası olduğundan, çağrılan yöntemdeki parametre ve çağıran yöntemdeki bağımsız değişken, bellekteki aynı nesneye başvurur.

Dizi nesnelerinin kendileri yerine dizilere başvurular iletmek, performans nedenleriyle mantıklıdır. Java'daki her şey değere göre geçtiğinden, dizi nesneleri geçirilirse, her öğenin bir kopyası geçirilir. Büyük diziler için bu, zaman kaybına neden olur ve öğelerin kopyaları için önemli miktarda depolama alanı kullanır.

Aşağıdaki görüntüde iki referans değişkenimiz var (bunlar C / C ++ 'da işaretçiler olarak adlandırılır ve bu terimin bu özelliği anlamayı kolaylaştırdığını düşünüyorum). İlkel ve referans değişkenleri yığın bellekte tutulur (aşağıdaki görüntülerde sol taraf). dizi1 ve dizi2 referans değişkenleri "nokta" (C / C ++ programcılarının dediği gibi) veya yığın hafızasındaki (aşağıdaki resimlerde sağ taraf) nesneler (bu referans değişkenlerinin tuttuğu değerler) sırasıyla a ve b dizilerine başvuru .

Array1 başvuru değişkeninin değerini reverseArray yöntemine bağımsız değişken olarak iletirsek, yöntemde bir başvuru değişkeni oluşturulur ve bu başvuru değişkeni aynı diziyi (a) işaret etmeye başlar.

public class Test
{
    public static void reverseArray(int[] array1)
    {
        // ...
    }

    public static void main(String[] args)
    {
        int[] array1 = { 1, 10, -7 };
        int[] array2 = { 5, -190, 0 };

        reverseArray(array1);
    }
}

Yani, eğer

array1[0] = 5;

reverseArray yönteminde, a dizisinde bir değişiklik yapar.

Bir dizi c'yi gösteren reverseArray yönteminde (dizi2) başka bir başvuru değişkenimiz var. Eğer söyleseydik

array1 = array2;

reverseArray yönteminde, reverseArray yöntemindeki dizi değişkeni başvuru dizisi a dizisine işaret etmeyi durdurur ve c dizisine (ikinci görüntüde noktalı çizgi) işaret etmeye başlar.

Dizi değişkeni değerini reverseArray yönteminin dönüş değeri olarak döndürürsek ve bu değeri ana yöntemde dizi1 başvuru değişkenine atarsak, dizi1 ana diziyi c dizisini göstermeye başlar.

Şimdi yaptığımız her şeyi hemen yazalım.

public class Test
{
    public static int[] reverseArray(int[] array1)
    {
        int[] array2 = { -7, 0, -1 };

        array1[0] = 5; // array a becomes 5, 10, -7

        array1 = array2; /* array1 of reverseArray starts
          pointing to c instead of a (not shown in image below) */
        return array2;
    }

    public static void main(String[] args)
    {
        int[] array1 = { 1, 10, -7 };
        int[] array2 = { 5, -190, 0 };

        array1 = reverseArray(array1); /* array1 of 
         main starts pointing to c instead of a */
    }
}

Ve şimdi reverseArray yöntemi bitti, referans değişkenleri (dizi1 ve dizi2) gitti. Bu, şimdi sadece ana yöntem dizi1 ve dizi2'de sırasıyla c ve b dizilerini gösteren iki referans değişkenine sahip olduğumuz anlamına gelir. Referans değişken hiçbir nesneyi (dizi) göstermiyor a. Bu nedenle çöp toplama için uygundur.

Ayrıca dizi1'e ana dizi2 dizisinin değerini atayabilirsiniz. dizi1 b'yi işaret etmeye başlar.

Burada herhangi bir programlama dili için bu tür sorulara ayrılmış bir iş parçacığı oluşturdum .

Java'dan da bahsedilmektedir . İşte kısa özet:

• Java, parametreleri değere geçirir
• java'da bir parametreye bir metoda geçmenin tek yolu "by by value"
• parametre olarak verilen nesneden yöntemler kullanılması, referanslar orijinal nesnelere işaret ettiği için nesneyi değiştirir. (bu yöntemin kendisi bazı değerleri değiştirirse)

Uzun bir hikaye kısaca anlatmak gerekirse, Java nesneleri çok tuhaf özelliklere sahiptir.

Genel olarak, bir Java (ilkel türleri vardır int, bool, char, doubledeğeri doğrudan geçirilir, vb). Sonra Java nesneleri var (her şeyi türetir java.lang.Object). Nesneler aslında her zaman bir referansla (başvuru dokunamayacağınız bir işaretçi) ele alınır. Bu, referanslar normalde ilginç olmadığından, nesnelerin referans olarak geçirildiği anlamına gelir. Ancak bu, başvurunun kendisi değere göre iletilirken hangi nesnenin işaret edileceğini değiştiremeyeceğiniz anlamına gelir.

Kulağa garip ve kafa karıştırıcı geliyor mu? C uygulamalarının referans ile nasıl geçtiğini ve değere göre nasıl geçtiğini ele alalım. C de, varsayılan kural değerdir. void foo(int x)int değerini değere geçirir. void foo(int *x), int abir int istemeyen ancak int: işaretçisi olan bir işlevdir foo(&a). &Değişken bir adres iletmek için bunu operatörle birlikte kullanabilirsiniz .

Bunu C ++ 'a götürün ve referanslarımız var. Referanslar temel olarak (bu bağlamda) denklemin işaretçi kısmını gizleyen sözdizimsel şekerdir: void foo(int &x)denir foo(a), burada derleyici kendisi bir referans olduğunu bilir ve referans olmayanın adresi ailetilmelidir. Java'da, nesnelere atıfta bulunan tüm değişkenler aslında referans türündedir, aslında C ++ tarafından sağlanan ince taneli kontrol (ve karmaşıklık) olmaksızın çoğu amaç ve amaç için çağrıyı referans olarak zorlar.