设计模式之工厂模式

工厂模式

把产品的创建过程封装起来。

一、简单工厂模式

一个工厂可以创建一类产品

由一个工厂对象决定创建出哪一种产品的实例；

// 课程
public interface Course {
    public void study();
}
//实现类1：Java课程
public class JavaCourse implements Course{
    public void study() {
        System.out.println("Java语言课程内容");
    }
}
//实现类2：c语言课程
public class CCourse implements Course{
    public void study() {
        System.out.println("C语言课程内容");
    }
}
//实现类3：python
public class PythonCourse implements Course {
    public void study() {
        System.out.println("Python课程内容");
    }
}

没有工厂，如果说创建过程很复杂，参数很多，使用起来会很麻烦；

//用户测试类
public class SimpleFactoryTest {
    public static void main(String[] args) {
        // 如果想要一个Java课程
        Course course = new JavaCourse();
        course.study();
    }
}

可以把创建过程封在工厂里。

// 课程工厂
public class CourseFactory {
    public Course create(Class clzz) {
        // 创建出来所需的实际类
        // 根据参数 创建合适的类
        try {
            return (Course) clzz.newInstance();
        } catch (Exception e) {
            return null;
        }
    }
}

//用户测试类
public class SimpleFactoryTest {
    public static void main(String[] args) {
        // 如果想要一个Java课程
        CourseFactory factory = new CourseFactory();
        Course course = factory.create(JavaCourse.class);
        course.study();
    }
}

使用场景：产品创建逻辑非常复杂，但是产品比较少，创建逻辑比较稳定（不易修改），客户端可以直接调用工厂创建产品，只需传参，无需关心创建对象的逻辑；

实例1：日期时间的处理
Calender.getInstance();
// 根据时区和语言创建不同的对象

实例2：根据不同的name创建不同的日志对象
loggerFactor.getlogger();

缺点：多个职责放在一个类里，新增产品就要修改逻辑，违背了开闭原则。
不易于扩展过于复杂的产品结构；

工厂方法模式

定义一个创建对象的接口，但让实现这个接口的类来决定实例化哪个类，让类的实例化推迟到子类进行。

// 工厂接口类
public Interface CourseFactory{
	Course create();
}

//实现类工厂1： Java课程工厂类
public class JavaCourseFactory implements CourseFactory {
    public Course create() {
        return new JavaCourse();
    }
}

// 实现类工厂2：C语言课程工厂类
public class CCourseFactory implements CourseFactory {
    public Course create() {
        return new CCourse();
    }
}

// 实现类工厂3：Python课程工厂类
public class PythonCourseFactory implements CourseFactory {
    public Course create() {
        return new PythonCourse();
    }
}

一个产品对应一个工厂，满足了单一职责，开闭原则；

public class FactoryMethodTest {
    public static void main(String[] args) {
        CourseFactory factory = new JavaCourseFactory();
        Course course = factory.create();
        course.study();
    }
}

案例：loggerFactory.getlogger()的IloggerFactory等等等

使用场景：
1、创建产品对象需要大量重复代码（可以在抽象类里把公共逻辑放进去处理）
2、客户端不依赖于产品类的实例，而依赖于工厂；
3、符合开闭原则，有新的产品，只需要新增工厂类即可，提高了系统的可维护性。
工厂方法模式的缺点：
类的个数增加，代码结构复杂；
增加了系统的抽象性和理解难度；

抽象工厂模式

提供一个创建一系列相关或相互依赖对象的接口，无需制定他们具体的类。

产品族和产品等级结构；
一个品牌下有多个产品；
一个产品有多个品牌；

// 笔记
public interface Note{
}
//实现类1：Java笔记
public class JavaNote implements Note {
    public void write() {
    }
}
//实现类2：c笔记
public class CNote implements Note {
    public void write() {
    }
}
//实现类3：python笔记
public class PythonNote implements Note {
    public void write() {
    }
}

// 
public interface Factory {
    // 创建课程
    Course createCourse();

    // 创建笔记
    Note createNote();
}

// java 工厂：可以创建JAVA课程 创建Java笔记
public class JavaFactory implements Factory {
    public Course createCourse() {
        return new JavaCourse();
    }

    public Note createNote() {
        return new JavaNote();
    }
}

//Python 工厂：可以创建Python 课程 创建Python 笔记
public class PythonFactory implements Factory {
    public Course createCourse() {
        return new PythonCourse();
    }

    public Note createNote() {
        return new PythonNote();
    }

}

一个工厂可以创建不同的产品，同一个产品可以被多个工厂创建；

public class Test {
    public static void main(String[] args) {
        Factory factory = new JavaFactory();
        factory.createCourse().study();
        factory.createNote();
    }
}

适应场景：产品链比较复杂，产品升级较慢
不符合开闭原则，增加一类产品可能会导致要改所有的类；

缺点：不符合开闭原则，增加一类产品可能会导致要改所有的类；
优点：1、客户端（应用层）无需知道产品如何被创建、被实现等细节；
2、强调一系列相关的产品对象在一起使用创建对象时候，需要大量重复的代码；
3、提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不需要依赖于具 体实现，工厂能实现什么样的产品在顶层类里就已经设定好了；
案例：Spring中的AbstractFactory