Jika suatu variabel memiliki pengambil dan penyetel, haruskah itu publik?

Saya memiliki kelas dengan variabel yang bersifat pribadi dan kelas memiliki pengambil dan penyetel untuk variabel itu. Mengapa tidak menjadikan variabel itu publik?

Satu-satunya kasus saya pikir Anda harus menggunakan getter dan setter adalah jika Anda perlu melakukan beberapa operasi selain set atau get. Contoh:

void my_class::set_variable(int x){
   /* Some operation like updating a log */
   this->variable = x;
}

Pernahkah Anda mendengar tentang properti?

Properti adalah bidang yang memiliki aksesor "bawaan" (getter dan setter). Java, misalnya, tidak memiliki properti, tetapi disarankan untuk menulis getter dan setter ke bidang pribadi. C # memiliki properti.

Jadi, mengapa kita membutuhkan getter dan setter? Pada dasarnya kita membutuhkannya untuk melindungi / melindungi lapangan. Misalnya, Anda tidak mengakses bidang dalam referensi memori, Anda sedang mengakses metode yang kemudian akan mengubah bidang (referensi). Metode itu mampu melakukan beberapa operasi yang pengguna tidak mau tahu ( perilaku enkapsulasi ), seperti dalam contoh Anda. Bayangkan, misalnya, bahwa selusin kelas menggunakan bidang publik Anda dan Anda perlu mengubah cara itu digunakan ... Anda harus melihat masing-masing kelas untuk mengubah cara mereka menggunakan bidang ... Tidak jadi "OOlysh".

Tapi, misalnya, Jika Anda memiliki bidang boolean yang disebut mati. Anda harus berpikir dua kali sebelum mendeklarasikan setDead dan isDead. Anda harus menulis pengakses yang dapat dibaca manusia , misalnya, kill () alih-alih setDead.

Namun, ada banyak kerangka kerja yang menganggap bahwa Anda mengikuti konvensi penamaan JavaBean (berbicara tentang Java di sini), oleh karena itu, dalam kasus tersebut, Anda harus mendeklarasikan semua getter dan setter mengikuti konvensi penamaan.

Ini bukan pendapat yang paling populer tetapi saya tidak melihat banyak perbedaan.

Setter dan getter adalah ide yang cukup buruk. Saya sudah memikirkannya dan jujur ​​saya tidak bisa menemukan perbedaan antara setter / pengambil properti dan variabel publik dalam praktik.

Dalam TEORI setter dan pengambil atau properti menambahkan tempat untuk mengambil beberapa tindakan tambahan ketika variabel diatur / didapat dan secara teori mereka mengisolasi kode Anda dari perubahan.

Pada kenyataannya saya jarang melihat setter dan getter digunakan untuk menambahkan aksi, dan ketika Anda ingin menambahkan aksi Anda ingin menambahkannya ke SEMUA setter atau getter dari suatu kelas (seperti logging) yang seharusnya membuat Anda berpikir bahwa harus ada menjadi solusi yang lebih baik.

Adapun untuk mengisolasi keputusan desain, jika Anda mengubah int untuk waktu yang lama, Anda masih harus mengubah setter Anda dan setidaknya memeriksa setiap baris yang mengaksesnya dengan tangan - tidak banyak isolasi di sana.

Kelas yang tidak dapat diubah harus dihindari secara default, jadi menambahkan setter harus menjadi pilihan terakhir. Ini dimitigasi dengan pola pembangun di mana nilai dapat diatur hingga objek berada dalam keadaan yang diinginkan maka kelas bisa menjadi tidak berubah dan setter Anda akan melempar pengecualian.

Sedangkan untuk getter - saya masih tidak bisa membuat banyak perbedaan antara pengambil dan variabel final publik. Masalahnya di sini adalah bahwa OO buruk dalam kedua kasus. Anda seharusnya tidak meminta nilai dari objek dan mengoperasikannya - Anda harus meminta objek untuk melakukan operasi untuk Anda.

Omong-omong, saya sama sekali tidak mengadvokasi variabel publik - saya katakan setter dan getter (dan bahkan properti) terlalu dekat dengan variabel publik yang sudah ada.

Masalah besarnya adalah orang-orang yang bukan pemrogram OO terlalu tergoda untuk menggunakan setter dan getter untuk membuat objek menjadi bola-properti (struktur) yang diedarkan dan dioperasikan, cukup berlawanan dengan cara kerja kode Berorientasi Objek.

Pengguna getter dan setter masuk ke dalam prinsip enkapsulasi . Ini akan memungkinkan Anda untuk mengubah cara kerja di dalam kelas dan menjaga semuanya berfungsi.

Misalnya jika 3 objek lain memanggil foo.baruntuk mendapatkan nilai bar dan Anda memutuskan untuk mengubah nama bar sejauh Anda memiliki masalah di tangan Anda. Jika objek yang dipanggil foo.barAnda harus mengubah semua kelas yang memiliki ini. Jika setter / pengambil digunakan maka Anda tidak perlu mengubah apa pun. Kemungkinan lain adalah mengubah jenis variabel yang hanya menambahkan beberapa kode transformasi ke pengambil / penyetel dan Anda baik-baik saja.

Menggunakan getter dan setter juga memungkinkan Anda untuk mengontrol konten apa yang disimpan dalam variabel tertentu. Jika konten perlu jenis atau nilai tertentu, bagian dari kode penyetel Anda dapat memastikan bahwa nilai yang baru memenuhi persyaratan ini. Jika variabel bersifat publik, Anda tidak dapat memastikan persyaratan ini dipenuhi.

Pendekatan ini juga membuat kode Anda lebih mudah beradaptasi dan dikelola. Jauh lebih mudah untuk membuat perubahan pada arsitektur kelas jika Anda memiliki fungsi di tempat yang membuat arsitektur itu tersembunyi dari semua kelas lain atau fungsi yang memanfaatkan kelas itu. Perubahan nama variabel yang telah disebutkan hanyalah satu dari banyak perubahan yang lebih mudah dilakukan jika Anda memiliki fungsi seperti getter dan setter. Gagasan keseluruhan adalah untuk menjaga privasi sebanyak mungkin, terutama variabel kelas Anda.

Anda mengatakan "Satu-satunya kasus saya pikir Anda harus menggunakan getter dan setter adalah jika Anda perlu melakukan beberapa operasi selain set atau get."

Anda harus menggunakan getter dan setter jika pada suatu saat nanti Anda mungkin perlu melakukan beberapa operasi selain set dan get dan Anda tidak ingin mengubah ribuan baris kode sumber ketika itu terjadi.

Anda harus menggunakan getter dan setter jika Anda tidak ingin seseorang mengambil alamat variabel dan menyebarkannya, dengan konsekuensi yang merusak jika variabel itu kemudian dapat diubah tanpa kode sumber menyebutkannya, atau bahkan setelah objek berhenti ada lagi .

Pertama mari kita perjelas paradigma.

• Struktur Data -> tata letak memori yang dapat dilalui dan dimanipulasi oleh fungsi yang sesuai dengan pengetahuan.
• Objek -> modul mandiri yang menyembunyikan implementasinya dan menyediakan antarmuka yang dapat dikomunikasikan.

Di mana pengambil / penyetel berguna?

Apakah getter / setter berguna dalam Struktur Data? Tidak.

Struktur Data adalah spesifikasi tata letak memori yang umum dan dimanipulasi oleh sekumpulan fungsi.

Secara umum, setiap fungsi baru yang lama dapat muncul dan memanipulasi struktur data, jika ia melakukannya sedemikian rupa sehingga fungsi lainnya masih dapat memahaminya, maka fungsi tersebut bergabung dengan keluarga. Kalau tidak, ini adalah fungsi jahat dan sumber bug.

Jangan salah paham, mungkin ada beberapa keluarga fungsi yang berperang karena struktur data dengan snitch, turn-coats, dan agen ganda di mana-mana. Tidak apa-apa ketika mereka masing-masing memiliki struktur data sendiri untuk dimainkan, tetapi ketika mereka membagikannya ... bayangkan saja beberapa keluarga kriminal yang tidak setuju dengan politik, itu bisa menjadi kekacauan yang sangat cepat.

Mengingat kekacauan yang dapat dicapai fungsi keluarga, apakah ada cara untuk menyandikan struktur data sehingga fungsi jahat tidak mengacaukan semuanya? Ya, mereka disebut Objects.

Apakah getter / setter berguna di Objek? Tidak.

Inti dari membungkus struktur data di suatu objek adalah untuk memastikan bahwa tidak ada fungsi jahat yang bisa ada. Jika fungsi ingin bergabung dengan keluarga, itu harus diperiksa terlebih dahulu dan kemudian menjadi bagian dari objek.

Titik / tujuan pengambil dan penyetel adalah untuk memungkinkan fungsi di luar objek untuk mengubah tata letak memori objek secara langsung. Kedengarannya seperti pintu terbuka untuk mengizinkan penyamun ...

Kasus Tepi

Ada dua situasi ketika seorang pengambil / pembuat keputusan masuk akal.

• Sebagian dari struktur data dalam objek dikelola oleh objek, tetapi tidak dikendalikan oleh objek.
• Antarmuka yang menggambarkan abstraksi tingkat tinggi dari struktur data di mana beberapa elemen diharapkan tidak dapat mengendalikan objek pelaksana.

Kontainer dan antarmuka wadah adalah contoh sempurna dari kedua situasi ini. Kontainer mengelola struktur data (daftar terkait, peta, pohon) secara internal tetapi dengan mudah mengendalikan elemen tertentu untuk semuanya. Antarmuka mengabstraksi hal ini dan mengabaikan implementasi sepenuhnya dan hanya menggambarkan harapan.

Sayangnya banyak implementasi yang salah dan mendefinisikan antarmuka objek semacam ini untuk memberikan akses langsung ke objek yang sebenarnya. Sesuatu seperti:

interface Container<T>
{
    typedef ...T... TRef; //<somehow make TRef to be a reference or pointer to the memory location of T
    TRef item(int index); 
}

Ini rusak Implementasi Container harus secara eksplisit menyerahkan kontrol internal mereka kepada siapa pun yang menggunakannya. Saya belum melihat bahasa dengan nilai yang bisa berubah-ubah di mana ini baik-baik saja (bahasa dengan semantik bernilai tidak berubah secara definisi baik dari perspektif korupsi data, tetapi tidak harus dari perspektif mata-mata data).

Anda dapat meningkatkan / memperbaiki getter / setter dengan hanya menggunakan copy-semantik, atau dengan menggunakan proxy:

interface Proxy<T>
{
     operator T(); //<returns a copy
     ... operator ->(); //<permits a function call to be forwarded to an element
     Proxy<T> operator=(T); //< permits the specific element to be replaced/assigned by another T.
}

interface Container<T>
{
     Proxy<T> item(int index);
     T item(int index); //<When T is a copy of the original value.
     void item(int index, T new_value); //<where new_value is used to replace the old value
}

Bisa dibilang fungsi jahat masih bisa memainkan kekacauan di sini (dengan upaya yang cukup banyak hal yang mungkin), tetapi copy-semantik dan / atau proksi mengurangi kemungkinan sejumlah kesalahan.

• meluap
• underflow
• interaksi dengan sub elemen adalah tipe-checked / type-checkable (dalam bahasa tipe hilang ini adalah anugerah)
• Elemen aktual mungkin atau mungkin bukan memori.

Setter Pribadi / Setter

Ini adalah benteng getter dan setter terakhir yang bekerja pada tipe ini secara langsung. Sebenarnya saya bahkan tidak akan memanggil getter dan setter ini selain accessor dan manipulator.

Dalam konteks ini kadang-kadang memanipulasi bagian tertentu dari struktur data selalu / hampir selalu / umumnya membutuhkan pembukuan khusus untuk terjadi. Katakanlah ketika Anda memperbarui root dari pohon cache yang perlu disingkirkan harus dibersihkan, atau ketika Anda mengakses elemen data eksternal, kunci perlu diperoleh / dirilis. Dalam kasus ini masuk akal untuk menerapkan prinsip KERING dan membagi tindakan tersebut bersama-sama.

Dalam konteks pribadi, masih mungkin bagi fungsi-fungsi lain dalam keluarga untuk mengesampingkan 'getter dan setter' ini dan memanipulasi struktur data. Karena itu mengapa saya menganggap mereka lebih sebagai penentu dan manipulator. Anda dapat mengakses data secara langsung, atau mengandalkan anggota keluarga lain untuk mendapatkan bagian itu dengan benar.

Getters / Setters yang dilindungi

Dalam konteks yang dilindungi, tidak jauh berbeda dengan konteks publik. Fungsi asing yang mungkin ingin akses ke struktur data. Jadi tidak, jika mereka ada mereka beroperasi seperti pengambil / setter publik.

Dari pengalaman C ++, Setter / getter sangat membantu untuk 2 skenario:

1. jika Anda harus melakukan pemeriksaan kewarasan sebelum memberikan nilai kepada anggota seperti string atau array.
2. ini bisa membantu ketika fungsi yang berlebihan diperlukan seperti nilai int ke tugas bool ketika -1 (atau nilai negatif) salah. dan sebaliknya untuk pengambil.

Terlepas dari itu, keamanan adalah titik yang valid tetapi kepentingannya terbatas pada sangat sedikit aplikasi pengembangan seperti modul terkait akses masuk atau db. Mengapa repot-repot membuat kode tambahan ketika hanya sedikit orang yang menggunakan modul Anda?