Prinsip Pengasingan Antara Muka di Jawa

1. Pengenalan

Dalam tutorial ini, kita akan membincangkan Prinsip Segregasi Antara Muka, salah satu prinsip SOLID. Mewakili "I" dalam "SOLID", pemisahan antara muka bermaksud bahawa kita harus memecahkan antara muka yang lebih besar menjadi yang lebih kecil.

Oleh itu memastikan bahawa kelas pelaksana tidak perlu melaksanakan kaedah yang tidak diingini.

2. Prinsip Pengasingan Antara Muka

Prinsip ini pertama kali didefinisikan oleh Robert C. Martin sebagai: " Pelanggan tidak boleh dipaksa untuk bergantung pada antara muka yang tidak mereka gunakan ".

Tujuan prinsip ini adalah untuk mengurangkan kesan sampingan penggunaan antara muka yang lebih besar dengan memecahkan antara muka aplikasi menjadi yang lebih kecil . Ia serupa dengan Prinsip Tanggungjawab Tunggal, di mana setiap kelas atau antara muka melayani satu tujuan.

Reka bentuk aplikasi yang tepat dan abstraksi yang betul adalah kunci di sebalik Prinsip Pengasingan Antara Muka. Walaupun memerlukan lebih banyak masa dan usaha dalam fasa reka bentuk aplikasi dan mungkin meningkatkan kerumitan kod, pada akhirnya, kami mendapatkan kod yang fleksibel.

Kami akan melihat beberapa contoh di bahagian kemudian di mana kami melanggar prinsip, dan kemudian kami akan menyelesaikan masalah dengan menerapkan prinsip dengan betul.

3. Contoh Antaramuka dan Pelaksanaan

Mari kita perhatikan keadaan di mana kita mempunyai antara muka Pembayaran yang digunakan oleh BankPayment pelaksanaan :

public interface Payment { void initiatePayments(); Object status(); List getPayments(); }

Dan pelaksanaannya:

public class BankPayment implements Payment { @Override public void initiatePayments() { // ... } @Override public Object status() { // ... } @Override public List getPayments() { // ... } }

Untuk kesederhanaan, mari kita abaikan pelaksanaan perniagaan sebenar kaedah ini.

Ini sangat jelas - setakat ini, BankPayment kelas pelaksana memerlukan semua kaedah dalam antara muka Pembayaran . Oleh itu, ia tidak melanggar prinsip.

4. Mencemarkan Antara Muka

Sekarang, seiring dengan berjalannya waktu, dan lebih banyak ciri masuk, ada keperluan untuk menambahkan perkhidmatan LoanPayment . Perkhidmatan ini juga jenis Pembayaran tetapi mempunyai beberapa operasi lagi.

Untuk mengembangkan ciri baru ini, kami akan menambahkan kaedah baru ke antara muka Pembayaran :

public interface Payment { // original methods ... void intiateLoanSettlement(); void initiateRePayment(); }

Seterusnya, kita akan melaksanakan pelaksanaan LoanPayment :

public class LoanPayment implements Payment { @Override public void initiatePayments() { throw new UnsupportedOperationException("This is not a bank payment"); } @Override public Object status() { // ... } @Override public List getPayments() { // ... } @Override public void intiateLoanSettlement() { // ... } @Override public void initiateRePayment() { // ... } }

Sekarang, kerana antara muka Pembayaran telah berubah dan lebih banyak kaedah ditambahkan, semua kelas pelaksana sekarang harus menerapkan kaedah baru. Masalahnya adalah, menerapkannya tidak diinginkan dan boleh menyebabkan banyak kesan sampingan. Di sini, kelas pelaksanaan LoanPayment harus melaksanakan inisiatePayments () tanpa memerlukan keperluan sebenarnya untuk ini. Oleh itu, prinsip itu dilanggar.

Jadi, apa yang berlaku pada kelas BankPayment kami :

public class BankPayment implements Payment { @Override public void initiatePayments() { // ... } @Override public Object status() { // ... } @Override public List getPayments() { // ... } @Override public void intiateLoanSettlement() { throw new UnsupportedOperationException("This is not a loan payment"); } @Override public void initiateRePayment() { throw new UnsupportedOperationException("This is not a loan payment"); } }

Perhatikan bahawa pelaksanaan BankPayment kini telah menerapkan kaedah baru. Dan kerana ia tidak memerlukannya dan tidak mempunyai logik untuk mereka, ia hanya membuang UnsupportedOperationException . Di sinilah kita mula melanggar prinsip.

Di bahagian seterusnya, kita akan melihat bagaimana kita dapat menyelesaikan masalah ini.

5. Mengaplikasi Prinsip

Pada bahagian terakhir, kami sengaja mencemarkan antara muka dan melanggar prinsip. Di bahagian ini, kita akan melihat cara menambahkan ciri baru untuk pembayaran pinjaman tanpa melanggar prinsip.

Mari pecahkan antara muka untuk setiap jenis pembayaran. Keadaan semasa:

Perhatikan dalam rajah kelas, dan merujuk pada antara muka di bahagian sebelumnya, bahawa kaedah () dan getPayments () diperlukan dalam kedua-dua pelaksanaan. Sebaliknya, inisiatPayments () hanya diperlukan di BankPayment , dan kaedah inisiateLoanSettlement () dan inisiateRePayment () hanya untuk LoanPayment .

Dengan cara yang disusun, mari pecahkan antara muka dan terapkan Prinsip Pengasingan Antara Muka. Oleh itu, kita sekarang mempunyai antara muka yang sama:

public interface Payment { Object status(); List getPayments(); }

Dan dua lagi antara muka untuk dua jenis pembayaran:

public interface Bank extends Payment { void initiatePayments(); }
public interface Loan extends Payment { void intiateLoanSettlement(); void initiateRePayment(); }

Dan pelaksanaan masing-masing, bermula dengan BankPayment :

public class BankPayment implements Bank { @Override public void initiatePayments() { // ... } @Override public Object status() { // ... } @Override public List getPayments() { // ... } }

Dan akhirnya, pelaksanaan LoanPayment kami yang disemak semula :

public class LoanPayment implements Loan { @Override public void intiateLoanSettlement() { // ... } @Override public void initiateRePayment() { // ... } @Override public Object status() { // ... } @Override public List getPayments() { // ... } }

Sekarang, mari kita semak rajah kelas baru:

Seperti yang kita lihat, antara muka tidak melanggar prinsip. Pelaksanaannya tidak perlu menyediakan kaedah kosong. Ini menjaga kodnya bersih dan mengurangkan kemungkinan bug.

6. Kesimpulannya

Dalam tutorial ini, kami melihat senario sederhana, di mana kami mula-mula menyimpang dari mengikuti Prinsip Segregasi Antara Muka dan melihat masalah yang disebabkan oleh penyimpangan ini. Kemudian kami menunjukkan cara menerapkan prinsip dengan betul untuk mengelakkan masalah ini.

Sekiranya kita berhadapan dengan antarmuka lama yang tercemar yang tidak dapat kita ubah, corak penyesuai dapat berguna.

Prinsip Segregasi Antara Muka adalah konsep penting semasa merancang dan mengembangkan aplikasi. Mematuhi prinsip ini membantu mengelakkan antara muka yang kembung dengan pelbagai tanggungjawab. Ini akhirnya membantu kita untuk mengikuti Prinsip Tanggungjawab Tunggal juga.

Seperti biasa, kodnya tersedia di GitHub.