工厂设计模式

工厂设计模式(Factory Pattern)

就是定义一个创建产品对象的接口。主要分为以下几种形态：

        1.简单工厂(Simple Factory)；

        2.工厂方法(Factory Method)；

       3.抽象工厂(Abstract Factory)；

首先定义抽象产品类Product：

    

package com.demo.factory.model;
/**
 * 抽象产品接口
 * @author li
 *
 */
public abstract class Product {
	
	private String name;

	public String getName() {
		return name;
	}

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

具体产品Washer：

package com.demo.factory.model.object;

import com.demo.factory.model.Product;


/**
 * 具体产品：洗衣机
 * @author li
 *
 */
public class Washer extends Product {
	
	public Washer(){
		this.setName("洗衣机");
	}
	
}

具体产品Icebox：

package com.demo.factory.model.object;

import com.demo.factory.model.Product;


/**
 * 具体产品：冰箱
 * @author li
 *
 */
public class Icebox extends Product {
	
	public Icebox(){
	  this.setName("冰箱");
	}

}

一、简单工厂(SimpleFactory)模式：

package com.demo.factory;

import com.demo.factory.model.Product;
/**
 * 简单工厂
 * @author li
 *
 */
public class SimpleFactory {
	
	public static Product create(Class<? extends Product> c){
		Product p=null;
		try {
			 p=c.newInstance();
		} catch (InstantiationException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		}
		return p;
	}

}

注：简单工厂又叫 静态工厂 ，是工厂模式三中状态中结构最为简单的。主要有一个静态方法，用来接受参数，并根据参数来决定返回实现同一接口的不同类的实例。当我们拥有很多很多产品的时候，而且产品之间又存在复杂的层次关系的时候，这个类必须拥有复杂的逻辑判断能力，其代码量也将不断地激增，这对以后的维护简直就是恐怖两个字...还有就是，整个系统都严重依赖SimpleFactory类，只要SimpleFactory类一出问题，系统就进入不能工作的状态，这也是最为致命的一点....
二、工厂方法：

首先定义抽象工厂接口Factory：

package com.demo.factory.itf;

import com.demo.factory.model.Product;
/**
 * 抽象工厂
 * @author li
 *
 */
public interface Factory {
	
	public Product create();

}

洗衣机的具体工厂WasherFactory：

package com.demo.factory;

import com.demo.factory.itf.Factory;
import com.demo.factory.model.Product;
import com.demo.factory.model.object.Washer;
/**
 * 创建洗衣机的具体工厂
 * @author li
 *
 */
public class WasherFactory implements Factory {

	@Override
	public Product create() {
		return new Washer();
	}

}

冰箱的具体工厂IceboxFactory：

package com.demo.factory;

import com.demo.factory.itf.Factory;
import com.demo.factory.model.Product;
import com.demo.factory.model.object.Icebox;
/**
 * 创建冰箱的具体工厂
 * @author li
 *
 */
public class IceboxFactory implements Factory {

	@Override
	public Product create() {
		return new Icebox();
	}

}

注： 工厂方法 和 简单工厂 的主要区别是， 简单工厂 是把创建产品的职能都放在一个类里面，而 工厂方法 则把不同的产品放在实现了工厂接口的不同工厂类里面，这样就算其中一个工厂类出了问题，其他工厂类也能正常工作，互相不受影响，以后增加新产品，也只需要新增一个实现工厂接口工厂类，就能达到，不用修改已有的代码。但 工厂方法 也有他局限的地方，那就是当面对的产品有复杂的等级结构的时候，例如，工厂除了生产家电外产品，还生产手机产品，这样一来家电是手机就是两大产品家族了，这两大家族下面包含了数量众多的产品，每个产品又有多个型号，这样就形成了一个复杂的产品树了。如果用 工厂方法 来设计这个产品家族系统，就必须为每个型号的产品创建一个对应的工厂类，当有数百种甚至上千种产品的时候，也必须要有对应的上百成千个工厂类，这就出现了传说的类爆炸，对于以后的维护来说，简直就是一场灾难.....
三、抽象工厂

首先定义抽象产品基类AbstractBaseProduct：

package com.demo.abfactory.model;
/**
 * 抽象产品基类
 * @author li
 *
 */
public abstract class AbstractBaseProduct {
	
	protected String version;
	
	protected double price;

	public abstract void printMessage();
}

定义洗衣机的抽象类AbstractWasher：

package com.demo.abfactory.model;
/**
 * 定义洗衣机的抽象类
 * @author li
 *
 */
public abstract class AbstractWasher extends AbstractBaseProduct{
	
	public abstract void wash();
	

}

定义冰箱的抽象类AbstractIcebox：

package com.demo.abfactory.model;
/**
 * 冰箱的抽象类
 * @author li
 *
 */
public abstract class AbstractIcebox extends AbstractBaseProduct{
	
	public abstract void freeze();

}

下来就是具体的产品类。

美的洗衣机的实现类MideaWasher：

package com.demo.abfactory.model.object;

import com.demo.abfactory.model.AbstractWasher;
/**
 * 美的洗衣机
 * @author li
 *
 */
public class MideaWasher extends AbstractWasher{
	
	public MideaWasher(){
		this.version="1.0";
		this.price=5000.00;
	}

	@Override
	public void printMessage() {
		System.out.println("price"+this.price+"  "+"version"+this.version);
	}

	@Override
	public void wash() {
      System.out.println("美的"+this.version+"洗衣服。。。");
	}

}

美的冰箱类的实现MideaIcebox：

package com.demo.abfactory.model.object;
import com.demo.abfactory.model.AbstractIcebox;
/**
 * 美的冰箱
 * @author li
 *
 */
public class MideaIcebox extends AbstractIcebox  {

    public MideaIcebox(){
    	this.version="1.0";
    	this.price=7000.00;
    }

	@Override
	public void freeze() {
		System.out.println("美的冰箱"+this.version+"冷藏。。。");
	}

	@Override
	public void printMessage() {
		System.out.println("price"+this.price+"  "+"version"+this.version);
	}

}

海尔洗衣机的实现类HaierWasher：

package com.demo.abfactory.model.object;

import com.demo.abfactory.model.AbstractWasher;
/**
 * 海尔洗衣机
 * @author li
 *
 */
public class HaierWasher extends AbstractWasher {
	
	public HaierWasher(){
		this.version="1.0";
        this.price=6000.00;
	}

	@Override
	public void printMessage() {
        System.out.println("price"+this.price+"  "+"version"+this.version);
	}

	@Override
	public void wash() {
     System.out.println("海尔"+this.version+"洗衣服。。。");
	}

}

海尔冰箱的实现类HaierIcebox：

package com.demo.abfactory.model.object;
import com.demo.abfactory.model.AbstractIcebox;
/**
 * 海尔冰箱
 * @author li
 *
 */
public class HaierIcebox extends AbstractIcebox {
	
	public HaierIcebox(){
		this.version="1.0";
		this.price=8000.00;
	}

	@Override
	public void printMessage() {
		System.out.println("price"+this.price+"  "+"version"+this.version);
	}

	@Override
	public void freeze() {
		System.out.println("海尔冰箱"+this.version+"冷藏。。。");
	}

}

抽象工厂接口Factory：

package com.demo.abfactory.itf;

import com.demo.abfactory.model.AbstractIcebox;
import com.demo.abfactory.model.AbstractWasher;
/**
 * 抽象工厂
 * @author li
 *
 */
public interface Factory {
	
	public AbstractWasher createWasher();
	
	public AbstractIcebox createIcebox();

}

美的工厂实现类MideaFactory：

package com.demo.abfactory;

import com.demo.abfactory.itf.Factory;
import com.demo.abfactory.model.AbstractIcebox;
import com.demo.abfactory.model.AbstractWasher;
import com.demo.abfactory.model.object.MideaIcebox;
import com.demo.abfactory.model.object.MideaWasher;
/**
 * 美的产品具体工厂
 * @author li
 *
 */
public class MideaFactory implements Factory {

	@Override
	public AbstractWasher createWasher() {
		return new MideaWasher();
	}

	@Override
	public AbstractIcebox createIcebox() {
		return new MideaIcebox();
	}

}

海尔工厂实现类HaierFactory：

package com.demo.abfactory;

import com.demo.abfactory.itf.Factory;
import com.demo.abfactory.model.AbstractIcebox;
import com.demo.abfactory.model.AbstractWasher;
import com.demo.abfactory.model.object.HaierIcebox;
import com.demo.abfactory.model.object.HaierWasher;
/**
 * 海尔产品具体工厂
 * @author li
 *
 */
public class HaierFactory implements Factory{

	@Override
	public AbstractWasher createWasher() {
		return new HaierWasher();
	}

	@Override
	public AbstractIcebox createIcebox() {
		return new HaierIcebox();
	}

}

注： 抽象工厂提供了一个接口(Factory)用于创建相关或者依赖对象的家族，而不需要具体的实现类,使客户端不必指定具体产品的情况下创建产品家族中的产品对象。抽象工厂的任务就是负责创建一组产品接口，每个接口负责创建一种产品。抽象工厂和工厂方法的区别：1). 工厂模式通过继承实现程序解耦，而抽象工厂则是通过组合实现程序解耦。2). 工厂方法用来创建一个抽象产品，具体工厂实现工厂方法创建具体产品，而抽象工厂用来创建一个产品家族的抽象产品。