设计模式（1）类图、设计原则与工厂

UML类图

如图所示，可分为三组

实现： 虚线+三角形
继承： 实线+三角形

依赖： 虚线+箭头
关联： 实线+箭头

组合： 实心菱形+实线+三角形
聚合： 空心菱形+实线+三角形

设计原则

1. 开闭原则：对修改关闭，对扩展开放
2. 依赖倒置原则：软件系统的设计，应该是依赖接口，而不是具体的实现类
3. 接口隔离原则：客户端接口应该按功能需求依赖多个不同的，而不是一个大而全的接口
4. 迪米特法则：即最少知道原则，一个类应该尽量少的依赖其他类
5. 里氏替换原则：在父类可以使用的地方，使用子类替换，系统执行效果不变
6. 单一职责原则：一个类应该只有一个引起它变化的原因

SOLID原则

单一职责原则（SRP）、开闭原则（OCP）、里氏代换原则（LSP）、接口隔离原则（SIP）、依赖倒置原则（DIP）

设计模式之工厂

1. 简单工厂模式

定义：

提供一个创建实例对象的功能，而无须关系具体的实现。被创建的类型可以使接口、抽象类或者具体的类。

特点：

解决如何去实例化对象的问题。到底要实例化谁，将来会不会增加实例化对象，将这些容易变化的地方，用单独的一个类来做这个创建实例的过程。

疑问

问：单独写一个类来创建实例和客户端直接new 只是创建位置变了，这有什么区别？
答：
客户端直接new：①客户端需要知道具体的实现类，但客户端其实并不关心是谁实现的；②如果有些实现并不想让客户端知道呢
使用工厂：工厂和实现类与接口是属于一个组件的，对外暴露的是工厂和接口；

 OperationFacory：
 public class OperationFacory {
    /**
     * @param operationType 运算类型
     * @return 实际运算类
     */
    public static Operation createOperation(String operationType){
        switch (operationType){
            case Operation.ADD:
                return new AddOperation();
            case Operation.SUB:
                return new SubOperation();
            default:
                throw new RuntimeException("暂不支持");
        }
    }
}
Operation ：
public interface Operation {
    //    +
    String ADD = "ADD";
    //    -
    String SUB = "SUB";

    double getResult(double d1, double d2);
}	
AddOperation ：
public class AddOperation implements Operation {
    @Override
    public double getResult(double d1, double d2) {
        return d1 + d2;
    }
}
SubOperation ：
public class SubOperation implements Operation {
    @Override
    public double getResult(double d1, double d2) {
        return d1 - d2;
    }
} 	
Demo ：
public class FactoryDemo {
    public static void main(String[] args) {
        double d1 = 1 ;
        double d2 = 5 ;
        Operation operation = OperationFacory.createOperation(Operation.ADD);
        double result = operation.getResult(d1, d2);
        System.out.println("结果："+result);

    }
}

2. 工厂方法模式

1. 解决了简单工厂模式中每次新增算法都需要修改factory的代码（开闭原则）的缺点；
2. 工厂方法模式是对简单工厂的进一步封装
3. 工厂方法模式是定义一个用于创建对象的接口，让子类去决定实例化哪一个类

OperationFacory 修改:
public abstract class OperationFacory {
    public abstract Operation createOperation();
}
SubOperationFactory ：
public class SubOperationFactory extends OperationFacory{
    public Operation createOperation(){
        return new SubOperation();
    }
}
AddOperationFactory ： 不再需要在这里判断使用哪个算法类，将判断逻辑延迟到客户端的具体实现
public class AddOperationFactory extends OperationFacory{
    public Operation createOperation(){
        return new AddOperation();
    }
}
FactoryDemo : 在这里当我们需要改变算法时，依然需要修改代码，但是范围缩小的一行代码 
将AddOperationFactory() --> SubOperationFactory() 
public class FactoryDemo {
    public static void main(String[] args) {
        double d1 = 1 ;
        double d2 = 5 ;
        OperationFacory facory = new AddOperationFactory();
        Operation operation =facory.createOperation();
        double result = operation.getResult(d1, d2);
        System.out.println("结果："+result);

    }
}

3. 抽象工厂模式

提供一个创建一系列相关或相互依赖对象的接口，而无须指定具体的类。