2.工厂设计模式-java版

2 工厂模式

1 简单工厂模式

1 具体的需求：披萨的订购：传统的方式实现

1）思路的分析：

2）编写订购的各种需要的代码

① pizza类及其子类的编写

package factory.simplefactory.pizzastore.pizza;

public abstract class Pizza {
	protected String name;
	//准备原材料，不同得pizza有不同的原材料
	public abstract void prepare();
	public void bake() {
		System.out.println(name+" bakingh;");
	}
	public void cut() {
		System.out.println(name+" cuting;");
	}
	public void box() {
		System.out.println(name+" boxing;");
	}
	public void setName(String name) {
		this.name=name;
	}
}
package factory.simplefactory.pizzastore.pizza;

public class GreekPizza extends Pizza{
	
	@Override
	public void prepare() {
		System.out.println("准备GreekPizza的原材料！");		
	}
}

package factory.simplefactory.pizzastore.pizza;

public class CheessPizza extends Pizza{

	@Override
	public void prepare() {
		System.out.println("准备cheesspizza的原材料！");		
	}
}

②order的编写

package factory.simplefactory.pizzastore.order;

import java.util.Scanner;
import factory.simplefactory.pizzastore.pizza.GreekPizza;
import factory.simplefactory.pizzastore.pizza.Pizza;

public class OrderPizza {

public OrderPizza() {
	//非简单工厂对象
	Pizza pizza=null;
	String orderType;  //订购pizza的类型’
	do {
		orderType=getType();
		if (orderType.equals("greek")) {
			pizza=new GreekPizza();
			pizza.setName("希腊");
		}else if (orderType.equals("cheess")) {
			pizza=new GreekPizza();
			pizza.setName("奶酪");
		}else {
			break;
		}
		pizza.prepare();
		pizza.bake();
		pizza.cut();
		pizza.box();
	} while (true);
}

//获取客户的订购pizza类型
private String getType() {
	Scanner scanner=new Scanner(System.in);
	System.out.println("input pizza type：");
	String string=scanner.next();
	return string;
}
}

3）UML类图如下

4）存在的问题：

• 违反了ocp（开闭原则）–扩展开放，修改关闭，当我们给类增加新功能的时候，尽量不修改代码，或者尽量少修改代码。
• 我们新增加一个pizza类型，只要订购pizza的代码都需要进行修改。

2 改进思路：将创建Pizza对象封装到一个类中，当有新的Pizza种类时，只需要修改该类就可以，引出简单工厂。

1）UML类图

2）简单工厂之前和使用简单工厂的对比

public OrderPizza() {
		//非简单工厂对象
		Pizza pizza=null;
		String orderType;  //订购pizza的类型’
		do {
			orderType=getType();
			if (orderType.equals("greek")) {
				pizza=new GreekPizza();
				pizza.setName("希腊");
			}else if (orderType.equals("cheess")) {
				pizza=new GreekPizza();
				pizza.setName("奶酪");
			}else {
				break;
			}
			pizza.prepare();
			pizza.bake();
			pizza.cut();
			pizza.box();
		} while (true);
	}
	
	
----------------------------------------------------------------

//简单工厂类
public class SimpleFactory {
	//给一个约定的类型，创建一个该类型的对象
	public Pizza createPizza(String orderType) {
		System.out.println("使用简单工厂模式");
		Pizza pizza=null;
		if (orderType.equals("greek")) {
			pizza=new GreekPizza();
			pizza.setName("希腊");
		}else if (orderType.equals("cheess")) {
			pizza=new GreekPizza();
			pizza.setName("奶酪");
		}
		return pizza;
	}
}

	
----------------------------------------------------------------
	
    //利用的聚合的方式
	SimpleFactory factory;
	Pizza pizza=null;
	public void setFactory(SimpleFactory factory) {
		String orderType="";
		//设置简单工厂对象
		this.factory=factory;
		do {
			orderType=getType();
			Pizza createPizza = this.factory.createPizza(orderType);
			if (createPizza!=null) {
				createPizza.prepare();
				createPizza.bake();
				createPizza.cut();
				createPizza.box();
			}else {
				System.out.println("订购pizza失败");
			}
		} while (true);
	} 
	
	public OrderPizza(SimpleFactory factory) {
		setFactory(factory);
	}
----------------------------------------------------------------
//静态工厂的方式
public void setFactory() {
		String orderType="";
		do {
			orderType=getType();
			Pizza createPizza = SimpleFactory.createPizza(orderType);
			if (createPizza!=null) {
				createPizza.prepare();
				createPizza.bake();
				createPizza.cut();
				createPizza.box();
			}else {
				System.out.println("订购pizza失败");
			}
		} while (true);
	} 

3 简单工厂基本介绍

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

2）简单工厂模式：定义一个创建对象的类，这个类来封装实例化对象的行为。

3）在软件开发中，我们会大量的创建某钟，某类或者某批对象的时候，就会使用到工厂模式。

3 简单工厂模式也称为静态工厂模式

//简单工厂类
public class SimpleFactory {
	//给一个约定的类型，创建一个该类型的对象
	public static Pizza createPizza(String orderType) {
		System.out.println("使用简单工厂模式");
		Pizza pizza=null;
		if (orderType.equals("greek")) {
			pizza=new GreekPizza();
			pizza.setName("希腊");
		}else if (orderType.equals("cheess")) {
			pizza=new GreekPizza();
			pizza.setName("奶酪");
		}
		return pizza;
	}
}

//调用的时候就不需要使用创建对象

2 工厂方法模式

1 项目需要

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

思路1：使用简单工厂类，会导致工厂类急剧增多。但是考虑到项目的规模，软件的可维护性，可扩展性并不是特别好。

思路2：使用工厂方法模式。

2 工厂方法模式

设计方案：将披萨项目的实例化功能抽象成抽象方法，在不同的口味点餐子类中具体实现。

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

3 UML类图及实现

1）UML类图

2）代码实现：

package factory.factorymethod.pizzastore.order;

import java.util.Scanner;

import factory.factorymethod.pizzastore.pizza.Pizza;

public abstract class OrderPizza {
	public OrderPizza() {
		Pizza pizza=null;
		String orderType;
		do {
			orderType=getType();
			//具体的方法业务由工厂子类来完成
			pizza= createPizza(orderType);
			//输出pizza的制作流程
			pizza.prepare();
			pizza.bake();
			pizza.cut();
			pizza.box();
		} while (true);
	}
	//定义一个抽象方法，让工厂子类自己实现
	abstract Pizza createPizza(String orderType);

	//获取客户的订购pizza类型
	private String getType() {
		Scanner scanner=new Scanner(System.in);
        System.out.println("input pizza type：");
        String string=scanner.next();
		return string;
	}
}
-----------------------------------------------------------
//pizza设置如图所示
package factory.factorymethod.pizzastore.pizza;

public class BJCheesePizza extends Pizza{
	@Override
	public void prepare() {
		setName("北京奶酪Pizza");
		System.out.println("给北京的奶酪Pizza准备原材料");
		
	}
}

------------------------------------------------------------
//北京order设置
package factory.factorymethod.pizzastore.order;

import factory.factorymethod.pizzastore.pizza.BJCheesePizza;
import factory.factorymethod.pizzastore.pizza.BJPeperPizza;
import factory.factorymethod.pizzastore.pizza.Pizza;

public class BJOrderPizza extends OrderPizza{

	@Override
	Pizza createPizza(String orderType) {
		Pizza pizza=null;
		if (orderType.equals("cheese")) {
			pizza=new BJCheesePizza();
		}else if (orderType.equals("pepper")){
			pizza=new BJPeperPizza();
		}
		return pizza;
	}
}

3 抽象工厂

1 基本介绍

1）模式：定义一个interface用于创建相关或有依赖关系的对象簇，而无需指明其具体的类。

2）抽象工厂可以将简单工厂和工厂方法进行整合。

3）设计层面上来看，抽象工厂就是对简单工厂模式的一种改进（进一步抽象）

4）将工厂抽象成两层，抽象工厂和具体实现的工厂子类。程序员可以根据创建的对象类型使用对应的工厂子类。这样使得单个简单工厂类变成了工厂簇，有利于代码的维护和扩展。

2 UML类图及代码实现

1）UML类图

2）代码实现

//工厂抽象类
package factory.abstractfactory.pizzastore.factory;

import factory.abstractfactory.pizzastore.pizza.Pizza;

public interface AbsFactory {
	//工厂子类来具体实现
	public Pizza createPizza(String orderType);
}
-----------------------------------------------------------
//工厂实例类
package factory.abstractfactory.pizzastore.factory;

import factory.abstractfactory.pizzastore.pizza.BJCheesePizza;
import factory.abstractfactory.pizzastore.pizza.BJPeperPizza;
import factory.abstractfactory.pizzastore.pizza.Pizza;

public class BJFactory implements AbsFactory{

	@Override
	public Pizza createPizza(String orderType) {
		System.out.println("使用抽象工厂模式");
		Pizza pizza=null;
		if ("cheese".equals(orderType)) {
			pizza=new BJCheesePizza();
		}else if("pepper".equals(orderType)) {
			pizza=new BJPeperPizza();
		}
		return pizza;
	}

}

4 工厂模式源码分析

1 工厂模式的JDK源码分析–Calendar

2 工厂模式小结：

1）意义：将实例化对象的代码提取出来，放到一个类中统一管理和维护，达到和主项目的依赖关系的解耦，从而提高项目的扩展和维护性。

2）三种工厂模式，依赖抽象的原则

• 创建对象实例的时候，不要直接new类，而是把new这个类的动作放到一个工厂的方法中，并返回。变量不要直接持有具有类的引用。
• 不要让类继承具体类，而是直接继承抽象类或者实现interface（接口）
• 不要覆盖积累中已经实现的方法