Ini adalah poin penting, tapi IMHO patut dipahami.
Semua bahasa OO selalu membuat salinan referensi, dan tidak pernah menyalin objek 'tidak terlihat'. Akan jauh lebih sulit untuk menulis program jika bahasa OO bekerja dengan cara lain. Misalnya, fungsi, dan metode, tidak pernah dapat memperbarui objek. Java, dan sebagian besar bahasa OO hampir tidak mungkin digunakan tanpa kompleksitas tambahan yang signifikan.
Objek dalam suatu program seharusnya memiliki arti. Misalnya itu mewakili sesuatu yang spesifik di dunia fisik nyata. Biasanya masuk akal jika memiliki banyak referensi untuk hal yang sama. Misalnya, alamat rumah saya dapat diberikan kepada banyak orang dan organisasi, dan alamat itu selalu merujuk ke lokasi fisik yang sama. Jadi poin pertama adalah, obyek sering mewakili sesuatu yang spesifik, nyata, atau konkret; sehingga dapat memiliki banyak referensi untuk hal yang sama sangat berguna. Kalau tidak, akan lebih sulit untuk menulis program.
Setiap kali Anda meneruskan a
sebagai argumen / parameter ke fungsi lain misalnya memanggil
foo(Dog aDoggy);
atau menerapkan metode a
, kode program yang mendasari membuat salinan referensi, untuk menghasilkan referensi kedua ke objek yang sama.
Lebih lanjut, jika kode dengan referensi yang disalin berada di utas yang berbeda, maka keduanya dapat digunakan secara bersamaan untuk mengakses objek yang sama.
Jadi dalam sebagian besar program yang bermanfaat, akan ada banyak referensi ke objek yang sama, karena itu adalah semantik dari sebagian besar bahasa pemrograman OO.
Sekarang, jika kita memikirkannya, karena lewat referensi adalah satu - satunya mekanisme yang tersedia dalam banyak bahasa OO (C ++ mendukung keduanya), kita mungkin berharap itu menjadi perilaku default 'benar' .
IMHO, menggunakan referensi adalah default yang tepat , karena beberapa alasan:
- Ini menjamin bahwa nilai suatu objek yang digunakan di dua tempat berbeda adalah sama. Bayangkan menempatkan sebuah objek ke dalam dua struktur data yang berbeda (array, daftar, dll.), Dan melakukan beberapa operasi pada objek yang mengubahnya. Itu bisa menjadi mimpi buruk untuk debug. Lebih penting lagi, itu adalah objek yang sama di kedua struktur data, atau program memiliki bug.
- Anda dapat dengan senang hati mengubah kode menjadi beberapa fungsi, atau menggabungkan kode dari beberapa fungsi menjadi satu, dan semantiknya tidak berubah. Jika bahasa tidak memberikan semantik referensi, itu akan menjadi lebih kompleks untuk memodifikasi kode.
Ada juga argumen efisiensi; membuat salinan seluruh objek kurang efisien daripada menyalin referensi. Namun, saya pikir itu melenceng. Berbagai referensi ke objek yang sama lebih masuk akal, dan lebih mudah digunakan, karena cocok dengan semantik dunia fisik nyata.
Jadi, IMHO, biasanya masuk akal untuk memiliki banyak referensi ke objek yang sama. Dalam kasus yang tidak biasa di mana itu tidak masuk akal dalam konteks suatu algoritma, sebagian besar bahasa menyediakan kemampuan untuk membuat 'klon' atau salinan dalam. Namun itu bukan default.
Saya pikir orang-orang yang berpendapat bahwa ini seharusnya bukan default menggunakan bahasa yang tidak menyediakan pengumpulan sampah otomatis. Misalnya, C ++ kuno. Masalahnya adalah bahwa mereka perlu menemukan cara untuk mengumpulkan benda-benda 'mati' dan tidak mengklaim kembali benda-benda yang mungkin masih diperlukan; memiliki banyak referensi ke objek yang sama menjadikannya sulit.
Saya pikir, jika C ++ memiliki pengumpulan sampah yang cukup murah, sehingga semua objek yang direferensikan adalah sampah yang dikumpulkan, maka sebagian besar keberatan hilang. Masih ada beberapa kasus di mana semantik referensi tidak dibutuhkan. Namun, dalam pengalaman saya, orang-orang yang dapat mengidentifikasi situasi-situasi itu juga biasanya mampu memilih semantik yang sesuai pula.
Saya percaya ada beberapa bukti bahwa sejumlah besar kode dalam program C ++ ada untuk menangani atau mengurangi pengumpulan sampah. Namun, menulis, dan memelihara kode 'infrastruktur' semacam itu menambah biaya; itu ada untuk membuat bahasa lebih mudah digunakan, atau lebih kuat. Jadi, misalnya bahasa Go dirancang dengan fokus untuk memulihkan beberapa kelemahan C ++, dan tidak memiliki pilihan selain pengumpulan sampah.
Ini tentu saja tidak relevan dalam konteks Jawa. Itu juga dirancang agar mudah digunakan, dan begitu pula pengumpulan sampah. Oleh karena itu memiliki banyak referensi adalah semantik default, dan relatif aman dalam arti bahwa objek tidak direklamasi sementara ada referensi ke sana. Tentu saja mereka mungkin dipegang oleh struktur data karena program tidak benar merapikan ketika sudah benar-benar selesai dengan objek.
Jadi, berputar kembali ke pertanyaan Anda (dengan sedikit generalisasi), kapan Anda ingin lebih dari satu referensi ke objek yang sama? Cukup banyak dalam setiap situasi yang dapat saya pikirkan. Mereka adalah semantik default dari sebagian besar mekanisme parameter lewat bahasa. Saya menyarankan itu karena semantik default untuk menangani objek yang ada di dunia nyata cukup banyak dengan referensi ('karena objek yang sebenarnya ada di luar sana).
Semantik lainnya akan lebih sulit ditangani.
Dog a = new Dog("rover"); // initialise with name
DogList dl = new DogList()
dl.add(a)
...
a.setOwner("Mr Been")
Saya menyarankan bahwa "bajak" di dl
harus yang dipengaruhi oleh setOwner
atau program menjadi sulit untuk menulis, memahami, men-debug atau memodifikasi. Saya pikir sebagian besar programmer akan bingung atau kecewa sebaliknya.
kemudian, anjing itu dijual:
soldDog = dl.lookupOwner("rover", "Mr Been")
soldDog.setOwner("Mr Mcgoo")
Jenis pemrosesan ini biasa dan normal. Jadi referensi semantik adalah default karena biasanya paling masuk akal.
Ringkasan: Selalu masuk akal untuk memiliki banyak referensi ke objek yang sama.