设计模式之六大设计原则

最新推荐文章于 2022-10-22 10:55:36 发布

晓_晨

最新推荐文章于 2022-10-22 10:55:36 发布

阅读量1.2k

点赞数 3

分类专栏： JAVA设计模式 java设计模式文章标签：设计模式设计原则学习详解 design pattern

本文链接：https://blog.csdn.net/niunai112/article/details/79517903

版权

JAVA设计模式同时被 2 个专栏收录

24 篇文章 2 订阅

订阅专栏

java设计模式

24 篇文章 3 订阅

订阅专栏

版权声明：转载必须注明本文转自晓_晨的博客：http://blog.csdn.net/niunai112

这是我不知道第几次开始学习设计模式了，之前都是看一点就去忙其他事了，没有完整的时间来系统的学习设计模式，这个系列就记录一下我学习设计模式的过程。
第一篇我想先仔细学习下设计模式种的六个原则，不然会很难理解后面的设计模式为什么要那么来设计。

单一职责原则
英文名称是Single Responsibility Principle，简称SRP。定义为就一个类而言，应该仅有一个引起它变化的原因。简单来说，一个类中应该是一组相关性很高的函数、数据的封装。
这个原则的意思就是说一个类中功能不要太多，尽量一个类只完成一个功能。

public class DecorationFloor {
    public void decorationFloor(){
        System.out.println("购买材料A");
        System.out.println("用A材料铺地板");
    }

}

这个类中的购买材料和装修可以分开来，单独封装

public class BuyMaterial {
    String material;
    public BuyMaterial(String material){

        System.out.println("购买材料A");
        this.material = material;

    }
}

public class DecorationFloor {

    public void decorationFloor(String material){
        System.out.println("用" + material + "材料铺地板");
    }

    public static void main(String[] args) {
        BuyMaterial a = new BuyMaterial("A");
        new DecorationFloor().decorationFloor(a.material);
    }
}

里氏替换原则
英文全称是Liskov Substitution Principle，简称LSP。定义为所有引用基类的地方必须能透明地使用其子类的对象。
意思是一个用父类能实现功能的地方，用他的子类也可以完成功能。

public class Parent {
    public void say(){
        System.out.println("haha");
    }
}

public class Child extends Parent {
    @Override
    public void say() {
        System.out.println("xixi");
    }
}

public class UseCla {
    public void use(Parent p){
        p.say();
    }

    public static void main(String[] args) {
        UseCla useCla = new UseCla();
        useCla.use(new Parent());
        useCla.use(new Child());


    }
}

这个例子种useCla需要的类型是Parent，但是child也可以带入，但是他得到的结果不一样，假设useCla预期想要的结果是哈哈，但是子类重写后，他得到的实际结果是嘻嘻，就没有完成和他父类一样的结果。

依赖倒置原则
英文全称是Dependence Inversion Principle，简称DIP。定义为高层模块不应该依赖低层模块，二者都应该依赖其抽象；抽象不应该依赖细节；细节应该依赖抽象。
这个按字面很难理解，大概的意思是功能实现不能依赖于实体的类，应该依赖于抽象的接口，通过实现接口的方式来实现功能。


public interface DecorationFloor {

    public void decorationFloor(String material);

}

public interface BuyMaterial {

    void buyMaterial(String material);
}

然后类实现接口，实现方法，依赖于接口的好处就是，你可能刷墙有很多的方式，比如用大刷子刷，用小刷子刷，用专业的机器来刷等等，你都可以新建类来实现这个接口，买材料接口这个也是如此。

接口隔离原则
英文全称是InterfaceSegregation Principles，简称ISP。定义为客户端不应该依赖它不需要的接口，类间的依赖关系应该建立在最小的接口上。
每个接口所要的实现的功能应该要最小化，只要定义出自己仅需的接口函数就行。

public interface Animal{

    public void eat();
    public void sleep();
    public void fly();

}

对于一个动物来说，他一定要吃饭，睡觉，但是不一定能飞，所以这个的接口不是最小化的接口。

public interface Animal{

    public void eat();
    public void sleep();


}
public interface Bird extends Animal{
    public void fly();
}

我们可以定义另一个抽象的接口来继承，然后在里面添加飞行的接口。

迪米特原则
英文全称为Law of Demeter，简称LOD。定义为一个对象应该对其他对象保持最少的了解。
这个原则很简单，就是要很好的封装你的类，仅向外界暴露你提供的服务，内部的细节不需要让外面的对象知道。

public class DecorationFloor {

    public void floorRoom(String material){//铺地板
        System.out.println("铺地板");
    }
    public void cleanFloor(){//清洗地板
        System.out.println("清洗地板");
    }
    public void decorationFloor(String material){
        cleanFloor();
        floorRoom(material);
    }


}

对于外面的对象来说，外面对象知道里面有floorRoom，cleanFloor，decorationFloor函数。但实际上他根本不需要知道floorRoom，cleanFloor细节，只需要直接调用decorationFloor就行了，所以该类可以修改为

public class DecorationFloor {

    private void floorRoom(String material){//铺地板
        System.out.println("铺地板");
    }
    private void cleanFloor(){//清洗地板
        System.out.println("清洗地板");
    }
    public void decorationFloor(String material){
        cleanFloor();
        floorRoom(material);
    }


}