JAVA学习-设计模式（上）

一、软件设计原则

1. 开闭原则：对拓展开发，对修改关闭，使用最广。
2. 单一职责原则：一个类，一个接口，一个方法，只做一件事情。
3. 依赖倒置原则：通过抽象实施，使各个类，各个模块之间，相互不影响，实现松耦合，实现面向抽象编程，面向接口编程。
4. 接口隔离原则：接口面向抽象编程的基础上，接口设计纯洁，单一，只做某类事情，不依赖不需要接口。
5. 迪尔特法则：最少知道原则，一个类对其所依赖的类，对其知道的越少越好，代码可读性提升。
6. 里氏替换原则：子类可拓展父类功能，不可改变父类原有功能。杜绝继承泛滥。
7. 合成复用原则：尽量使用对象组合，聚合，尽量不使用继承来达到代码目的。

二、设计模式总览

优点：代码优雅，便于重构。

工厂型模式、创建型模式

三、简单工厂模式

1、历史由来

原始社会自给自足-->农耕社会小作坊-->工厂流水线生产-->现代产品链代工厂

2、简单工厂的定义

简单工厂模式（Simple Factory Pattern）是指由一个工厂对象决定创建出哪一种产品类的实例；

属于创建型模式，但他不属于GOF 23种设计模式。

3、工厂模式代码案例

1）背景：

• ICouse作为课程接口，使用抽象方法record
• JavaCouse、PythonCouse作为ICouse的实现类，分别实现不同的业务场景的record抽象方法；
• 使用工厂模式类CourseFactory，创建课程，实现Create方法，传入不同课程，返回不同的实现类；
• 测试类Test，无需关系具体实现，只需调用抽离出的工厂类CourseFactory的create方法，传输不同的课程即可，无需关系具体业务的实现，利用工厂类帮其处理具体的业务实现。
• 具体的类图关系如下：

2）具体代码实现：

package pattern.factory.simplefactory;

public interface ICouse {
    void record();
}

package pattern.factory.simplefactory;

public class CourseFactory {

    public ICouse create(String name){
        if("java".equals(name)){
            return new JavaCouse();
        }else if ("python".equals(name)){
            return new PythonCouse();
        }else {
            return null;
        }
    }
}

package pattern.factory.simplefactory;

public class JavaCouse implements ICouse{

    @Override
    public void record() {
        System.out.printf("录制Java课程！");
    }
}

package pattern.factory.simplefactory;

public class PythonCouse implements ICouse{
    @Override
    public void record() {
        System.out.printf("录制Python课程！");
    }
}

package pattern.factory.simplefactory;

public class Test {
    public static void main(String[] args) {
        ICouse couse = new CourseFactory().create("java");
        couse.record();
    }
}

 3)代码事项过程中的优化

• 工厂类的优化

使用反射机制实现

入参使用泛型，集成ICouse类控制clazz的规范性，避免clazz.newInstance()强制转换为ICouse。

package pattern.factory.simplefactory;

public class CourseFactory {

    public ICouse create(Class<? extends ICouse> clazz){
        /**
         * v1.0
         */
//        if("java".equals(name)){
//            return new JavaCouse();
//        }else if ("python".equals(name)){
//            return new PythonCouse();
//        }else {
//            return null;
//        }
        /**
         * v2.0通过使用反射，完成工厂
         */
//        try{
//            if(null==className||"".equals(className)){
//                return (ICouse) Class.forName(className).newInstance();
//            }
//        }catch (Exception e){
//            e.printStackTrace();
//        }
        try{
            if(null!=clazz){
                return clazz.newInstance();
            }
        }catch (Exception e){
            e.printStackTrace();
        }


        return null;
    }
}

• 测试类的同步修改，入参使用类。

package pattern.factory.simplefactory;

public class Test {
    public static void main(String[] args) {
        ICouse couse = new CourseFactory().create(PythonCouse.class);
        couse.record();
    }
}

4、简单工厂模式适用场景

• 工厂类负责创建的对象比较少；
• 客户端只需要传入工厂类的参数，对于如何创建对象的逻辑不需要关心；

5、优点

只需要传入一个正确的参数，就可以获取你需要的对象，无需知道其创建的细节；

6、缺点

工厂类的职责相对过重，增加新的产品需要修改工厂类的判断逻辑，违背开闭原则；

不易于扩展过于复杂的产品结构