工厂模式总结

简单工厂模式，工厂方法模式和抽象工厂模式都是属于创建型设计模式，这三种创建型模式都不需要知道具体类。我们掌握一种思想，就是在创建一个对象时，需要把容易发生变化的地方给封装起来，来控制变化（哪里变化，封装哪里），以适应客户的变动，项目的扩展。

 

简单工厂模式：简单工厂没有抽象类，只有一个具体工厂类如MyFactory，然后MyFactory里面有个工厂方法CreateProduct返回一个基类产品，具体返回什么具体实例通过传入参数然后用case判断。

 

 

比如下面的例子：产品是手机，分别有子类 诺基亚手机和苹果手机，两种手机都通过CellphoneProducer类来控制产生。

package designpattern;

interface Cellphone {
	void call();
}

class AppleCellphone implements Cellphone {
	public void call() {
		System.out.println("Apple calls.");
	}

}

class NokiaCellphone implements Cellphone {
	public void call() {
		System.out.println("Nokia calls.");
	}
}

class CellphoneProducer {
	public static Cellphone produceNokia() {
		return new NokiaCellphone();
	}

	public static Cellphone produceApple() {
		return new AppleCellphone();
	}
}

public class SimpleFactory {

	public static void main(String[] args) {
		Cellphone phone1 = CellphoneProducer.produceNokia();
		phone1.call();
		Cellphone phone2 = CellphoneProducer.produceApple();
		phone2.call();
	}

}

 

 

工厂方法模式：该模式有一个抽象基类和若干个派生的具体工厂类，基类定义了一个虚工厂方法返回指定产品类的基类，派生类需要实现该虚方法并创建具体产品类返回。注意工厂方法的每个具体工厂只负责返回一种产品类。

 

比如下面的例子，此时的工厂类是一个基类，通过不同的子类生产不同的产品。

package designpattern;

interface CellphoneFactory {
	Cellphone produce();
}

class NokiaFactory implements CellphoneFactory {
	public Cellphone produce() {
		return new NokiaCellphone();
	}
}

class AppleFactory implements CellphoneFactory {
	public Cellphone produce() {
		return new AppleCellphone();
	}
}

public class FactoryMethod {

	public static void main(String[] args) {
		Cellphone phone1 = new NokiaFactory().produce();
		phone1.call();
		Cellphone phone2 = new AppleFactory().produce();
		phone2.call();
	}

}

 

 

抽象工厂模式：该模式和工厂方法模式很相似，也是一个抽象基类和若干个具体工厂类，不同的是抽象工厂的工厂基类定义了多个虚工厂方法，每个虚工厂方法负责返回一种产品，多个工厂方法返回多种产品，并且这些产品具有某些联系。

 

 

比如下面的例子，现在工厂类不仅要生产手机，还要生产充电器，并且两者之间有一定关联（苹果手机必须的用苹果充电器）。因此工厂类的每个子类定义了一个产品族。

package designpattern;

interface Charger {
	void charge();
}

class NokiaCharger implements Charger {
	public void charge() {
		System.out.println("Nokia charges.");
	}
}

class AppleCharger implements Charger {
	public void charge() {
		System.out.println("Apple charges.");
	}
}

interface abstractFactory {
	Cellphone producePhone();

	Charger produceCharger();
}

class NokiaAbsFactory implements abstractFactory {

	@Override
	public Cellphone producePhone() {

		return new NokiaCellphone();
	}

	@Override
	public Charger produceCharger() {
		return new NokiaCharger();
	}

}

class AppleAbsFactory implements abstractFactory {

	@Override
	public Cellphone producePhone() {

		return new AppleCellphone();
	}

	@Override
	public Charger produceCharger() {
		return new AppleCharger();
	}

}

public class AbstractFactory {

	public static void main(String[] args) {
		NokiaAbsFactory naf = new NokiaAbsFactory();
		Cellphone phone1 = naf.producePhone();
		phone1.call();
		Charger charger1 = naf.produceCharger();
		charger1.charge();

		AppleAbsFactory aaf = new AppleAbsFactory();
		Cellphone phone2 = aaf.producePhone();
		phone2.call();
		Charger charger2 = aaf.produceCharger();
		charger2.charge();
	}

}

 

 

总结：

简单工厂：用来生产同一等级结构中的任意产品。（对于增加新的产品，无能为力）

工厂方法 ：用来生产同一等级结构中的固定产品。（支持增加任意产品）  

抽象工厂：用来生产不同产品族的全部产品。（对于增加新的产品，无能为力；支持增加产品族）

 

以上三种工厂方法在等级结构和产品族这两个方向上的支持程度不同。所以要根据情况考虑应该使用哪种方法。 

评论

1 楼 huntfor 2014-03-28  

把多线程考虑在内重写一遍吧