java设计模式（三）——工厂设计模式

看一个具体的需求

看一个披萨的项目：要便于披萨种类的扩展，要便于维护

1)   披萨的种类很多(比如 GreekPizz、CheesePizz 等)

2)   披萨的制作有 prepare，bake, cut, box

3)   完成披萨店订购功能。

使用传统方式去实现：

1.创建抽象Pizza类

//将pizza类做成抽象
public abstract class Pizza {
	protected String name;

	public abstract void prepare();

	public void bake() {
		System.out.println(name +"baking");
	}
	public void cut() {
		System.out.println(name +"cutting");
	}
	public void box() {
		System.out.println(name +"boxing");
	}
	public void setName(String name) {
		this.name = name;
	}
}

2.创建两种pizza

//希腊pizza
public class GreekPizza extends Pizza{

	@Override
	public void prepare() {
		// TODO Auto-generated method stub
		System.out.println("给制作希腊披萨准备原材料");
	}
	
}
//奶酪pizza
public class CheesePizza extends Pizza{

	@Override
	public void prepare() {
		// TODO Auto-generated method stub
		System.out.println("给只做奶酪披萨准备原材料");
	}

}

3.订单pizza

public class OrderPizza {
		//构造器
		public OrderPizza() {
			// TODO Auto-generated constructor stub
			Pizza pizza = null;
			String orderType;//订购的披萨类型
			do {
				orderType = getType();
				if(orderType.equals("greek")){
					pizza = new GreekPizza();
					pizza.setName("希腊披萨");
				}else if(orderType.equals("cheese")){
					pizza = new CheesePizza();
					pizza.setName("奶酪披萨");
				}else{
					break;
				}
				//输出披萨的制作过程
				pizza.prepare();
				pizza.bake();
				pizza.cut();
				pizza.box();
			} while (true);
		}

	private String getType() {
		try {
			BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
			System.out.println("请输入要订购的披萨：");
			String str;
			str = reader.readLine();
			return str;
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			return null;
		}
	}
}

传统的方式的优缺点

1)   优点是比较好理解，简单易操作。

2)   缺点是违反了设计模式的 ocp 原则，即对扩展开放，对修改关闭。即当我们给类增加新功能的时候，尽量不修改代码，或者尽可能少修改代码.

3)   比如我们这时要新增加一个 Pizza 的种类(Pepper 披萨)，我们需要做如下修改.如果我们增加一个 Pizza 类，只要是订购 Pizza 的代码都需要修改.

基本介绍

1)   简单工厂模式是属于创建型模式，是工厂模式的一种。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式；

2)   简单工厂模式：定义了一个创建对象的类，由这个类来封装实例化对象的行为(代码)

3)   在软件开发中，当我们会用到大量的创建某种、某类或者某批对象时，就会使用到工厂模式.

传统方法修改思路分析：

分析：修改代码可以接受，但是如果我们在其它的地方也有创建 Pizza 的代码，就意味着，也需要修改，而创建 Pizza的代码，往往有多处。

思路：把创建 Pizza 对象封装到一个类中，这样我们有新的 Pizza 种类时，只需要修改该类就可，其它有创建到 Pizza对象的代码就不需要修改了.-> 简单工厂模式

代码演示：

1.创建工厂类： 

//简单工程类
public class SimpleFactory {
	//根据orderType返回对应的Pizza对象
	public Pizza createPizza(String orderType) {
		Pizza pizza = null;
		if(orderType.equals("greek")){
			pizza = new GreekPizza();
			pizza.setName("希腊披萨");
		}else if(orderType.equals("cheese")){
			pizza = new CheesePizza();
			pizza.setName("奶酪披萨");
		}
		return pizza;
	}
}

 2.修改订单pizza类

public class OrderPizza {
	SimpleFactory simpleFactory;
	Pizza pizza = null;
	public OrderPizza(SimpleFactory simpleFactory) {
		setFactory(simpleFactory);
	}

	public void setFactory(SimpleFactory simpleFactory) {
		String orderType = ""; 

		this.simpleFactory = simpleFactory;
		do {
			orderType = getType(); 
			pizza = this.simpleFactory.createPizza(orderType);
			
			if(pizza != null) { 
				pizza.prepare();
				pizza.bake();
				pizza.cut();
				pizza.box();
			} else {
				System.out.println("订购失败 ");
				break;
			}
		}while(true);
	}
	private String getType() {
		try {
			BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
			System.out.println("请输入要订购的披萨：");
			String str;
			str = reader.readLine();
			return str;
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			return null;
		}
	}
}

简单工厂设计模式总结：

1 简单工厂模式 也叫 静态工厂模式；

2.扩展性差（我想增加一种pizza，除了新增一个pizza产品类，还需要修改工厂类方法）

3.不同的产品需要不同额外参数的时候 不支持。

在看一个新需求

披萨项目新的需求：客户在点披萨时，可以点不同口味的披萨，比如 北京的奶酪 pizza、北京的胡椒 pizza 或者是伦敦的奶酪 pizza、伦敦的胡椒 pizza。

思路1：

使用简单工厂模式，创建不同的简单工厂类，比如 BJPizzaSimpleFactory、LDPizzaSimpleFactory 等等.从当前这个案例来说，也是可以的，但是考虑到项目的规模，以及软件的可维护性、可扩展性并不是特别好。

思路2：

使用工厂方法模式

工厂方法模式介绍

 

 

 

• 工厂方法模式设计方案：将披萨项目的实例化功能抽象成抽象方法，在不同的口味点餐子类中具体实现。
• 工厂方法模式：定义了一个创建对象的抽象方法，由子类决定要实例化的类。工厂方法模式将对象的实例化推迟到子类。

应用实例：

披萨项目新的需求：客户在点披萨时，可以点不同口味的披萨，比如 北京的奶酪 pizza、北京的胡椒 pizza 或者是伦敦的奶酪 pizza、伦敦的胡椒 pizza。

OrderPizza类修改：

public abstract class OrderPizza {
	//定义一个抽象方法，createPizza ,  让各个工厂子类自己实现
	abstract Pizza createPizza(String orderType);
	// 构造器
	public OrderPizza() { 
		Pizza pizza = null;
		String orderType; //  订购披萨的类型
		do {
			orderType = getType();
			pizza = createPizza(orderType); //抽象方法，由工厂子类完成
			//输出 pizza 制作过程
			pizza.prepare(); pizza.bake();
			pizza.cut();
			pizza.box();


		} while (true);
	}


	// 写一个方法，可以获取客户希望订购的披萨种类
	private String getType() { 
		try {
			BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
			System.out.println("input pizza 种类:");
			String str = strin.readLine();
			return str;
		} catch (IOException e) { 
			e.printStackTrace(); return "";
		}
	}
}

分别设计BJOrderPizza 类与LDOrderPizza类，继承OrderPizza类，复写其createPizza 方法，让用户根据需求订购所需的pizza类型：

工厂方法设计模式总结：

1. 可以一定程度上解耦，消费者和产品实现类隔离开，只依赖产品接口(抽象产品)，产品实现类如何改动与消费者完全无关。
2. 可以一定程度增加扩展性，若增加一个产品实现，只需要实现产品接口，修改工厂创建产品的方法，消费者可以无感知（若消费者不关心具体产品是什么的情况）。
3. 可以一定程度增加代码的封装性、可读性。清楚的代码结构，对于消费者来说很少的代码量就可以完成很多工作。
4. 工厂方法模式在一定程度上面违反了设计模式的里氏替换原则，即子类中尽量不要重写父类的方法；抽象工厂才是实际意义的工厂模式，工厂方法只是抽象工厂的一个比较常见的情况。

抽象工厂模式简介：

1. 抽象工厂模式：定义了一个 interface 用于创建相关或有依赖关系的对象簇，而无需指明具体的类
2. 抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合。
3. 从设计层面看，抽象工厂模式就是对简单工厂模式的改进(或者称为进一步的抽象)。
4. 将工厂抽象成两层，AbsFactory(抽象工厂) 和 具体实现的工厂子类。程序员可以根据创建对象类型使用对应的工厂子类。这样将单个的简单工厂类变成了工厂簇，更利于代码的维护和扩展。

应用实例：

使用抽象工厂模式来完成披萨项目.

//一个抽象工厂模式的抽象层(接口)
public interface AbsFactory {
    //让下面的工厂子类来 具体实现
    public Pizza createPizza(String orderType);
}

分别让不同的pizza工厂去实现这接口：

//这是北京pizza工厂子类
public class BJFactory implements AbsFactory {

	@Override
	public Pizza createPizza(String orderType) {
		System.out.println("~使用的是抽象工厂模式~");
		//TODO Auto-generated method stub 
		Pizza pizza = null; if(orderType.equals("cheese")) {
			pizza = new BJCheesePizza();
		} else if (orderType.equals("pepper")){ pizza = new BJPepperPizza();
		}
		return pizza;
	}
}
//这是伦敦pizza工厂子类
public class LDFactory implements AbsFactory {
	@Override
	public Pizza createPizza(String orderType) {
		System.out.println("~使用的是抽象工厂模式~"); Pizza pizza = null;
		if (orderType.equals("cheese")) { 
			pizza = new LDCheesePizza();
		} else if (orderType.equals("pepper")) { 
			pizza = new LDPepperPizza();
		}
		return pizza;
	}
}

OrderPizza类修改为：

public class OrderPizza {
	AbsFactory factory;

	// 构造器
	public OrderPizza(AbsFactory factory) {
		setFactory(factory);
	}
	private void setFactory(AbsFactory factory) { 
		Pizza pizza = null;
		String orderType = ""; //  用户输入
		this.factory = factory; 
		do {
			orderType = getType();
			// factory  可能是北京的工厂子类，也可能是伦敦的工厂子类
			pizza = factory.createPizza(orderType); 
			if (pizza != null) { // 订 购 ok
				pizza.prepare();
				pizza.bake();
				pizza.cut();
				pizza.box();
			} else {
				System.out.println("订购失败"); break;
			}
		} while (true);
	}

	// 写一个方法，可以获取客户希望订购的披萨种类
	private String getType() { 
		try {
			BufferedReader strin = new BufferedReader(new InputStreamReader(System.in)); 
			System.out.println("input pizza 种类:");
			String str = strin.readLine();
			return str;
		} catch (IOException e) { 
			e.printStackTrace(); 
			return "";
		}
	}
}

 

抽象工厂模式与工厂方法模式的区别：

 抽象工厂模式是工厂方法模式的升级版本，他用来创建一组相关或者相互依赖的对象。他与工厂方法模式的区别就在于，工厂方法模式针对的是一个产品等级结构；而抽象工厂模式则是针对的多个产品等级结构。在编程中，通常一个产品结构，表现为一个接口或者抽象类，也就是说，工厂方法模式提供的所有产品都是衍生自同一个接口或抽象类，而抽象工厂模式所提供的产品则是衍生自不同的接口或抽象类。

在抽象工厂模式中，有一个产品族的概念：所谓的产品族，是指位于不同产品等级结构中功能相关联的产品组成的家族。抽象工厂模式所提供的一系列产品就组成一个产品族；而工厂方法提供的一系列产品称为一个等级结构。我们依然拿生产汽车的例子来说明他们之间的区别。

工厂模式小结

• 工厂模式的意义
  • 将实例化对象的代码提取出来，放到一个类中统一管理和维护，达到和主项目的依赖关系的解耦。从而提高项目的扩展和维护性。
• 三种工厂模式 (简单工厂模式、工厂方法模式、抽象工厂模式)
• 设计模式的依赖抽象原则
• 创建对象实例时，不要直接 new 类, 而是把这个 new 类的动作放在一个工厂的方法中，并返回。有的书上说， 变量不要直接持有具体类的引用。
• 不要让类继承具体类，而是继承抽象类或者是实现 interface(接口)
• 不要覆盖基类中已经实现的方法。