工厂模式总共分为3种，1.简单工厂模式(Simple Factory Pattern) 2.工厂方法(Factory Method Pattern) 3.抽象工厂模式(Abstract Factory Pattern)，这篇文章会展示3种不同的工厂模式的差异和写法。
定义- 定义：定义一个创建对象接口
但让视线这个接口的类来决定实例化哪个类
工厂方法让类的实例化推迟到子类中进行 - 类型：创建型
- 创建对象需要大量重复代码
- 客户端(应用层)不依赖于产品类实例如何被创建、实现等细节
- 一个类通过其子类来制指定创建哪个对象
- 用户只需要关系产品对应的工厂，无需关心创建细节
- 加入新产品符合开闭原则，提高可扩展性
- 类的个数容易过多，增加复杂度
- 增加了系统的抽象性和理解难度
- Product(产品)
- Product角色属于框架房，是一个抽象类，是对创建类的一个具体抽象。
- ConcreteProduct(实际的产品)
- ConcreteCreator角色属于具体的实际加工方，它是实际工厂创建的实际产品。
- ConcreteCreator(实际的创建者)
- ConcreteCreator角色属于实际加工方，它负责生产实际的产品。
- Product(产品)
- Product角色属于框架房，是一个抽象类，是对创建类的一个具体抽象。
- Creator(创建者)
- Creator角色属于框架房，它是负责生成Product角色的抽象类，但具体的处理是由子类ConcreteCreator角色决定。
- ConcreteProduct(实际的产品)
- ConcreteCreator角色属于具体的实际加工方，它是实际工厂创建的实际产品。
- ConcreteCreator(实际的创建者)
- ConcreteCreator角色属于实际加工方，它负责生产实际的产品。
- AbstractProduct(抽象产品)
- AbstractProduct角色负责定义AbstractFactory角色所生成的抽象零件和产品接口。
- AbstractFactory(抽象工厂)
- AbstractFactory角色负责定义用于生成抽象产品的接口。
- ConcreteProduct(实际产品)
- ConcreteProduct角色负责实现AbstractProduct角色的接口。
- ConcreteFactory(实际工厂)
- ConcreteFactory角色负责实现AbstractFactory角色的接口。
第一步，写一个Book接口，对应角色中Product
public interface Book {
void read();
}
第二步，写Book的实现类JavaBook，对应角色中ConcreteProduct
public class GoBook implements Book{
@Override
public void read() {
System.out.println("写一本Go从入门到精通");
}
}
第三步，再写一个Book的实现类PythonBook
public class GoBook implements Book{
@Override
public void read() {
System.out.println("写一本Go从入门到精通");
}
}
第四步，写简单工厂类
public class BookFactory {
private final String javaBook = "java";
private final String goBook = "go";
public Book createBook(String name) {
if (javaBook.equalsIgnoreCase(name)) {
return new JavaBook();
}else if (goBook.equalsIgnoreCase(name)){
return new GoBook();
}else {
return null;
}
}
}
最后，写简单工厂测试类
public class SimpleFactoryTest {
public static void main(String[] args) {
BookFactory bookFactory = new BookFactory();
Book javaBook = bookFactory.createBook("java");
javaBook.read();
}
}
执行简单工厂测试结果
简单工厂写法一在增加Book的时候，每次都需要根据产品的增加修改代码逻辑，不符合开闭原则，因此可以使用反射来优化，优化代码前三步都是相同，知识在工厂方法实现方式上不同，我们直接跳到第四步工厂方法的实现
public class BookFactory {
public Book createBook(String className) {
try {
if (className != null && className.length() > 0) {
return (Book) Class.forName(className).newInstance();
}
} catch (InstantiationException | IllegalAccessException | ClassNotFoundException e) {
e.printStackTrace();
}
return null;
}
}
第五步，简单工厂写法二测试实现类相同
public class SimpleFactoryTest {
public static void main(String[] args) {
BookFactory bookFactory = new BookFactory();
Book javaBook = bookFactory.createBook(JavaBook.class.getName());
javaBook.read();
}
}
可以看到简单工厂写法二执行结果和写法一相同，但写法二符合开闭原则。
3. 工厂方法工厂方法模式的写法中前三步与简单工厂模式中相同，这里就不重复赘述了，那我们从第四步开始写。
第四步，声明一个BookFactory接口，就是角色中的Creator
public interface BookFactory {
Book create();
}
第五步，实现一个JavaBookFacotory，也就是角色中的ConcreteCreator
public class JavaBookFactory implements BookFactory {
@Override
public Book create() {
return new JavaBook();
}
}
第六步，再实现一个GoBookFactory
public class GoBookFactory implements BookFactory {
@Override
public Book create() {
return new GoBook();
}
}
第七步，完成工厂方法测试类
public class FactoryMethodTest {
public static void main(String[] args) {
BookFactory javaBookFactory = new JavaBookFactory();
Book javaBook = javaBookFactory.create();
javaBook.read();
System.out.println("n"+"==========我是分割线========="+"n");
BookFactory goBookFactory = new GoBookFactory();
Book goBook = goBookFactory.create();
goBook.read();
}
}
举个例子，我们读一本书，会将学习到的知识记录成笔记，但是我们的笔记可能包含好几个部分，比如书上的笔记(BookNote)，笔记本上记录的笔记(Note)以及电脑中的学习笔记(ENote)。
第一步，先创建BookNote,Note和ENote接口或抽象类，在类图中是AbstractProduct角色。
public interface ENote {
void typing();
}
public interface BookNote {
void mark();
}
public interface Note {
void write();
}
第二步，分别创建三者实现类，在类图中是ConcreteProduct角色。
public class JavaBookNote implements BookNote{
@Override
public void mark() {
System.out.println("在Java从入门到精通上标注了一段话！");
}
}
public class JavaENote implements ENote{
@Override
public void typing() {
System.out.println("在电脑上敲了一段java笔记");
}
}
public class JavaNote implements Note {
@Override
public void write() {
System.out.println("在笔记本上写了一段java笔记");
}
}
public class GoBookNote implements BookNote{
@Override
public void mark() {
System.out.println("在Go从入门到精通上标注了一段话！");
}
}
public class GoENote implements ENote{
@Override
public void typing() {
System.out.println("在电脑上敲了一段go笔记");
}
}
public class GoNote implements Note {
@Override
public void write() {
System.out.println("在笔记本上写了一段Go笔记");
}
}
第三步，创建抽象工厂接口/抽象类，在类图中是AbstractFactory角色。
public interface NoteFactory {
BookNote createBookNote();
ENote createENote();
Note createNote();
}
第四步，创建抽象工厂实现类，在类图中是ConcreteFactory角色。
public class JavaNoteFactory implements NoteFactory{
@Override
public BookNote createBookNote() {
return new JavaBookNote();
}
@Override
public ENote createENote() {
return new JavaENote();
}
@Override
public Note createNote() {
return new JavaNote();
}
}
public class GoNoteFactory implements NoteFactory{
@Override
public BookNote createBookNote() {
return new GoBookNote();
}
@Override
public ENote createENote() {
return new GoENote();
}
@Override
public Note createNote() {
return new GoNote();
}
}
第五步，创建抽象工厂测试类
public class AbstractFactoryTest {
public static void main(String[] args) {
NoteFactory javaNoteFactory = new JavaNoteFactory();
BookNote javaBookNote = javaNoteFactory.createBookNote();
ENote javaENote = javaNoteFactory.createENote();
Note javaNote = javaNoteFactory.createNote();
javaBookNote.mark();
javaENote.typing();
javaNote.write();
System.out.println("n"+"==========我是分割线========="+"n");
NoteFactory gonoteFactory = new GoNoteFactory();
BookNote goBookNote = goNoteFactory.createBookNote();
ENote goENote = goNoteFactory.createENote();
Note gonote = goNoteFactory.createNote();
goBookNote.mark();
goENote.typing();
goNote.write();
}
}
