设计模式读书笔记——工厂模式

1、概述

工厂模式为创建对象提供过渡接口，将实例化具体类的代码从应用中抽离或者封装起来，使得它们不会干扰应用的其他部分。

2、简单工厂模式

简单工厂其实不是一个设计模式，反而比较像是一种编程习惯。也有资料称简单工厂为静态工厂方法模式

组成：

（1）工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑，在java中由具体的累实现。

（2）抽象产品角色：一般是由具体产品继承 的父类或者实现的接口。在java中由接口或者抽象类来实现。

（3）具体产品角色：工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现。

 

产品类：（一个抽象的产品+两个具体产品）

 

public abstract class Pizza {
	
    public abstract void prepare();
    
    public void bake(){
    	System.out.println("bake pizza");
    }
}

public class CheesePizza extends Pizza {

	@Override
	public void prepare() {
		System.out.println("prepare CheesePizza");
	}
	
}

public class VeggiePizza extends Pizza {

	@Override
	public void prepare() {
		System.out.println("prepare VeggiePizza");
	}

}

 

 

 

 

 

工厂类：

public class SimplePizzaFactory {
	public Pizza createPizza(String type){
		Pizza pizza=null;
		if (type.equals("cheese")) {
			pizza=new CheesePizza();
		} else if (type.equals("veggie")) {
			pizza=new VeggiePizza();
		}
		return pizza;
	}

}

 

客户类：

 

 

 

public class PizzaStore {
	public static void main(String[] args) {
		SimplePizzaFactory factory= new SimplePizzaFactory();
		Pizza pizza;
		pizza=factory.createPizza("cheese");
	    pizza.prepare();
	    pizza.bake();
	    
	    pizza=factory.createPizza("veggie");
	    pizza.prepare();
	    pizza.bake();
	}
	
}

运行结果：prepare CheesePizza
                  bake pizza
                  prepare VeggiePizza
                  bake pizza

 

分析：运用简单工厂之后，PizzaStore想要哪种类型的Pizza只需要通知SimplePizzaFactory，就能得到Pizza。但是SimplePizzaFactory能够制造的Pizza的种类都是固定的，我们如果想增加一种PIzza或者减少一种Pizza都需要去修改SimplePizzaFactory里的代码，这样不符合开闭原则（对扩展开放，对修改关闭）不利于程序的后期扩展。

3、工厂方法模式
工厂方法模式定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法让类把实例化推迟到子类。

组成：

（1）抽象工厂角色：这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。

（2）具体工厂角色：它含有和具体业务逻辑有关的代码，由应用程序调用以创建对应的具体产品的对象。

（3）抽象产品角色：他是具体产品必须继承的父类或者是实现的接口。在java中它由抽象类或者接口来实现。

（4）具体产品角色：由具体工厂角色所创建。在java中由具体的类实现。

产品类：

 

public abstract class Pizza {
	
    public abstract void prepare();
public abstract class PizzaFactory {
	abstract Pizza createPizza();
}

public class CheesePizza extends Pizza {

	@Override
	public void prepare() {
		System.out.println("prepare CheesePizza");
	}
	
}

public class VeggiePizza extends Pizza {

	@Override
	public void prepare() {
		System.out.println("prepare VeggiePizza");
	}

}

工厂类：

 

 

public abstract class PizzaFactory {
	abstract Pizza createPizza();
}

public class VeggiePizzaFactory extends PizzaFactory {
	@Override
	Pizza createPizza() {
		return new VeggiePizza();
	}
}

public class CheesePizzaFactory extends PizzaFactory {
	@Override
	Pizza createPizza() {
		return new CheesePizza();
	}
}

用户类：

 

 

public class PizzaStore {
	public static void main(String[] args) {
		Pizza pizza;
		
		VeggiePizzaFactory factory= new VeggiePizzaFactory();
		pizza=factory.createPizza();
	    pizza.prepare();
	    pizza.bake();
	    
	    CheesePizzaFactory factory2= new CheesePizzaFactory();
		pizza=factory2.createPizza();
	    pizza.prepare();
	    pizza.bake();
	}
	
}

运行结果：

 

prepare VeggiePizza
bake pizza
prepare CheesePizza
bake pizza
 

分析：简单工厂把全部的事情在一个类中处理完成，而工厂方法却是创建一个框架，让子类决定如何来实现。这样当我们要新增一种ChicagoPizza，只需要创建此产品类和产品工厂即可，无需做过多改动。现在在每个具体的工厂里都只能生产Pizza，我们想在工厂里不仅能有Pizza还想要Coffee，这种情况下就需要抽象工厂模式。

 

4、抽象工厂方法

抽象工厂模式是工厂方法模式的升级版，提供几个接口 用于创建相关或者依赖对象的家族而不需要明确指定具体的类。

组成：

与工厂方法一样，只不过每个具体工厂类里面产生一组对象。

产品类：

 

public abstract class Pizza {
	
    public abstract void prepare();
    
    public void bake(){
    	System.out.println("bake pizza");
    }
}

public class CheesePizza extends Pizza {

	@Override
	public void prepare() {
		System.out.println("prepare CheesePizza");
	}
	
}

public class VeggiePizza extends Pizza {

	@Override
	public void prepare() {
		System.out.println("prepare VeggiePizza");
	}

}

public abstract class Coffee {
	abstract void prepare();
	void boil(){
		System.out.println("boil coffee");
	}

}

public class CheeseCoffee extends Coffee {

	@Override
	void prepare() {
		System.out.println("prapare CheeseCoffee");
	}

}

public class VeggieCoffee extends Coffee {

	@Override
	void prepare() {
		System.out.println("prapare VeggieCoffee");
		
	}

}

工厂类：

 

 

public abstract class Factory {
	abstract Pizza createPizza();
	abstract Coffee createCoffee();
}

public class CheeseFactory extends Factory {
	@Override
	Pizza createPizza() {
		return new CheesePizza();
	}

	@Override
	Coffee createCoffee() {
		return new CheeseCoffee();
	}
}

public class VeggieFactory extends Factory {
	@Override
	Pizza createPizza() {
		return new VeggiePizza();
	}

	@Override
	Coffee createCoffee() {
		return new VeggieCoffee();
	}
}

客户类：

 

 

public class Store {
	public static void main(String[] args) {
		Pizza pizza;
		Coffee coffee;
		
		VeggieFactory factory= new VeggieFactory();
		pizza=factory.createPizza();
	    pizza.prepare();
	    pizza.bake();
	    coffee=factory.createCoffee();
	    coffee.prepare();
	    coffee.boil();
	    
	    VeggieFactory factory2= new VeggieFactory();
		pizza=factory2.createPizza();
	    pizza.prepare();
	    pizza.bake();
	    coffee=factory.createCoffee();
	    coffee.prepare();
	    coffee.boil();
	}
	
}

运行结果：

 

prepare VeggiePizza
bake pizza
prapare VeggieCoffee
boil coffee
prepare VeggiePizza
bake pizza
prapare VeggieCoffee
boil coffee

分析：抽象工厂模式的具体工厂经常实现工厂方法来创建产品。工厂方法提供一个抽象接口来创建一个产品而抽象工厂提供一个抽象接口来创建一个产品家族。

 

 

参考：Head First 设计模式
           http://blog.csdn.net/jason0539/article/details/23020989