Enam prinsip corak reka bentuk: 1. Prinsip tanggungjawab tunggal, terasnya adalah untuk mengawal kebutiran kelas, memisahkan objek, dan meningkatkan kesepaduan mereka; 2. Prinsip pembukaan dan penutup, yang boleh dicapai melalui "kekangan abstrak", perubahan enkapsulasi" untuk dicapai; 3. Prinsip penggantian Liskov terutamanya menerangkan beberapa prinsip mengenai warisan; 4. Prinsip penyongsangan kebergantungan mengurangkan gandingan antara klien dan modul pelaksanaan; 5. Prinsip pengasingan antara muka adalah untuk mengekang antara muka , Mengurangkan pergantungan kelas pada antara muka 6. Undang-undang Demeter memerlukan mengehadkan lebar dan kedalaman komunikasi antara entiti perisian.

Persekitaran pengendalian tutorial ini: sistem Windows 7, versi Java 8, komputer DELL G3.

Mengenai corak reka bentuk, saya telah membaca banyak buku corak reka bentuk suatu masa dahulu, beberapa daripadanya beberapa kali, dan saya sentiasa berharap bahawa saya boleh menggunakan corak reka bentuk ini semasa mengekod. Walau bagaimanapun, dalam pengekodan harian, singleton paling banyak digunakan, diikuti oleh pola pemerhati dan pembina (pembina), yang digunakan lebih kerap, dan yang lain jarang digunakan.

Sebab mengapa ia tidak digunakan ialah mereka masih tidak memahami idea corak reka bentuk dan tidak boleh menghubungkan corak reka bentuk ini dengan masalah yang dihadapi dalam pengekodan, jadi mereka tidak boleh menggunakan corak reka bentuk.

Malah, corak reka bentuk dicadangkan untuk menyelesaikan masalah biasa. Oleh itu, apabila anda berfikir tentang corak reka bentuk yang mana untuk diguna pakai, anda harus terlebih dahulu bertanya kepada diri sendiri apakah masalah semasa? Pilih corak reka bentuk yang sesuai berdasarkan masalah.

Selepas anda membiasakan diri dengan corak reka bentuk, anda akan mendapati bahawa terdapat hubungan inklusif antara beberapa corak reka bentuk, malah ia sangat serupa, tetapi corak reka bentuk yang berbeza menyelesaikan masalah yang berbeza.

Apabila kami mereka bentuk modul, kami boleh mempertimbangkannya dari perspektif berikut:

• Apakah hubungan antara modul ini dengan modul lain?

• Bahagian modul manakah yang malar, bahagian mana yang sentiasa berubah, dan bagaimana?

• Apakah hubungan antara kelas Mengapa kita perlu bergantung kepada mereka?

• Adakah anda mahu menambah antara muka? Apakah masalah yang wujud antara muka untuk diselesaikan?

Sudah tentu, artikel ini tidak mengajar anda cara menggunakan corak reka bentuk. Sebaliknya, ia menerangkan prinsip reka bentuk corak reka bentuk. Corak reka bentuk juga mengikut beberapa peraturan apabila ia direka bentuk.

Enam prinsip corak reka bentuk adalah seperti berikut:

• Prinsip tanggungjawab tunggal (kelas, kaedah, antara muka)

• Prinsip pembuka dan penutup (terbuka untuk sambungan, ditutup untuk pengubahsuaian)

• Prinsip penggantian Liskov (hubungan antara kelas asas dan subkelas )

• Prinsip Penyongsangan Kebergantungan (bergantung pada antara muka abstrak, bukan objek konkrit)

• Prinsip pengasingan antara muka (antara muka dibahagikan mengikut fungsi)

• Hukum Demeter (hubungan rapat antara kelas)

Terdapat kurungan di sebelah setiap prinsip reka bentuk untuk menerangkan atau menerangkan skop aplikasi. Setiap prinsip diterangkan secara terperinci di bawah.

Takrifan prinsip tanggungjawab tunggal (kelas, kaedah, antara muka)

Prinsip Tanggungjawab Tunggal (SRP) juga dipanggil prinsip fungsi tunggal. Tanggungjawab di sini merujuk kepada sebab perubahan kelas Prinsip tanggungjawab tunggal menetapkan bahawa kelas harus mempunyai dan hanya satu sebab untuk perubahannya, jika tidak kelas itu harus dipecahkan (Tidak boleh ada lebih daripada satu sebab untuk kelas. untuk berubah).

Prinsip ini menyatakan bahawa objek tidak boleh mengambil terlalu banyak tanggungjawab Jika objek mengambil terlalu banyak tanggungjawab, akan terdapat sekurang-kurangnya dua kelemahan berikut:

• Perubahan dalam satu tanggungjawab mungkin melemahkan atau menghalang keupayaan kelas ini untuk melaksanakan tanggungjawab lain

• Apabila pelanggan memerlukan tanggungjawab tertentu; objek, ia mestilah tidak Tidak termasuk semua tanggungjawab lain yang tidak perlu membawa kepada kod berlebihan atau kod terbuang.

Kelebihan Prinsip Tanggungjawab Tunggal

Teras Prinsip Tanggungjawab Tunggal adalah untuk mengawal kebutiran kelas. Jika anda mengikuti prinsip tanggungjawab tunggal, anda akan mendapat kelebihan berikut.

• Kurangkan kerumitan kelas. Jika kelas bertanggungjawab untuk hanya satu tanggungjawab, logiknya pasti lebih mudah berbanding jika ia bertanggungjawab untuk pelbagai tanggungjawab.

• Tingkatkan kebolehbacaan kelas. Kerumitan dikurangkan, dan kebolehbacaan dipertingkatkan secara semula jadi.

• Meningkatkan kebolehselenggaraan sistem. Kebolehbacaan yang dipertingkatkan secara semula jadi akan menjadikannya lebih mudah untuk diselenggara.

• Pengurangan risiko yang disebabkan oleh perubahan. Perubahan tidak dapat dielakkan Jika prinsip tanggungjawab tunggal dipatuhi dengan baik, apabila satu fungsi diubah suai, kesan ke atas fungsi lain boleh dikurangkan dengan ketara.

Bagaimana untuk melaksanakan prinsip tanggungjawab tunggal

Prinsip tanggungjawab tunggal adalah yang paling mudah tetapi paling sukar untuk menerapkan Prinsip ini memerlukan pereka bentuk untuk menemui dan memisahkan tanggungjawab yang berbeza bagi sesebuah kelas, dan kemudian merangkumnya ke dalam kelas atau modul yang berbeza. Pelbagai tanggungjawab kelas penemuan memerlukan pereka bentuk mempunyai keupayaan analisis dan reka bentuk yang kukuh serta pengalaman pemfaktoran semula yang berkaitan.

Contoh

public interface UserService {
    
    public void login(String username, String password);
    public void register(String email, String username, String password);
    public void logError(String msg);
    public void sendEmail(String email);
    
}

這段代碼很顯然存在很大的問題，UserService 既要負責用戶的注冊和登錄，還要負責日志的記錄和郵件的發(fā)送，并且后者的行為明顯區(qū)別于前者。<br/>

假設我要修改發(fā)送郵件的邏輯就得修改這個類，這時候 qa 還得回歸登錄注冊邏輯，這樣明顯不合理。

Jadi kita perlu lakukan Split, mengikut fungsi tertentu, ia boleh dibahagikan seperti berikut:

UserService: hanya bertanggungjawab untuk log masuk dan pendaftaran

public interface UserService {

    public void login(String username, String password);
    public void register(String email, String username, String password);

}

LogService: 只負責日志<br/>

public interface LogService {
    public void logError(String msg);

}

EmailService: Hanya bertanggungjawab untuk menghantar e-mel

public interface EmailService {
    public void sendEmail(String email);

}

這時候，咱們再去回顧前面提到的優(yōu)點，就能深深體會了。

Di sini kita hanya bercakap tentang antara muka Sebenarnya, ia adalah sama untuk kelas, malah kaedahnya adalah sama.

Untuk kelas, berdasarkan nama kelas, pastikan semua kaedah yang disediakan tergolong dalam kelas ini.

Untuk kaedah, jangan hantar kejadian objek yang tidak berkaitan sebagai parameter. Jika anda mendapati bahawa kaedah bergantung pada objek yang tidak berkaitan, mungkin terdapat masalah dengan pelaksanaan kaedah tersebut.

Sebagai contoh, selepas memuat turun imej dalam android dan memaparkannya dalam imageView, saya menyediakan kaedah berikut:

loadImage(String url, ImageView view) {
// 下載圖片，展示圖片
}

Untuk kaedah loadImage, url parameter ialah ok, tetapi Parameter ImageView tidak munasabah. Kerana dua operasi dilakukan di sini, memuat turun gambar dan memaparkan gambar. Kaedah ini harus dibahagikan kepada:

// 下載圖片 
loadImage(String url) {

}
// 顯示圖片
displayImage(String url, ImageView view) {

// 調(diào)用 getBitmap (url)  獲取圖片
// 獲取圖片后將其設置到 view 中。

}

// 根據(jù) url 獲取圖片， 
getBitmap(String url) {

}

supaya keseluruhan logiknya jelas. Jika anda perlu mengubah suai logik muat turun kemudian, ia tidak akan menjejaskan logik paparan. Sudah tentu, sebenarnya terdapat satu lagi soalan: adakah kedua-dua kaedah ini perlu diletakkan dalam kelas?

Prinsip pembukaan dan penutup

Cara melaksanakan prinsip pembukaan dan penutup: Prinsip pembukaan dan penutup boleh direalisasikan melalui "kekangan abstrak dan perubahan enkapsulasi" , iaitu melalui antara muka atau kelas Abstrak mentakrifkan lapisan abstraksi yang agak stabil untuk entiti perisian dan merangkum faktor pembolehubah yang sama dalam kelas pelaksanaan konkrit yang sama.

Oleh kerana abstraksi mempunyai fleksibiliti yang baik dan kebolehsuaian yang luas, selagi abstraksi adalah munasabah, kestabilan seni bina perisian pada asasnya boleh dikekalkan. Butiran yang tidak menentu dalam perisian boleh dilanjutkan daripada kelas pelaksanaan yang diperoleh daripada abstraksi Apabila perisian perlu diubah, anda hanya perlu memperoleh semula kelas pelaksanaan mengikut keperluan untuk melanjutkannya.

Contoh

// 矩形
public class Rectangle {

    public double getWidth() {
        return width;
    }
    
    public double getHeight() {
        return height;
    }

}

需要計算矩形的面積

// 面積計算器
public class AreaCalculator {

    public double area(Rectangle shape){
        return shape.getWidth() * shape.getHeight();
    }
}

Andaikan pada masa ini , Terdapat satu lagi kelas bulatan

// 圓形
public class Circular {

    public double getRadius(){
        return radius;
    }
}

同樣也需要計算他的面積，這時候就會變成下面這樣子：

public class AreaCalculator {

    public double area(Object shape){
        if(shape instanceof Rectangle) {
            Rectangle rectangle = (Rectangle) shape;
            return rectangle.getWidth() * rectangle.getHeight();
        } else if (shape instanceof Circular) {
            Circular circular = (Circular) shape;
            return circular.getRadius() * circular.getRadius() * Math.PI;
        } else {
            throw new RuntimeException("There is no such type.");
        }
    }
}

Dengan perubahan ini selesai, tiada masalah sama sekali . Walau bagaimanapun, dalam persekitaran pengeluaran sebenar, keadaan lebih rumit dan perubahan melibatkan banyak bahagian, yang mungkin menjejaskan seluruh badan. Selain itu, beberapa fungsi yang ditulis dan diuji sebelum ini perlu diuji semula, malah menyebabkan beberapa fungsi menjadi tidak tersedia.

Versi yang dipertingkatkan, menjadikan logik awam mengira kawasan menjadi antara muka:

public interface Shape {

    public double getArea();

}
 
public class Rectangle implements Shape{

    public double getWidth() {
        return width;
    }

    public double getHeight() {
        return height;
    }

    public double getArea() {
        return getWidth() * getHeight();
    }
    
}

Dengan cara ini, apabila diperlukan Tukar, apabila kita perlu mengira luas bulatan, kita hanya perlu mencipta kelas bulatan dan melaksanakan antara muka Bentuk: <code class="java java">這樣，當需求變更，需要計算圓形面積的時候，我們只需創(chuàng)建一個圓形的類，并實現(xiàn) Shape 接口即可:<br/>

public class Circular implements Shape {

    public double getRadius(){
        return radius;
    }

    public double getArea() {
        return getRadius() * getRadius() * Math.PI;
    }
}

計算三角形面積、四邊形面積... 的時候，我們只需讓它們?nèi)崿F(xiàn) Shape 接口即可，無需修改源代碼。

Prinsip Penggantian Liskov

Prinsip Penggantian Liskov terutamanya menerangkan beberapa prinsip mengenai pewarisan, iaitu apabila ia harus digunakan Warisan, apabila tidak menggunakan warisan, dan prinsip di sebaliknya. Penggantian Liskov pada asalnya adalah asas untuk penggunaan semula warisan Ia mencerminkan hubungan antara kelas asas dan subkelas, menambah prinsip pembukaan dan penutup, dan mengawal langkah khusus untuk mencapai abstraksi.

Fungsi prinsip penggantian Liskov

Fungsi utama prinsip penggantian Liskov adalah seperti berikut.

• Prinsip penggantian Liskov ialah salah satu cara penting untuk merealisasikan prinsip pembukaan dan penutup.

• Ia mengatasi kelemahan kebolehgunaan semula yang lemah disebabkan oleh mengatasi kelas induk dalam warisan.

• Ia adalah jaminan ketepatan tindakan. Iaitu, lanjutan kelas tidak akan memperkenalkan ralat baru ke dalam sistem sedia ada, mengurangkan kemungkinan ralat kod.

• Tingkatkan keteguhan program, dan pada masa yang sama mencapai keserasian yang sangat baik apabila menukar, meningkatkan kebolehselenggaraan dan kebolehskalaan program, dan mengurangkan masa diperlukan untuk menukar keperluan yang diperkenalkan risiko.

Bagaimana untuk melaksanakan prinsip penggantian Liskov (warisan)

Dalam istilah awam, penggantian Liskov prinsip Iaitu: subkelas boleh memanjangkan fungsi kelas induk, tetapi mereka tidak boleh mengubah fungsi asal kelas induk. Dalam erti kata lain: apabila subkelas mewarisi kelas induk, cuba untuk tidak mengatasi kaedah kelas induk kecuali menambah kaedah baharu untuk melengkapkan fungsi baharu.

Berdasarkan pemahaman di atas, takrifan prinsip penggantian Liskov boleh diringkaskan seperti berikut:

• Sesuatu subkelas boleh melaksanakan kaedah abstrak induk kelas, tetapi tidak boleh mengatasi kelas induk Kaedah bukan abstrak kelas

• Subkelas boleh menambah kaedah unik mereka sendiri

• Apabila kaedah subkelas mengatasi kaedah kelas induk, prasyarat kaedah (iaitu parameter input kaedah) adalah lebih longgar daripada kaedah kelas induk

• Apabila kaedah subkelas melaksanakan kaedah kelas induk (menimpa/melebihi beban atau melaksanakan kaedah abstrak), postcondition kaedah (iaitu nilai output/pulangan bagi kaedah) adalah lebih ketat atau sama dengan kelas induk

Walaupun mudah untuk menulis fungsi baharu dengan mengatasi kaedah kelas induk, kebolehgunaan semula keseluruhan sistem warisan akan menjadi agak lemah, terutamanya apabila perbandingan polimorfik digunakan Selalunya, kebarangkalian ralat menjalankan program akan menjadi sangat tinggi.

Jika program melanggar prinsip penggantian Liskov, objek kelas yang diwarisi akan mempunyai ralat masa jalan di mana kelas asas muncul.

Kaedah pembetulan pada masa ini ialah: batalkan hubungan warisan asal dan reka bentuk semula hubungan antara mereka.

Bagi contoh prinsip penggantian Liskov, yang paling terkenal ialah "segi empat bukan segi empat tepat". Sudah tentu, terdapat banyak contoh yang serupa dalam kehidupan Sebagai contoh, penguin, burung unta dan kiwi diklasifikasikan sebagai burung dari perspektif biologi, tetapi dari hubungan warisan kelas, kerana mereka tidak boleh mewarisi keupayaan "burung" untuk terbang, jadi mereka tidak boleh ditakrifkan sebagai subkelas "burung". Begitu juga, kerana "ikan belon" tidak boleh berenang, ia tidak boleh ditakrifkan sebagai subkategori "ikan"; "meriam mainan" tidak boleh meletupkan musuh, jadi ia tidak boleh ditakrifkan sebagai subkategori "meriam", dsb.

Cara terbaik untuk segi empat sama dan segi empat tepat ialah menambah kelas induk yang lain, dan kelas induk ini mewarisi daripada kelas induk ini pada masa yang sama.

Penyongsangan Kebergantungan (Butiran Lukisan Wayar)

Prinsip penyongsangan kebergantungan ialah salah satu cara penting untuk merealisasikan prinsip pembukaan dan penutupan antara pelanggan dan modul pelaksanaan antara.

Oleh kerana dalam reka bentuk perisian, butiran boleh diubah, manakala lapisan pengabstrakan agak stabil, jadi seni bina yang dibina pada pengabstrakan adalah lebih stabil daripada seni bina yang dibina pada butiran . Abstrak di sini merujuk kepada antara muka atau kelas abstrak, dan butiran merujuk kepada kelas pelaksanaan tertentu.

Tujuan menggunakan antara muka atau kelas abstrak adalah untuk merumuskan spesifikasi dan kontrak tanpa melibatkan sebarang operasi khusus, dan menyerahkan tugas untuk menunjukkan butiran kepada kelas pelaksanaannya.

Fungsi prinsip kebergantungan dan penyongsangan

Fungsi utama prinsip penyongsangan kebergantungan adalah seperti berikut.

• Prinsip penyongsangan kebergantungan boleh mengurangkan gandingan antara kelas.

• Prinsip penyongsangan kebergantungan boleh meningkatkan kestabilan sistem.

• Prinsip penyongsangan kebergantungan boleh mengurangkan risiko yang disebabkan oleh pembangunan selari.

• Prinsip penyongsangan kebergantungan boleh meningkatkan kebolehbacaan dan kebolehselenggaraan kod.

依賴倒置原則的實現(xiàn)方法

依賴倒置原則的目的是通過要面向接口的編程來降低類間的耦合性，所以我們在實際編程中只要遵循以下4點，就能在項目中滿足這個規(guī)則。

• 每個類盡量提供接口或抽象類，或者兩者都具備。

• 變量的聲明類型盡量是接口或者是抽象類。

• 任何類都不應該從具體類派生。

• 使用繼承時盡量遵循里氏替換原則。

依賴倒置原則在“顧客購物程序”中的應用。

分析：本程序反映了 “顧客類”與“商店類”的關(guān)系。商店類中有 sell() 方法，顧客類通過該方法購物以下代碼定義了顧客類通過韶關(guān)網(wǎng)店 ShaoguanShop 購物

class Customer {
    public void shopping(ShaoguanShop shop) {
        //購物
        System.out.println（shop.sell());
    }
}

但是，這種設計存在缺點，如果該顧客想從另外一家商店（如婺源網(wǎng)店 WuyuanShop）購物，就要將該顧客的代碼修改如下：

class Customer {
    public void shopping(WuyuanShop shop) {
        //購物
        System.out.println(shop.sell());
    }
}

顧客每更換一家商店，都要修改一次代碼，這明顯違背了開閉原則。

存在以上缺點的原因是：顧客類設計時同具體的商店類綁定了，這違背了依賴倒置原則。

解決方法是：定義“婺源網(wǎng)店”和“韶關(guān)網(wǎng)店”的共同接口 Shop，顧客類面向該接口編程，其代碼修改如下：

class Customer {
    public void shopping(Shop shop) {
        //購物
        System.out.println(shop.sell());
    }
}

class Customer {
    public void shopping(Shop shop) {
        //購物
        System.out.println(shop.sell());
    }
}

這樣，不管顧客類 Customer 訪問什么商店，或者增加新的商店，都不需要修改原有代碼了，其類如下圖所示：



程序代碼如下：

package principle;
public class DIPtest
{
    public static void main(String[] args)
    {
        Customer wang=new Customer();
        System.out.println("顧客購買以下商品："); 
        wang.shopping(new ShaoguanShop()); 
        wang.shopping(new WuyuanShop());
    }
}
//商店
interface Shop
{
    public String sell(); //賣
}
//韶關(guān)網(wǎng)店
class ShaoguanShop implements Shop
{
    public String sell()
    {
        return "韶關(guān)土特產(chǎn)：香菇、木耳……"; 
    } 
}
//婺源網(wǎng)店
class WuyuanShop implements Shop
{
    public String sell()
    {
        return "婺源土特產(chǎn)：綠茶、酒糟魚……"; 
    }
} 
//顧客
class Customer
{
    public void shopping(Shop shop)
    {
        //購物
        System.out.println(shop.sell()); 
    }
}

程序的運行結(jié)果如下：

顧客購買以下商品：
韶關(guān)土特產(chǎn)：香菇、木耳……
婺源土特產(chǎn)：綠茶、酒糟魚……

Prinsip Pengasingan Antara Muka (Antara Muka)

Prinsip Pengasingan Antara Muka (ISP) memerlukan pengaturcara untuk cuba membahagikan antara muka kembung kepada antara muka yang lebih kecil dan lebih spesifik, supaya antara muka hanya mengandungi kaedah yang diminati pelanggan.

Pada tahun 2002, Robert C. Martin mendefinisikan "Prinsip Pengasingan Antara Muka" sebagai: Pelanggan tidak boleh dipaksa untuk bergantung pada kaedah yang mereka tidak gunakan). Terdapat definisi lain bagi prinsip ini: Kebergantungan satu kelas kepada kelas lain harus bergantung pada antara muka terkecil yang mungkin.

Maksud dua takrifan di atas ialah: untuk mewujudkan antara muka khusus yang mereka perlukan untuk setiap kelas, dan bukannya cuba membina antara muka yang besar untuk semua kelas yang bergantung padanya untuk memanggil.

Prinsip pengasingan antara muka dan tanggungjawab tunggal kedua-duanya adalah untuk meningkatkan kesepaduan kelas dan mengurangkan gandingan antara mereka, merangkumi idea pengkapsulan, tetapi kedua-duanya berbeza:

• Prinsip tanggungjawab tunggal memfokuskan pada tanggungjawab, manakala prinsip pengasingan antara muka memfokuskan pada pengasingan kebergantungan antara muka.

• Prinsip tanggungjawab tunggal terutamanya mengekang kelas, yang menyasarkan pelaksanaan dan butiran program, prinsip pengasingan antara muka terutamanya mengekang antara muka, terutamanya menyasarkan pengabstrakan dan program; secara keseluruhan Pembinaan rangka kerja.

Kelebihan prinsip pengasingan antara muka

Prinsip pengasingan antara muka adalah untuk mengekang antara muka dan mengurangkan kelas -kebergantungan antara muka, mengikut prinsip pengasingan antara muka mempunyai lima kelebihan berikut.

• Mengurai antara muka kembung kepada berbilang antara muka berbutir kecil boleh menghalang penyebaran perubahan luaran dan meningkatkan fleksibiliti dan kebolehselenggaraan sistem.

• Pengasingan antara muka meningkatkan kesepaduan sistem, mengurangkan interaksi luaran dan mengurangkan gandingan sistem.

• Jika kebutiran antara muka ditakrifkan secara munasabah, kestabilan sistem boleh dijamin walau bagaimanapun, jika takrifan terlalu kecil, akan ada juga; banyak antara muka, yang akan menjadikan reka bentuk Kerumitan jika definisi terlalu besar, fleksibiliti akan dikurangkan, perkhidmatan tersuai tidak dapat disediakan, dan risiko yang tidak dijangka akan dibawa ke keseluruhan projek.

• Menggunakan berbilang antara muka khusus juga boleh mencerminkan hierarki objek, kerana takrifan antara muka keseluruhan boleh dicapai melalui pewarisan antara muka.

• boleh mengurangkan lebihan kod dalam kejuruteraan projek. Antara muka yang terlalu besar biasanya mengandungi banyak kaedah yang tidak digunakan Apabila melaksanakan antara muka ini, anda terpaksa mereka bentuk kod berlebihan.

Cara melaksanakan prinsip pengasingan antara muka

Apabila menggunakan prinsip pengasingan antara muka secara khusus, perkara berikut perlu dipatuhi Beberapa peraturan untuk diukur.

• Antara muka hendaklah sekecil mungkin, tetapi dalam had. Antara muka hanya menyediakan satu sub-modul atau logik perniagaan.

• Sesuaikan perkhidmatan untuk kelas yang bergantung pada antara muka. Hanya sediakan kaedah yang diperlukan oleh pemanggil dan sekat kaedah yang tidak diperlukan.

• Fahami persekitaran dan enggan mengikut membuta tuli. Setiap projek atau produk mempunyai faktor persekitaran yang dipilih Persekitaran yang berbeza mempunyai piawaian yang berbeza untuk pemisahan antara muka.

• Meningkatkan perpaduan dan mengurangkan interaksi luaran. Jadikan antara muka menggunakan kaedah paling sedikit untuk mencapai kebanyakan perkara.

Untuk pengasingan antara muka, anda masih boleh merujuk kepada contoh yang dinyatakan dalam tanggungjawab tunggal:

public interface UserService {
    
    public void login(String username, String password);
    public void register(String email, String username, String password);
    public void logError(String msg);
    public void sendEmail(String email);
    
}

這時候，應該就能理解拆分的好處了。

迪米特法則 (類與類之間的關(guān)系)

迪米特法則（Law of Demeter，LoD）又叫作最少知識原則（Least Knowledge Principle，LKP)，產(chǎn)生于 1987 年美國東北大學（Northeastern University）的一個名為迪米特（Demeter）的研究項目，由伊恩·荷蘭（Ian Holland）提出，被 UML 創(chuàng)始者之一的布奇（Booch）普及，后來又因為在經(jīng)典著作《程序員修煉之道》（The Pragmatic Programmer）提及而廣為人知。

迪米特法則的定義是：只與你的直接朋友交談，不跟“陌生人”說話（Talk only to your immediate friends and not to strangers）。其含義是：如果兩個軟件實體無須直接通信，那么就不應當發(fā)生直接的相互調(diào)用，可以通過第三方轉(zhuǎn)發(fā)該調(diào)用。其目的是降低類之間的耦合度，提高模塊的相對獨立性。

迪米特法則中的“朋友”是指：當前對象本身、當前對象的成員對象、當前對象所創(chuàng)建的對象、當前對象的方法參數(shù)等，這些對象同當前對象存在關(guān)聯(lián)、聚合或組合關(guān)系，可以直接訪問這些對象的方法。

迪米特法則的優(yōu)點

迪米特法則要求限制軟件實體之間通信的寬度和深度，正確使用迪米特法則將有以下兩個優(yōu)點。

• 降低了類之間的耦合度，提高了模塊的相對獨立性。

• 由于親合度降低，從而提高了類的可復用率和系統(tǒng)的擴展性。

但是，過度使用迪米特法則會使系統(tǒng)產(chǎn)生大量的中介類，從而增加系統(tǒng)的復雜性，使模塊之間的通信效率降低。所以，在釆用迪米特法則時需要反復權(quán)衡，確保高內(nèi)聚和低耦合的同時，保證系統(tǒng)的結(jié)構(gòu)清晰。

迪米特法則的實現(xiàn)方法

從迪米特法則的定義和特點可知，它強調(diào)以下兩點：

• 從依賴者的角度來說，只依賴應該依賴的對象。

• 從被依賴者的角度說，只暴露應該暴露的方法。

所以，在運用迪米特法則時要注意以下 6 點。

• 在類的劃分上，應該創(chuàng)建弱耦合的類。類與類之間的耦合越弱，就越有利于實現(xiàn)可復用的目標。

• 在類的結(jié)構(gòu)設計上，盡量降低類成員的訪問權(quán)限。

• 在類的設計上，優(yōu)先考慮將一個類設置成不變類。

• 在對其他類的引用上，將引用其他對象的次數(shù)降到最低。

• 不暴露類的屬性成員，而應該提供相應的訪問器（set 和 get 方法）。

• 謹慎使用序列化（Serializable）功能

明星與經(jīng)紀人的關(guān)系實例。

分析：明星由于全身心投入藝術(shù)，所以許多日常事務由經(jīng)紀人負責處理，如與粉絲的見面會，與媒體公司的業(yè)務洽淡等。這里的經(jīng)紀人是明星的朋友，而粉絲和媒體公司是陌生人，所以適合使用迪米特法則，其類圖如下圖所示。



代碼如下：

package principle;
public class LoDtest
{
    public static void main(String[] args)
    {
        Agent agent=new Agent();
        agent.setStar(new Star("林心如"));
        agent.setFans(new Fans("粉絲韓丞"));
        agent.setCompany(new Company("中國傳媒有限公司"));
        agent.meeting();
        agent.business();
    }
}
//經(jīng)紀人
class Agent
{
    private Star myStar;
    private Fans myFans;
    private Company myCompany;
    public void setStar(Star myStar)
    {
        this.myStar=myStar;
    }
    public void setFans(Fans myFans)
    {
        this.myFans=myFans;
    }
    public void setCompany(Company myCompany)
    {
        this.myCompany=myCompany;
    }
    public void meeting()
    {
        System.out.println(myFans.getName()+"與明星"+myStar.getName()+"見面了。");
    }
    public void business()
    {
        System.out.println(myCompany.getName()+"與明星"+myStar.getName()+"洽淡業(yè)務。");
    }
}
//明星
class Star
{
    private String name;
    Star(String name)
    {
        this.name=name;
    }
    public String getName()
    {
        return name;
    }
}
//粉絲
class Fans
{
    private String name;
    Fans(String name)
    {
        this.name=name;
    }
    public String getName()
    {
        return name;
    }
}
//媒體公司
class Company
{
    private String name;
    Company(String name)
    {
        this.name=name;
    }
    public String getName()
    {
        return name;
    }
}

程序的運行結(jié)果如下：

粉絲韓丞與明星林心如見面了。
中國傳媒有限公司與明星林心如洽淡業(yè)務。

?到此，設計模式的六大原則就講完了。

更多編程相關(guān)知識，請訪問：編程教學??！

Atas ialah kandungan terperinci Apakah enam prinsip corak reka bentuk?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!