Saya cukup sering menjumpai pengembang yang belum mendengar tentang prinsip-prinsip SOLID (kami
membicarakannya secara terperinci di sini . - Terjemahan.) Atau pemrograman berorientasi objek (OOP), atau dengar, tetapi tidak menggunakannya dalam praktik. Artikel ini menjelaskan manfaat prinsip OOP yang membantu pengembang dalam pekerjaan sehari-harinya. Beberapa dari mereka terkenal, yang lain tidak terlalu baik, sehingga artikel ini akan bermanfaat bagi pemula dan programmer berpengalaman.
Kami mengingatkan Anda: untuk semua pembaca "Habr" - diskon 10.000 rubel saat mendaftar untuk kursus Skillbox apa pun menggunakan kode promo "Habr".
Rekomendasi Skillbox: Kursus Pendidikan Online Pengembang Java .
KERING (Jangan Ulangi Diri Sendiri)
Prinsip yang cukup sederhana, intinya jelas dari judul: "Jangan ulangi." Untuk programmer, ini berarti kebutuhan untuk menghindari kode duplikat, serta kemampuan untuk menggunakan abstraksi dalam pekerjaan.
Jika kode memiliki dua bagian berulang, mereka harus digabungkan menjadi satu metode. Jika nilai hard-coded digunakan lebih dari sekali, ada baiknya mengubahnya menjadi konstanta publik.
Ini diperlukan untuk menyederhanakan kode dan membuat dukungannya lebih mudah, yang merupakan tugas utama OOP. Menggabungkan serikat pekerja juga tidak sepadan, karena kode yang sama tidak akan lolos verifikasi dengan OrderId dan SSN.
Enkapsulasi perubahan
Produk perangkat lunak dari sebagian besar perusahaan terus berkembang. Jadi, Anda perlu membuat perubahan pada kode, itu harus didukung. Anda dapat menyederhanakan hidup Anda dengan enkapsulasi. Ini akan memungkinkan pengujian dan pemeliharaan yang lebih efisien dari basis kode yang ada.
Ini salah satu contohnya .
Jika Anda menulis dalam Java, maka
secara default tetapkan metode dan variabel pribadi .
Prinsip keterbukaan / kedekatan
Prinsip ini dapat dengan mudah diingat dengan membaca pernyataan berikut: "Entitas perangkat lunak (kelas, modul, fungsi, dll.) Harus terbuka untuk ekspansi, tetapi tertutup untuk perubahan." Dalam praktiknya, ini berarti mereka dapat memungkinkan Anda untuk mengubah perilaku mereka tanpa mengubah kode sumber.
Prinsip ini penting ketika perubahan pada kode sumber memerlukan revisi, pengujian unit, dan prosedur lainnya. Kode yang mematuhi prinsip keterbukaan / kedekatan tidak berubah selama ekspansi, jadi ada lebih sedikit masalah dengannya.
Berikut adalah contoh kode yang melanggar prinsip ini.
Jika Anda perlu mengubah sesuatu di dalamnya, itu akan memakan banyak waktu, karena Anda harus mengubah semua bagian kode yang memiliki koneksi dengan fragmen yang diinginkan.
Omong-omong, keterbukaan-keterbukaan adalah salah satu prinsip SOLID.
Prinsip Tanggung Jawab Tunggal (SRP)
Prinsip lain dari suite SOLID. Dia menyatakan bahwa "hanya ada satu alasan yang menyebabkan perubahan kelas." Kelas hanya memecahkan satu masalah. Mungkin ada beberapa metode, tetapi masing-masing digunakan hanya untuk memecahkan masalah umum. Semua metode dan properti hanya melayani ini.
Nilai dari prinsip ini adalah melemahkan koneksi antara komponen perangkat lunak individu dan kode. Jika Anda menambahkan lebih dari satu fungsionalitas ke kelas, ini memperkenalkan koneksi antara dua fungsi. Jadi, jika Anda mengubah salah satunya, ada peluang besar untuk merusak yang kedua, terkait dengan yang pertama. Dan ini berarti peningkatan siklus pengujian untuk mengidentifikasi semua masalah di muka.
Prinsip Ketergantungan Inversi (DIP)
Kode di atas adalah contoh di mana AppManager bergantung pada EventLogWriter, yang pada gilirannya terkait erat dengan AppManager. Jika Anda memerlukan cara lain untuk menampilkan pemberitahuan, baik itu push, SMS atau email, Anda perlu mengubah kelas AppManager.
Masalahnya dapat diselesaikan dengan menggunakan DIP. Jadi, alih-alih AppManager, kami meminta EventLogWriter, yang akan diperkenalkan menggunakan framework.
DIP memungkinkan Anda untuk dengan mudah mengganti modul individu dengan yang lain, mengubah modul ketergantungan. Ini memungkinkan untuk mengubah satu modul tanpa mempengaruhi sisanya.
Komposisi alih-alih warisan
Ada dua cara utama untuk menggunakan kembali kode - ini adalah warisan dan komposisi, dan masing-masing memiliki kelebihan dan kekurangan. Yang kedua biasanya disukai karena lebih fleksibel.
Komposisi memungkinkan Anda untuk mengubah perilaku kelas saat runtime dengan mengatur propertinya. Saat mengimplementasikan antarmuka, polimorfisme digunakan, yang memberikan implementasi yang lebih fleksibel.
Bahkan "Java Efektif" oleh Joshua Bloch menyarankan untuk memberikan preferensi pada komposisi daripada warisan.
Prinsip Pengganti Barbara Lisk (LSP)
Prinsip lain dari toolkit SOLID. Ini menyatakan bahwa subtipe harus diganti untuk supertype. Artinya, metode dan fungsi yang bekerja dengan superclass harus dapat bekerja dengan subkelasnya tanpa masalah.
LSP terhubung baik dengan prinsip tanggung jawab tunggal, dan dengan prinsip pembagian tanggung jawab. Jika kelas menyediakan lebih banyak fungsionalitas daripada subclass, maka yang terakhir tidak akan mendukung beberapa fungsi, melanggar prinsip ini.
Ini adalah bagian dari kode yang bertentangan dengan LSP.
Metode area (Rectangle r) menghitung luas Rectangle. Program akan macet setelah mengeksekusi Square, karena Square bukan Rectangle di sini. Menurut prinsip LSP, fungsi yang menggunakan referensi ke kelas dasar harus dapat menggunakan objek dari kelas turunan tanpa instruksi tambahan.
Prinsip ini, yang merupakan definisi spesifik dari subtipe, diusulkan oleh Barbara Liskov pada tahun 1987 pada sebuah konferensi di laporan utama berjudul "Abstraksi Data dan Hirarki" - maka namanya.
Prinsip Pemisahan Antar Muka (ISP)
Prinsip SOLID lainnya. Menurutnya, antarmuka yang tidak digunakan tidak boleh diimplementasikan. Mengikuti prinsip ini membantu sistem untuk tetap fleksibel dan cocok untuk refactoring ketika membuat perubahan pada logika kerja.
Paling sering situasi ini terjadi ketika antarmuka berisi beberapa fungsi sekaligus, dan klien hanya membutuhkan satu dari mereka.
Karena menulis antarmuka adalah tugas yang sulit, setelah selesai bekerja, mengubahnya tanpa merusak apa pun akan menjadi masalah.
Keuntungan dari prinsip ISP di Jawa adalah bahwa semua metode harus diimplementasikan terlebih dahulu, dan baru setelah itu mereka dapat digunakan oleh kelas. Oleh karena itu, prinsipnya memungkinkan untuk mengurangi jumlah metode.
Pemrograman untuk antarmuka, bukan implementasi
Semuanya di sini jelas dari namanya. Penerapan prinsip ini mengarah pada pembuatan kode fleksibel yang dapat bekerja dengan implementasi antarmuka baru.
Gunakan tipe antarmuka untuk variabel, tipe kembali, atau jenis argumen metode. Contohnya adalah penggunaan SuperClass, bukan SubClass.
Itu adalah:
Daftar angka = getNumbers ();Dan tidak:
Angka ArrayList = getNumbers ();Berikut ini adalah implementasi praktis dari apa yang dikatakan di atas.
Prinsip pendelegasian
Contoh umum adalah metode equals () dan hashCode () di Jawa. Ketika diminta untuk membandingkan dua objek, tindakan ini didelegasikan ke kelas yang sesuai, bukan klien.
Keuntungan dari prinsip ini adalah tidak adanya duplikasi kode dan perubahan perilaku yang relatif sederhana. Ini juga berlaku untuk delegasi acara.
Semua prinsip ini memungkinkan penulisan kode yang lebih fleksibel, indah, dan andal dengan konektivitas tinggi dan gigi rendah. Tentu saja, teorinya bagus, tetapi bagi pengembang untuk benar-benar mulai menggunakan pengetahuan yang diperoleh, praktik diperlukan. Langkah selanjutnya setelah menguasai prinsip-prinsip OOP dapat menjadi studi pola desain untuk memecahkan masalah umum pengembangan perangkat lunak.
Skillbox merekomendasikan: