设计模式：自个儿手动写一个工厂模式（整合工厂方法模式和抽象工厂模式）

设计模式：自己手动写一个工厂模式（整合工厂方法模式和抽象工厂模式）

工厂模式：所有工厂模式都用来封装对象的创建。工厂方法模式通过让子类决定该创建的对象是什么，来达到将对象的创建过程封装的目的。

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

抽象工厂模式提供一个接口，用来创建相关或依赖对象的家族，而不需要明确指定具体类。

工厂方法使用继承：把对象的创建委托给子类，子类实现工厂方法来创建对象。

抽象工厂使用对象组合：对象的创建被实现在工厂接口所暴露出来的方法中。抽象工厂创建相关的对象家族，而不需要依赖它们的具体类。

下面是工厂方法的类图

设计模式：自个儿手动写一个工厂模式（整合工厂方法模式和抽象工厂模式）

下面是工程的结构图

设计模式：自个儿手动写一个工厂模式（整合工厂方法模式和抽象工厂模式）

AbstractFactorys包下的类主要体现抽象工厂模式的运用

factoryMethods 包下的类主要体现工厂方法模式的运用

源代码如下：

先给出 factoryMethods 下的代码

package factoryMethods;

import AbstractFactorys.PizzaIngredientFactory;

/**
 * 披萨商店抽象类 超类
 * @author Arvon
 *
 */
public abstract class PizzaStore {
	PizzaIngredientFactory ingredientFactory;
	public void orderPizza(String type,PizzaIngredientFactory ingredientFactory){
		Pizza pizza;
		pizza = createPizza(type,ingredientFactory);
		pizza.prepare();
		pizza.bake();
		pizza.cut();
		pizza.box();
	}
	/**
	 * 生产披萨  工厂方法 由子类来实现
	 * @param type
	 * @return
	 */
	public abstract Pizza createPizza(String type,PizzaIngredientFactory ingredientFactory);
	
	
}

package factoryMethods;

import AbstractFactorys.PizzaIngredientFactory;

/**
 * 芝加哥披萨商店 负责生产披萨
 * @author Administrator
 *
 */
public class ChicagoPizzaStore extends PizzaStore {
	
	@Override
	public Pizza createPizza(String type,PizzaIngredientFactory ingredientFactory) {
		if(type.equals(Constant.CHEESE))
			return new ChicagoStyleCheesePizza(ingredientFactory);
		else if(type.equals(Constant.VEGGIE))
			return new ChicagoStyleVeggiePizza(ingredientFactory);
		else return null;
	}

}

package factoryMethods;

import AbstractFactorys.PizzaIngredientFactory;

/**
 * 纽约披萨商店 负责生产披萨
 * @author Administrator
 *
 */
public class NYPizzaStroe extends PizzaStore {

	@Override
	public Pizza createPizza(String type, PizzaIngredientFactory ingredientFactory) {
		if(type.equals(Constant.CHEESE))
			return new NYStyleCheesePizza(ingredientFactory);
		else if(type.equals(Constant.VEGGIE))
			return new NYStyleVeggiePizza();
		else return null;
	}
}

package factoryMethods;

import AbstractFactorys.Cheese;
import AbstractFactorys.Veggie;

/**
 * 产品类 超类
 * @author Administrator
 *
 */
public abstract class Pizza {
	String name;
	Veggie veggie;
	Cheese cheese;
	
	
	public abstract void prepare();

	public void bake() {
		System.out.println("Bake for 25 minutes at 350");
		
	}

	public void cut() {
		System.out.println("Cutting the pizza into diagonal slices");
	}

	public void box() {
		System.out.println("Place pizza in official PizzaStore box");
	}

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

}

package factoryMethods;

import AbstractFactorys.PizzaIngredientFactory;

public class ChicagoStyleCheesePizza extends Pizza {
	PizzaIngredientFactory ingredientFactory;
	public ChicagoStyleCheesePizza(PizzaIngredientFactory ingredientFactory) {
		super();
		// TODO Auto-generated constructor stub
		name = "ChicagoStyleCheesePizza";
		this.ingredientFactory = ingredientFactory;
	}

	@Override
	public void prepare() {
		
	}
	
}

package factoryMethods;

import AbstractFactorys.PizzaIngredientFactory;

public class ChicagoStyleVeggiePizza extends Pizza {
	PizzaIngredientFactory ingredientFactory;
	public ChicagoStyleVeggiePizza(PizzaIngredientFactory ingredientFactory) {
		super();
		// TODO Auto-generated constructor stub
		name = "ChicagoStyleVeggiePizza";
		this.ingredientFactory = ingredientFactory;
	}

	@Override
	public void prepare() {
		// TODO Auto-generated method stub
		cheese = ingredientFactory.createCheese();
		veggie = ingredientFactory.createVeggie();
		System.out.println("Preparing " + name);
		System.out.println(cheese.getName());
		System.out.println(veggie.getName());
	}
	
}

package factoryMethods;

import AbstractFactorys.PizzaIngredientFactory;

public class NYStyleCheesePizza extends Pizza {
	PizzaIngredientFactory ingredientFactory;
	public NYStyleCheesePizza(PizzaIngredientFactory ingredientFactory) {
		super();
		name = "NYStyleCheesePizza";
		this.ingredientFactory = ingredientFactory;
	}

	@Override
	public void prepare() {
		cheese = ingredientFactory.createCheese();
		veggie = ingredientFactory.createVeggie();
		System.out.println("Preparing " + name);
		System.out.println(cheese.getName());
		System.out.println(veggie.getName());
	}
	
}

package factoryMethods;

public class NYStyleVeggiePizza extends Pizza {

	public NYStyleVeggiePizza() {
		super();
		// TODO Auto-generated constructor stub
		name = "NYStyleVeggiePizza";
	}

	@Override
	public void prepare() {
		// TODO Auto-generated method stub
		
	}

}

package factoryMethods;

public interface Constant {
	public static final String CHEESE = "cheese";
	public static final String VEGGIE = "veggie";
}

接下来是AbstractFactorys包里的类

package AbstractFactorys;
/**
 * 原料生产工厂 抽象工厂
 * @author Administrator
 *
 */
public interface PizzaIngredientFactory {
	public Cheese createCheese();
	public Veggie createVeggie();
	
}

package AbstractFactorys;
/**
 * 原料生产工厂 具体工厂
 * @author Administrator
 *
 */
public class ChicagoPizzaIngredientFactory implements PizzaIngredientFactory {

	@Override
	public Cheese createCheese() {
		return new Cheese(this);
	}

	@Override
	public Veggie createVeggie() {
		return new Veggie(this);
	}

}

package AbstractFactorys;
/**
 * 原料生产工厂 具体工厂
 * @author Administrator
 *
 */
public class NYPizzaIngredientFactory implements PizzaIngredientFactory {

	@Override
	public Cheese createCheese() {
		// TODO Auto-generated method stub
		return new Cheese(this);
	}

	@Override
	public Veggie createVeggie() {
		// TODO Auto-generated method stub
		return new Veggie(this);
	}

}

package AbstractFactorys;
/**
 * 原料类 超类
 * @author Administrator
 *
 */
public class Ingredient {
	String name;

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

	public String getName() {
		return name;
	}
	
	
}

package AbstractFactorys;
/**
 * 具体的原料
 * @author Administrator
 *
 */
public class Cheese extends Ingredient {

	public Cheese(PizzaIngredientFactory ingredientFactory) {
		name = "cheese from "+ ingredientFactory.getClass().getSimpleName();
		setName(name);
	}
	
}

package AbstractFactorys;
/**
 * 具体的原料
 * @author Administrator
 *
 */
public class Veggie extends Ingredient {

	public Veggie(PizzaIngredientFactory ingredientFactory) {
		name = "veggie from "+ ingredientFactory.getClass().getSimpleName();
	}

}

测试类

package factoryMethods;

import AbstractFactorys.ChicagoPizzaIngredientFactory;
import AbstractFactorys.NYPizzaIngredientFactory;
import AbstractFactorys.PizzaIngredientFactory;

/**
 * 测试类
 * @author Administrator
 *
 */
public class Test {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		PizzaStore mPizzaStore = new NYPizzaStroe();
		PizzaIngredientFactory ingredientFactory = new NYPizzaIngredientFactory();
		mPizzaStore.orderPizza("cheese", ingredientFactory);
		System.out.println("-----------------------------------");
		ingredientFactory = new ChicagoPizzaIngredientFactory();
		mPizzaStore = new ChicagoPizzaStore();
		mPizzaStore.orderPizza("veggie", ingredientFactory);
		
	}
	

}

测试结果：

Preparing NYStyleCheesePizza
cheese from NYPizzaIngredientFactory
veggie from NYPizzaIngredientFactory
Bake for 25 minutes at 350
Cutting the pizza into diagonal slices
Place pizza in official PizzaStore box
-----------------------------------
Preparing ChicagoStyleVeggiePizza
cheese from ChicagoPizzaIngredientFactory
veggie from ChicagoPizzaIngredientFactory
Bake for 25 minutes at 350
Cutting the pizza into diagonal slices
Place pizza in official PizzaStore box

设计模式： 自个儿手动写一个工厂模式（整合工厂方法模式和抽象工厂模式）

相关推荐

设计模式：自个儿手动写一个工厂模式（整合工厂方法模式和抽象工厂模式）