设计模式--六大原则

「爱情、让人受尽委屈。」 2021-12-19 03:53 324阅读 0赞

参考内容：[https://www.cnblogs.com/liebrother/p/10941660.html][https_www.cnblogs.com_liebrother_p_10941660.html]  
一、 单一职责原则

package day01.designPattern.srp;
    
    /**
     * @description 单一职责原则适用的范围有接口、方法、类。
     * 按大家的说法，接口和方法必须保证单一职责，类就不必保证，只要符合业务就行。
     * @author ZerlindaLi create at 2019/6/11 16:13
     * @version 1.0.0
     * @description Shopping
     */
    public class SrpTest{
        public static void main(String[] args) {
    
        }
    }
    interface Shopping {
        void doShopping();
    }
    
    interface PourGarbage {
        void doPourGarbage();
    }
    
    interface WashingUp{
        void doWashingUp();
    }
    
    class XiaoMing implements PourGarbage {
    
        @Override
        public void doPourGarbage() {
            System.out.println(("pourGarbage..."));
        }
    }
    
    class XiaoHong implements Shopping, WashingUp {
    
        @Override
        public void doShopping() {
            System.out.println(("Shopping..."));
        }
    
        @Override
        public void doWashingUp() {
            System.out.println(("doWashingUp..."));
        }
    }

二、开闭原则

package day01.designPattern.ocp;
    
    import java.math.BigDecimal;
    
    /**
     * 开闭原则：当应用的需求改变时，在不修改软件实体的源代码或者二进制代码的前提下，可以扩展模块的功能，使其满足新的需求。
     * 对扩展开放，对修改封闭
     * 抽象约束，封装变化，派生类
     * @author ZerlindaLi create at 2019/5/28 17:09
     * @version 1.0.0
     * @description OcpTest
     */
    public class OcpTest {
        public static void main(String[] args) {
            Hospital h = new Hospital();
            Medicine m = new Medicine("阿司匹林",new BigDecimal(12.34));
            OneLevelSocialSecurityPatient chf = new OneLevelSocialSecurityPatient("程海锋");
            h.sellMedicine(chf, m);
    
            TwoLevelSocialSecurityPatient zl  = new TwoLevelSocialSecurityPatient("郑龙");
            h.sellMedicine(zl, m);
    
            ThreeLevelSocialSecurityPatient zc  = new ThreeLevelSocialSecurityPatient("张超");
            h.sellMedicine(zc, m);
        }
    
    }
    
    class Medicine {
        private String name;
        private BigDecimal price;
    
        public Medicine(String name, BigDecimal price){
            this.name = name;
            this.price = price;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public BigDecimal getPrice() {
            return price;
        }
    
        public void setPrice(BigDecimal price) {
            this.price = price;
        }
    }
    
    class Hospital {
        public void sellMedicine(IPatient patient, Medicine medicine){
            BigDecimal money = patient.pay(medicine);
            System.out.println(patient.getName() + "花了" + money.setScale(2, BigDecimal.ROUND_UP) + "块钱买了药：" + medicine.getName());
        }
    }
    
    interface IPatient {
        String getName();
        BigDecimal pay(Medicine medicine);
    }
    
    /**
     * 一档社保
     */
    class OneLevelSocialSecurityPatient implements IPatient {
        private String name;
    
        public OneLevelSocialSecurityPatient(String name) {
            this.name = name;
        }
    
        @Override
        public String getName() {
            return this.name;
        }
    
        @Override
        public BigDecimal pay(Medicine medicine) {
            return medicine.getPrice().multiply(new BigDecimal(0.7));
        }
    }
    
    /**
     * 二挡社保
     */
    class TwoLevelSocialSecurityPatient implements IPatient {
        private String name;
    
        public TwoLevelSocialSecurityPatient(String name) {
            this.name = name;
        }
    
        @Override
        public String getName() {
            return this.name;
        }
    
        @Override
        public BigDecimal pay(Medicine medicine) {
            return medicine.getPrice().multiply(new BigDecimal(0.8));
        }
    }
    
    /**
     * 三挡社保
     */
    class ThreeLevelSocialSecurityPatient implements IPatient {
        private String name;
    
        public ThreeLevelSocialSecurityPatient(String name) {
            this.name = name;
        }
    
        @Override
        public String getName() {
            return this.name;
        }
    
        @Override
        public BigDecimal pay(Medicine medicine) {
            return medicine.getPrice().multiply(new BigDecimal(0.9));
        }
    }

三、里氏替换原则

package day01.designPattern.lsp;
    
    /**
     * 里氏替换原则：
     * 如果对每一个类型为S的对象o1，都有类型为T的对象o2，使得以T定义的所有程序P在所有的对象o1都代换成o2时，程序P的行为没有发生变化，
     * 那么类型S是类型T的子类型。
     * 所有引用基类的地方必须能透明地使用其子类的对象。
     *
     * 子类继承父类，且不重写父类的方法。
     * @author ZerlindaLi create at 2019/5/28 11:41
     * @version 1.0.0
     * @description LSPTest
     */
    public class LspTest {
        public static void main(String[] args) {
            Father f = new Father();
            Son1 s1 = new Son1();
            Son2 s2 = new Son2();
    
            f.makeMechine();
            s1.makeMechine();
            s2.makeMechine();
            s2.makeWeapon();
        }
    }
    
    class Father{
        public void makeMechine(){
            System.out.println("制造冷兵器");
        }
    }
    
    class Son1 extends Father {
        @Override
        public void makeMechine(){
            System.out.println("制造核武器");
        }
    }
    
    class Son2 extends Father {
        public void makeWeapon(){
            System.out.println("制造核武器");
        }
    }

四、迪米特法则

package day01.designPattern.lod;
    
    /**
     * @author ZerlindaLi create at 2019/7/2 17:12
     * @version 1.0.0
     * @description 迪米特法则
     * Each unit should have only limited knowledge about other units: only units "closely" related to the current unit. (每个单元对于其他的单元只能拥有有限的知识：只是与当前单元紧密联系的单元)
     * Each unit should only talk to its friends; don't talk to strangers. (每个单元只能和它的朋友交谈：不能和陌生单元交谈)
     * Only talk to your immediate friends. (只和自己直接的朋友交谈)
     * (来自维基百科)
     *
     * 平常在零碎的时间里，喜欢看一些书籍，一般都是电子书，现在我们看书的操作是这样的：唤醒手机，打开阅读软件，选择书籍，然后阅读。总共 3 个步骤，涉及了 3 样东西：手机、软件、书籍。同学们用代码实现这个过程。
     */
    public class LODRightTest {
    
        public static void main(String[] args) {
            Phone phone = new Phone();
            phone.readBook();
        }
    }
    
    class Book {
    
        private String title;
    
        public Book(String title) {
            this.title = title;
        }
    
        public String getTitle() {
            return title;
        }
    
        public void setTitle(String title) {
            this.title = title;
        }
    }
    
    class App {
        private Book book = new Book("设计模式");
    
        public void read(){
            System.out.println(book.getTitle());
        }
    }
    
    class Phone {
        private App app = new App();
    
        public void readBook() {
            app.read();
        }
    }

五、接口隔离原则

package day01.designPattern.isp;
    
    /**
     * @description 接口隔离原则
     * 1. Clients should not be forced to depend upon interfaces that they don't use.（客户端不应该依赖它不需要的接口。）
     * 2. The dependency of one class to another one should depend on the smallest possible interface.（类间的依赖关系应该建立在最小的接口上。）
     * @author ZerlindaLi create at 2019/6/11 16:44
     * @version 1.0.0
     * @description IspTest
     */
    public class IspTest {
        public static void main(String[] args) {
            // 测试代码
            LiAunt liAunt = new LiAunt();
            WangMather wangMather = new WangMather();
            ChenUncle chenUncle = new ChenUncle();
            HuangSister huangSister = new HuangSister();
            liAunt.hairBraiding();
            wangMather.getDressed();
            chenUncle.packingIntoTheBox();
            huangSister.makeTag();
        }
    }
    
    interface Hair {
        void hairBraiding();
    }
    
    interface Dress {
        void getDressed();
    }
    
    interface Box {
        void packingIntoTheBox();
    }
    
    interface Tag {
        void makeTag();
    }
    
    class LiAunt implements Hair {
    
        @Override
        public void hairBraiding() {
            System.out.println("李大姨给布娃娃扎辫子");
        }
    }
    
    class WangMather implements Dress {
    
        @Override
        public void getDressed() {
            System.out.println("王大妈给布娃娃穿衣服");
        }
    }
    
    class ChenUncle implements Box {
    
        @Override
        public void packingIntoTheBox() {
            System.out.println("陈大叔给布娃娃装箱");
        }
    }
    
    class HuangSister implements Tag {
    
        @Override
        public void makeTag() {
            System.out.println("黄大姐给箱子打标签");
        }
    }

六、依赖倒置原则

package day01.designPattern.dip;
    
    /**
     * @author ZerlindaLi create at 2019/5/29 15:42
     * @version 1.0.0
     * @description 依赖倒置原则
     *
     * High level modules should not depend upon low level modules.Both should depend upon abstractions. 高层模块不应该依赖低层模块，两者都应该依赖其抽象（模块间的依赖通过抽象发生，实现类之间不发生直接的依赖关系，其依赖关系是通过接口或抽象类产生的）
     * Abstractions should not depend upon details. 抽象不应该依赖细节（接口或抽象类不依赖于实现类）
     * Details should depend upon abstractions. 细节应该依赖抽象（实现类依赖接口或抽象类）
     */
    abstract class Boss {
        private Staff staff;
    
        public Boss(Staff staff) {
            this.staff = staff;
        }
    
        /**
         * 提供支持
         */
        abstract void support();
    
        /**
         * 需求帮助
         * @param boss
         */
        abstract void askHelp(Boss boss);
    
        public void setStaff(Staff staff) {
            this.staff = staff;
        }
    
        /**
         * 招募员工
         * @return
         */
        public Staff getStaff() {
            return staff;
        }
    }

[https_www.cnblogs.com_liebrother_p_10941660.html]: https://www.cnblogs.com/liebrother/p/10941660.html