工厂模式：Factory Pattern
定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。
优点：
1、一个调用者想创建一个对象，只要知道其名称就可以了。
2、扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。
3、屏蔽产品的具体实现，调用者只关心产品的接口。
缺点：每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。
抽象工厂模式： Abstract Factory Pattern 是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。
优点：当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。
缺点：产品族扩展非常困难，要增加一个系列的某一产品，既要在抽象的 Creator 里加代码，又要在具体的里面加代码。
抽象工厂模式等于在简单的工厂模式，在添加一个生产工厂的类，更具不同的类型去生产具体的工厂。
简单工厂模式：
1.创建Book接口 Book.java
[java]package com.proliu.designPatterns.factory;
public interface Book {
public void bookDetails();
}[/java]
2.创建Book实现类,Math.java English.java
[java]package com.proliu.designPatterns.factory;
public class Math implements Book {
public void bookDetails() {
System.out.println(“Hello. I’m Math”);
}
}
package com.proliu.designPatterns.factory;
public class English implements Book {
public void bookDetails() {
System.out.println(“Hello. I’m English”);
}
}[/java]
3.创建简单工厂类 SimpleBookFactory.java
[java]package com.proliu.designPatterns.factory;
public class SimpleBookFactory {
public Book getBook(String bookType){
if(bookType == null)
return null ;
if(“math”.equals(bookType))
return new Math();
else if(“english”.equals(bookType))
return new English();
return null ;
}
}[/java]
- 测试方法
[java]@Test
public void testSimpleFactory(){
SimpleBookFactory simpleBookFactory = new SimpleBookFactory();
Book math = simpleBookFactory.getBook(“math”);
math.bookDetails();
Book english = simpleBookFactory.getBook(“english”);
english.bookDetails();
}[/java]
5.输出结果
Hello. I’m Math
Hello. I’m English
抽象工厂模式：
1.创建接口 Category.java
[java]package com.proliu.designPatterns.factory;
public interface Category {
public void categoryDetails();
}[/java]
2.创建实现Category接口类 Education.java Life.java
[java]package com.proliu.designPatterns.factory;
public class Education implements Category {
public void categoryDetails() {
System.out.println(“Hello. i’m is Education Category.”);
}
}
package com.proliu.designPatterns.factory;
public class Life implements Category {
public void categoryDetails() {
System.out.println(“Hello. i’m is Life Category.”);
}
}[/java]
3.创建抽象工厂 AbstractFactory.java
[java]package com.proliu.designPatterns.factory;
public abstract class AbstractFactory {
public abstract Book getBook(String bookType);
public abstract Category getCategory(String categoryType);
}[/java]
4.创建Book和Category工厂,并继承抽象工厂AbstractFactory
[java]package com.proliu.designPatterns.factory;
public class BookFactory extends AbstractFactory{
@Override
public Book getBook(String bookType) {
if(bookType == null)
return null ;
if(“math”.equals(bookType))
return new Math();
else if(“english”.equals(bookType))
return new English();
return null;
}
@Override
public Category getCategory(String categoryType) {
return null;
}
}
package com.proliu.designPatterns.factory;
public class CategoryFactory extends AbstractFactory{
@Override
public Book getBook(String bookType) {
return null;
}
@Override
public Category getCategory(String categoryType) {
if(categoryType == null)
return null ;
if(“edu”.equals(categoryType))
return new Education();
else if(“life”.equals(categoryType))
return new Life();
return null;
}
}[/java]
5.创建工厂的生产类 FactoryProducer.java
[java]package com.proliu.designPatterns.factory;
public class FactoryProducer {
public static AbstractFactory getFactory(String factoryType){
if(“book”.equals(factoryType))
return new BookFactory() ;
else if(“category”.equals(factoryType))
return new CategoryFactory() ;
return null ;
}
}[/java]
6.测试代码
[java]@Test
public void testAbstractFactory(){
AbstractFactory bookFactory = FactoryProducer.getFactory(“book”);
Book math = bookFactory.getBook(“math”);
math.bookDetails();
AbstractFactory categoryFactory = FactoryProducer.getFactory(“category”);
Category edu = categoryFactory.getCategory(“edu”);
edu.categoryDetails();
}[/java]
输出结果：
Hello. I’m Math
Hello. i’m is Education Category.