1. 简单工厂
简单工厂模式又称为静态工厂模式，它属于创建型模式。在简单工厂模式中，可以根据不同的参数返回不同类的实例。简单工厂模式专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。
简单工厂模式包含如下角色：
Factory：工厂角色
工厂角色负责实现创建所有实例的内部逻辑。Product：抽象产品角色
抽象产品角色是所创建的所有对象的父类，负责描述所有实例所共有的公共接口。ConcreteProduct：具体产品角色
具体产品角色是创建目标，所有创建的对象都充当这个角色的某个具体类的实例。
举个例子：我们要制作披萨，有奶酪味的和希腊风味的，所以就可以定义一个抽象的 Pizza 接口，各种口味的披萨扩展接口。然后再定义一个静态的工厂方法，根据不同的类型来创建 Pizza 实例。
public abstract class Pizza {
public void bake(){
System.out.println("bake " + getDesc());
}
/**
* 披萨描述
*
* @return
*/
protected abstract String getDesc();
}
public class GreekPizza extends Pizza {
@Override
protected String getDesc() {
return "greek";
}
}
public class CheesePizza extends Pizza {
@Override
protected String getDesc() {
return "cheese";
}
}
public class SimplePizzaFactory {
/**
* 根据类型 创建 pizza
*
* @param type
* @return
*/
public static Pizza createPizza(String type) {
if ("cheese".equals(type)) {
return new CheesePizza();
} else if ("greek".equals(type)) {
return new GreekPizza();
} else {
throw new IllegalArgumentException("Invalid pizza type!");
}
}
}
// 简单工厂
Pizza cheese = SimplePizzaFactory.createPizza("cheese");
cheese.bake();
简单工厂模式的要点在于：当你需要什么，只需要传入一个正确的参数，就可以获取你所需要的对象，而无须知道其创建细节。
优点：实现对象的创建和对象的使用分离，将对象的创建交给专门的工厂类负责。
缺点：工厂类不够灵活，增加新产品时，需要修改判断逻辑代码；产品较多时，工厂方法代码将会非常复杂。
使用场景：工厂类负责创建的对象比较少；客户端只知道传入工厂类的参数，对于如何创建对象不关心。
2. 工厂方法模式
工厂方法模式属于类创建型模式，工厂父类负责定义创建产品对象的公共接口，工厂子类负责生成具体的产品对象，这样做的目的是，将产品类的实例化操作延迟到工厂子类中完成，即通过工厂子类来确定究竟应该实例化哪个具体产品类。
工厂方法模式包含如下角色：
Product：抽象产品
抽象产品定义产品的接口，是工厂方法模式所创建对象的超类型，即产品对象的共同父类或接口。ConcreteProduct：具体产品
具体产品实现了抽象产品接口，某种类型的具体产品由专门的具体工厂创建，它们之间往往一一对应。Factory：抽象工厂
抽象工厂中声明了工厂方法，用于返回一个产品，它是工厂方法模式的核心，任何在模式中创建对象的工厂类都必须实现该接口。ConcreteFactory：具体工厂
具体工厂是抽象工厂类的子类，实现了抽象工厂中定义的工厂方法，并可由客户调用，返回一个具体产品类的实例。
继续上面披萨的例子，我们开了两家披萨店，分别制作不同口味的披萨，客户想要哪种披萨，我们就让哪家做。
public abstract class PizzaStore {
public void orderPizza() {
Pizza pizza = createPizza();
pizza.bake();
}
/**
* 制作披萨
*
* @return
*/
protected abstract Pizza createPizza();
}
public class CheesePizzaStore extends PizzaStore {
@Override
protected Pizza createPizza() {
return new CheesePizza();
}
}
public class GreekPizzaStore extends PizzaStore {
@Override
protected Pizza createPizza() {
return new GreekPizza();
}
}
// 工厂方法
PizzaStore pizzaStore = new CheesePizzaStore();
pizzaStore.orderPizza();
工厂方法模式是简单工厂模式的进一步抽象和推广。由于使用了面向对象的多态性，工厂方法模式保持了简单工厂模式的优点，而且克服了它的缺点。在工厂方法模式中，核心的工厂类不再负责所有产品的创建，而是将具体创建工作交给子类去做。这个核心类仅仅负责给出具体工厂必须实现的接口，而不负责产品类被实例化这种细节，这使得工厂方法模式可以允许系统在不修改工厂角色的情况下引进新产品。
优点：增加新产品类时无须修改现有系统，并封装了产品对象的创建细节，系统具有良好的灵活性和可扩展性。
缺点：增加新产品的同时需要增加新的工厂，导致系统类的个数成对增加，在一定程度上增加了系统的复杂性。
使用场景：一个类不知道它所需要的对象的类；一个类通过其子类来指定创建哪个对象；将创建对象的任务委托给多个工厂子类中的某一个，客户端在使用时可以无须关心是哪一个工厂子类创建产品子类，需要时再动态指定。
3. 抽象工厂模式
抽象工厂模式：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。
抽象工厂模式包含如下角色：
AbstractFactory：抽象工厂
抽象工厂用于声明生成抽象产品的方法。ConcreteFactory：具体工厂
具体工厂实现了抽象工厂声明的方法，生成一组具体产品，这些产品构成了一个产品族，每个产品都位于某个产品等级结构中。AbstractProduct：抽象产品
抽象产品为每种产品声明接口，在抽象产品中定义了产品的抽象业务方法。Product：具体产品
具体产品定义具体工厂生产的具体产品对象，实现抽象产品接口中定义的业务方法。
继续上面的例子，披萨店要卖饮料了，和披萨搭配一起卖，但是每个地区的人们都有喜欢的口味，所以制作的披萨和饮料就要合理满足客户的需要。
public abstract class Drink {
public void taste(){
System.out.println("taste " + getDesc());
}
/**
* 饮料描述
*
* @return
*/
protected abstract String getDesc();
}
public class CocaCola extends Drink {
@Override
protected String getDesc() {
return "Coca cola";
}
}
public class Coffee extends Drink {
@Override
protected String getDesc() {
return "Coffee";
}
}
public interface IPizzaStore {
/**
* 制作披萨
*
* @return
*/
Pizza createPizza();
/**
* 制作饮料
*
* @return
*/
Drink createDrink();
}
public class NewYorkPizzaStore implements IPizzaStore {
@Override
public Pizza createPizza() {
return new CheesePizza();
}
@Override
public Drink createDrink() {
return new CocaCola();
}
}
public class ParisPizzaStore implements IPizzaStore {
@Override
public Pizza createPizza() {
return new GreekPizza();
}
@Override
public Drink createDrink() {
return new Coffee();
}
}
// 抽象工厂
ParisPizzaStore parisPizzaStore = new ParisPizzaStore();
Drink drink = parisPizzaStore.createDrink();
drink.taste();
Pizza pizza = parisPizzaStore.createPizza();
pizza.bake();
抽象工厂模式是所有形式的工厂模式中最抽象和最具一般性的一种形态。抽象工厂模式与工厂方法模式最大的区别在于，工厂方法模式针对的是一个产品等级结构，而抽象工厂模式则需要面对多个产品等级结构。
优点：隔离了具体类的生成，使得客户并不需要知道什么被创建，而且每次可以通过具体工厂类创建一个产品族中的多个对象，增加或者替换产品族比较方便，增加新的具体工厂和产品族很方便。
缺点：增加新的产品等级结构很复杂，需要修改抽象工厂和所有的具体工厂类，对「开闭原则」的支持呈现倾斜性。
使用场景：一个系统不应当依赖产品类实例如何被创建、组合和表达的细节；系统中有多于一个的产品族，而每次只使用其中某一产品族；属于同一个产品族的产品将在一起使用；系统提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖具体实现。
