java设计模式之6大设计原则day01

ゞ浴缸里的玫瑰 2022-06-02 00:39 128阅读 0赞

# 一、 单一职责原则 #

## 1.1 ##

单一职责原则的英文名称是Single Responsibility Principle，简称是**SRP**

## 1.2 ##

There should never be more than one reason for a class to change

## 1.3 单一原则好处 ##

1.  类的复杂性降低，实现什么职责都有清晰明确的定义
2.  可读性提高，复杂性降低，那当然可读性提高了
3.  可维护性提高，可读性提高，那当然更容易维护
4.  变更引起的风险降低，变更是必不可少的，如果接口的单一职责做得好，一个接口修  
    改只对相应的实现类有影响，对其他的接口无影响，这对系统的扩展性、维护性都有非常大的帮助。

## 1.4 注意 ##

单一职责原则提出了一个编写程序的标准，用“职责”或“变化原因”来衡量接口或  
类设计得是否优良，但是“职责”和“变化原因”都是不可度量的，因项目而异，因环境而异

## 1.5 This is sometimes hard to see ##

# 二 、里氏替换原则 #

## 2.1 继承 ##

### 2.1.1 继承带来的好处 ###

1.  代码共享，减少创建类的工作量，每个子类都拥有父类的方法和属性；
2.  提高代码的重用性；
3.  子类可以形似父类，但又异于父类
4.  提高代码的可扩展性
5.  提高产品或项目的开放性

### 2.1.2 继承的缺点 ###

1.  继承是侵入性的。只要继承，就必须拥有父类的所有属性和方法
2.  降低代码的灵活性
3.  增强了耦合性

### 2.1.3 ###

Java使用extends关键字来实现继承，它采用了单一继承的规则

## 2.2 什么是里氏替换原则 ##

1.  ：If for each object o1 of type S there is an object o2 of  
    type T such that for all programs P defined in terms of T,the behavior of P is unchanged when o1 is substituted for o2 then S is a subtype of T.（如果对每一个类型为S的对象o1，都有类型为T的对象o2，使得以T定义的所有程序P在所有的对象o1都代换成o2时，程序P的行为没有发生变化，那么类型S是类型T的子类型。）
2.  ：Functions that use pointers or references to base classes must be able to use objects of derived classes without knowing it.（所有引用基类的地方必须能透明地使用其子类的对象。）
3.  通俗点讲，只要父类能出现的地方子类就可以出现，而且替换为子类也不会产生任何错误或异常，使用者可能根本就不需要知道是父类还是子类。但是，反过来就不行了，有子类出现的地方，父类未必就能适应。

## 2.3 里氏替换原则含义 ##

### 2.3.1 ###

1.  子类必须完全实现父类的方法  
    如果子类不能完整地实现父类的方法，或者父类的某些方法在子类中已经发生“畸变”，则建议断开父子继承关系，采用依赖、聚集、组合等关系代替继承
2.  子类可以有自己的个性  
    向下转型（downcast）是不安全的，从里氏替换原则来看，就是有子类出现的地方父类未必就可以出现，会在运行期抛出**`java.lang.ClassCastException`**异常
3.  覆盖或实现父类的方法时输入参数可以被放大  
    Design by Contract（契约设计）：先定义接口：方法名、参数、返回值，指定双方开发协议，然后再各自实现。 子类的参数的范围应该大于父类的参数范围。比如下面代码所示：

/**
    *Father类源代码
    */
    public class Father {
        
    public Collection doSomething(HashMap map){
            System.out.println("父类被执行...");
            return map.values();
        }
    }
    
    /**
    *子类源代码
    */
    public class Son extends Father {
        
        //放大输入参数类型
        public Collection doSomething(Map map){
            System.out.println("子类被执行...");
            return map.values();
        }
    }
    
    /**
    *这里使用父类  结果是 父类被执行...
    */
    public class Client {
        
    public static void invoker(){
            //父类存在的地方，子类就应该能够存在
            Father f = new Father();
            HashMap map = new HashMap();
            f.doSomething(map);
        }
        public static void main(String[] args) {
            invoker();
        }
    }
    
    /**
    *这里使用子类 结果是 父类被执行...
    */
    public class Client {
        
    public static void invoker(){
        //父类存在的地方，子类就应该能够存在
            Son f =new Son();
            HashMap map = new HashMap();
            f.doSomething(map);
        }
        public static void main(String[] args) {
            invoker();
        }
    }

这里子类和父类方法名相同，但是不是覆写（Override）父类的方法 。如果这里加入@Override 会报错，因为方法名虽然相同，但是参数不同，就不是覆写，这里是**重载（Overload ）** ， 这个例子 父类方法的输入参数是HashMap类型，子类的输入参数是Map类型，也就是说子类的输入参数类型的范围扩大了，子类代替父类传递到调用者中，子类的方法永远都不会被执行。

如果相反，父类的范围比子类大的话 。那么我们就会发生业务逻辑混乱。例子如下：

/**
    *父类的前置条件较大
    */
    public class Father {
        
        public Collection doSomething(Map map){
            System.out.println("父类被执行...");
            return map.values();
        }
    }
    
    /**
    *子类的前置条件较小
    */
    public class Son extends Father {
        
        //缩小输入参数范围
        public Collection doSomething(HashMap map){
            System.out.println("子类被执行...");
            return map.values();
        }
    }
    
    /**
    *输出结果为 父类被执行... 
    */
    public class Client {
        
        public static void invoker(){
            //有父类的地方就有子类
            Father f= new Father();
            HashMap map = new HashMap();
            f.doSomething(map);
        }
        public static void main(String[] args) {
            invoker();
        }
    }
    
    /**
    *采用子类代替父类执行后  结果为 子类被执行...
    */
    public class Client {
        
        public static void invoker(){
            //有父类的地方就有子类
            Son f =new Son();
            HashMap map = new HashMap();
            f.doSomething(map);
        }
        public static void main(String[] args) {
            invoker();
        }
    }

子类在没有覆写父类的方法的前提下，子类方法被执行了。

### 2.3.2 总结 ###

子类中方法的前置条件必须与超类中被覆写的方法的前置条件相同或者更宽松

## 2.4 覆写或实现父类的方法时输出结果可以被缩小 ##

### 2.4.1 理解 ###

父类的一个方法的返回值是一个类型T，子类的相同方法（重载或覆写）的返回值为S，那么里氏替换原则就要求S必须小于等于T，也就是说，要么S和T是同一个类型，要么S是T的子类

### 2.4.2 为什么要这样？ ###

1.  如果是覆写，父类和子类的同名方法的输入参数是完全相同的，两个方法的范围值S小于等于T ， 这是覆写的要求。
2.  如果是重载，则要求输入参数类型或者数量不同，在里氏替换原则要求下，就是子类的输入参数宽于或等于父类的输入参数，也就是说我们写的这个方法是不会被调用的。这里需要理解2.3 。

## 2.5 总结 ##

在项目中，采用里氏替换原则时，**尽量避免子类的“个性”**，一旦子类有“个性”，这个子类和父类之间的关系就很难调和了，把子类当做父类使用，子类的“个性”被抹杀——委屈了点；把子类单独作为一个业务来使用，则会让代码间的耦合关系变得扑朔迷离——缺乏类替换的标准。