工厂模式实战

设计模式最重要的是解耦，（面向抽象编程，面向接口编程）
简单工厂是产品的工厂，工厂方法是工厂的工厂，抽象工厂是复杂产品的工厂
简单工厂模式：1、工厂生产一类具有共同特征的产品，2、工厂制定标准 3、通过标识告诉工厂生产什么产品
适合创建对象种类较少的场景（Calender），缺点：不易于扩展复杂的产品结构，新增产品需要修改工厂代码，违背了开闭原则

工厂方法模式：起的是一个调度的作用，用户只需要关心产品对应的工厂（比简单工厂模式多一层工厂（指定产品的工厂）），不需要关心产品的细节，加入新的产品工厂的实现逻辑不需要改变，符合开闭原则
主要是解决产品扩展的问题
使用场景：创建对象需要大量的重复代码
缺点：类的数量容易过多，增加了代码的复杂性

抽象工厂：是指提供一个创建一系列相关或者相互依赖对象的接口，无需指定他们具体的类
（抽象工厂不符合开闭原则，适用于产品族相对比较稳定的场景）
缺点：规定了所有可能被创建的产品集合，产品族中扩展新的产品困难，需要修改抽象工厂的接口，增加了系统的抽象性和理解难度。
优点：1、完成遵循单一原则，具体产品在应用层代码隔离，无须关心创建细节，2、将一个系列的产品族统一到一起创建
简单工厂模式：

public interface ICourse {
    void record();
}

public class JavaCourse implements ICourse {
    @Override
    public void record() {
        System.out.println("java 课程");
    }
}

public class PythonCourse implements ICourse {
    @Override
    public void record() {
        System.out.println("python 课程");
    }
}

public class CourseFactory {

    public ICourse create(Class<? extends ICourse> clazz) throws Exception {

//        if (name.equals("java")){
//            return new JavaCourse();
//        } else if(name.equals("pythone")){
//            return new PythonCourse();
//        } else {
//             throw new Exception("没有这个课程");
//        }

        //（代码优化）课程名有可能传错（例如：Java），使用反射
//        if(!StringUtils.isEmpty(className)){
//            return (ICourse)Class.forName(className).newInstance();
//        }
//
//        return null;

        //（继续优化），全类名笔记复杂，输入没有限制，直接传入类Class
        if (clazz != null){
            //（继续优化）这里需要强转，可以继续优化，强制要求传进来的clazz是ICourse的子类,使用泛型
            //return (ICourse) clazz.newInstance();
            return clazz.newInstance();
        }
        return null;
    }
}

public class SimpleFactoryTest {

    public static void main(String[] args) {
        ICourse iCourse = null;
        try {
            //iCourse = new CourseFactory().create("com.example.designpattern.simpleFactory.PythonCourse");
            iCourse = new CourseFactory().create(JavaCourse.class);
        } catch (Exception e) {
            e.printStackTrace();
        }
        iCourse.record();
    }
}

抽象工厂模式：

public interface ICourse {
    void record();
}

public interface INote {
    void edit();
}

public interface IVideo {
    void record();
}

/**
 * 每一个产品创建前创建后没有公共的逻辑可以使用接口，有公共逻辑的话使用抽象类
 */
public abstract class CourseFactory {

    public void init(){
        System.out.println("初始化基础数据");
    }

    protected abstract  INote createNote();

    protected abstract  IVideo createVideo();

}

public class JavaCourseFactory extends CourseFactory {
    @Override
    protected INote createNote() {
        super.init();
        return new JavaNote();
    }

    @Override
    protected IVideo createVideo() {
        super.init();
        return new JavaVideo();
    }
}

public class PythonCourseFactory extends CourseFactory {
    @Override
    protected INote createNote() {
        super.init();
        return new PythonNote();
    }

    @Override
    protected IVideo createVideo() {
        super.init();
        return new PythonVideo();
    }
}

public class JavaCourse implements ICourse {
    @Override
    public void record() {
        System.out.println("java 课程");
    }
}

public class PythonCourse implements ICourse {
    @Override
    public void record() {
        System.out.println("python 课程");
    }
}

public class JavaNote implements INote {
    @Override
    public void edit() {
        System.out.println("修改java笔记");
    }
}

public class JavaVideo implements IVideo {
    @Override
    public void record() {
        System.out.println("记录java课程");
    }
}

public class PythonNote implements INote {
    @Override
    public void edit() {
        System.out.println("修改python笔记");
    }
}

public class PythonVideo implements IVideo {
    @Override
    public void record() {
        System.out.println("记录python课程");
    }
}

public class AbstractFactoryTest {
    public static void main(String[] args) {
        CourseFactory factory = new JavaCourseFactory();
        factory.createNote().edit();
        factory.createVideo().record();
    }
}