23种java设计模式之工厂模式

一、简单工厂模式（Simple Factory Pattern）

简单工厂模式是属于创建型模式，又叫做静态工厂方法（Static Factory Method）模式。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式，可以理解为是不同工厂模式的一个特殊实现。

下面我就由一个顾客订购pizza的例子来讲解。

1.首先，我们写一个pizza父类，各种类型的pizza可以继承于这个父类。

public abstract class Pizza {
String name;

public void setName(String name) {
this.name = name;
}

public abstract void preapre();

public abstract void bake();

public abstract void finish();

}

2.我们写几个指定的pizza类：

ChinesePizza类：

public class ChiesePizza extends Pizza {
public void preapre() {
super.setName("ChinesePizza");
System.out.println(name+"正在准备！！！");

}
public void bake() {
super.setName("ChinesePizza");
System.out.println(name+"正在烘焙！！！");

}
public void finish() {
super.setName("ChinesePizza");
System.out.println(name+"完成！！！");

}

}

GreekPizza类：

public class GreekPizza extends Pizza {
public void preapre() {
super.setName("GreekPizza");
System.out.println(name+"正在准备！！！");

}
public void bake() {
super.setName("GreekPizza");
System.out.println(name+"正在烘焙！！！");

}
public void finish() {
super.setName("GreekPizza");
System.out.println(name+"完成！！！");

}

}

3.然后我们定义了一个创建对象的类SimpleFactory，用这个类来封装实例化对象的行为。这个就是简单工厂模式的核心部分：

public class SimpleFactory {
public Pizza createPizza(String orderType){
Pizza pizza=null;
if(orderType.equals("chinese")){
pizza=new ChiesePizza();
}else if(orderType.equals("greek")){
pizza=new GreekPizza();
}else if(orderType.equals("milk")){
pizza=new MilkPizza();
}
return pizza;
}

}

4、然后给一个顾客预订类OrderPizza，对于顾客指定的pizza进行处理，回应：

public class OrderPizza {
SimpleFactory simpleFactory;

public OrderPizza(SimpleFactory simpleFactory) {
setFactory(simpleFactory);
}

private void setFactory(SimpleFactory simpleFactory) {
Pizza pizza=null;
String orderType;

this.simpleFactory=simpleFactory;

do{
orderType=getType();
pizza=simpleFactory.createPizza(orderType);

if(pizza!=null){
pizza.preapre();
pizza.bake();
pizza.finish();

}
}while(true);

}

private String getType() {

try {
BufferedReader string = new BufferedReader(new InputStreamReader(System.in));
System.out.println("input pizza type:");
String str = string.readLine();
return str;
} catch (IOException e) {
e.printStackTrace();
return "";
}
}

}

5、最后，实现交易pizzaStroe类：

public class PizzaStroe {
public static void main(String[] args) {
SimpleFactory simpleFactory;
OrderPizza orderPizza=new OrderPizza(new SimpleFactory());
}

}

二、工厂方法模式

工厂方法模式：定义了一个创建对象的抽象方法，由子类决定要实例化的类。工厂方法模式将对象的 实例化推迟到子类。

对于上面的那个例子，如果这个pizza店要在别的城市开连锁店，然而不同的城市的pizza可能同一种类的pizza都会有口味上的区别，我们的确可以直接用简单工厂来实现，分别在不同的城市建一个简单工厂，可能这样解决方法问题不大，但是从可维护性可拓展性来说就对以后不便了。以下用代码来看一下两者的区别。

我们把之前的OrderPizza改写成抽象类：

public abstract class OrderPizza {
public OrderPizza(){
Pizza pizza=null;
String orderType;
do{
orderType=getType();
pizza=createPizza(orderType);
if(pizza!=null){
pizza.preapre();
pizza.bake();
pizza.finish();

}
}while(true);

}

abstract Pizza createPizza(String ordertype);

private String getType() {
try {
BufferedReader string = new BufferedReader(new InputStreamReader(System.in));
System.out.println("input pizza type:");
String str = string.readLine();
return str;
} catch (IOException e) {
e.printStackTrace();
return "";
}
}

}

然后我们就可以在不同的城市有不同的order方法了，一下是两个不同城市的order类：

SROrderPizza：

public class SROrderPizza extends OrderPizza {
Pizza createPizza(String ordertype) {
Pizza pizza=null;
if(ordertype.equals("greek")){
pizza=new SRGreekPizza();
}else if(ordertype.equals("cheese")){
pizza=new SRCheesePizza();
}
return pizza;
}

}

BJOrderPizza :

public class BJOrderPizza extends OrderPizza {
Pizza createPizza(String ordertype) {
Pizza pizza=null;
if(ordertype.equals("greek")){
pizza=new BJGreekPizza();
}else if(ordertype.equals("cheese")){
pizza=new BJCheesePizza();
}
return pizza;
}

}

最后在指定城市pizza店里面点你自己所需要的口味的pizza：

public class PizzaStroe {
public static void main(String[] args) {
OrderPizza mOrderPizza;
mOrderPizza=newSROrderPizza();
}

}

三、抽象工厂模式

抽象工厂模式定义了一个接口用于创建相关或有依赖关系的对象族，而无需明确指定具体类。

还是根据上面的项目来说，对于OrderPizza类：

public class OrderPizza {
AbstractFactory abstractFactory;

public OrderPizza(AbstractFactory abstractFactory) {
setFactory(abstractFactory);
}

private void setFactory(AbstractFactory abstractFactory) {
Pizza pizza=null;
String orderType;

this.abstractFactory=abstractFactory;

do{
orderType=getType();
pizza=abstractFactory.createPizza(orderType);

if(pizza!=null){
pizza.preapre();
pizza.bake();
pizza.finish();
}
}while(true);

}

private String getType() {
try {
BufferedReader string = new BufferedReader(new InputStreamReader(System.in));
System.out.println("input pizza type:");
String str = string.readLine();
return str;
} catch (IOException e) {
e.printStackTrace();
return "";
}
}

}

其实就是相比于简单工厂模式，把具体的工厂抽象化，然后让每个地区自己去构建自己的工厂，以下我就一SRFactory类来说：

public class SRFactroy extends AbstractFactory {
public Pizza createPizza(String orderType) {
Pizza pizza=null;
if(orderType.equals("chess")){
pizza=new SRCheesePizza();
}else if(orderType.equals("greek")){
pizza=new SRGreekPizza();
}
return pizza;
}

}

这样我们就用一个接口创建相关或有依赖关系的对象族，而无需明确指定具体类了。

最后实现在特定的地区购买pizza

PizzaStore类:

public class PizzaStore {
public static void main(String[] args) {
AbstractFactory abstractFactory;
OrderPizza mOrderPizza=newOrderPizza(new SRFactroy() );
}

}

总结：

1、工厂模式的本质

工厂模式的本质就是把项目里面的对象的实例化部分抽取出来单独处理和设计。

2、三种工厂子模式

a、如果把对象的实例化放在一个简单的类里面，那就是简单工厂模式

b、如果我们把对象的实例化的代码进行抽象，抽象成创建对象的方法，跟具体的实例化的子类，创建的对象的动作放到子类里面来操作，这样有更好的灵活性，这就是工厂方法模式

c、从结果上看，把原来的简单工厂这种形式可以抽象成两级，一个是抽象工厂，还有一个子工厂，把工厂变成工厂族的方式，这就是抽象工厂模式

3、依赖抽象原则

a、变量不要持有具体类的引用

b、不要让类继承自具体类，要继承自抽象类或者接口

c、不要覆盖基类中已实现的方法