设计模式：工厂模式

参考实例：http://www.cnblogs.com/java-my-life/archive/2012/03/28/2418836.html

 

抽象工厂模式的缺点

• 不太容易扩展新的产品

　　如果需要给整个产品族添加一个新的产品，那么就需要修改抽象工厂，这样就会导致修改所有的工厂实现类。

===================

 

工厂 其实就是抽象出事物的共性或者相似之处，定义共同的接口，实现交给具体的子类处理的过程。

 

理解 产品族和等级的概念：

 

   1.抽象工厂：定义工厂接口，包含生产原味和草莓味的酸奶的方法；

   2.定义工厂的实现类：蒙牛工厂和伊利工厂，并实现接口的方法；

   3.抽象工厂：定义口味接口，包含原味接口和草莓味接口，每个接口包含该口味酸奶的价格的方法；

   4.定义口味接口的实现类：每个工厂都能生产原味和草莓味酸奶，因此每个工厂分别包含原味接口的实现类和草莓味接口的实现类，实现类中给出该口味酸奶的价格。

   5.顾客类：顾客购买酸奶，只要说明要买酸奶的厂家，既得到该厂家下不同口味酸奶的价格信息；

   代码如下：

定义 草莓味接口：

package iv.factory.feidanyi.yuanshi.interfaces;

public interface CaoMeiWei {

	void getPrice();
}

 

定义草莓味的实现类：蒙牛草莓味

package iv.factory.feidanyi.yuanshi.classes;

import iv.factory.feidanyi.yuanshi.interfaces.CaoMeiWei;

public class MengNiuCmw implements CaoMeiWei {

	private int price =0;
	
	public MengNiuCmw(int price){
		this.price = price;
	}
	public void getPrice() {
		// TODO Auto-generated method stub
		System.out.println("蒙牛草莓味价格："+this.price);
	}

}

 

定义草莓味的实现类：伊利草莓味

package iv.factory.feidanyi.yuanshi.classes;

import iv.factory.feidanyi.yuanshi.interfaces.CaoMeiWei;

public class YiLiCmw implements CaoMeiWei {

	private int price =0;
	
	public YiLiCmw(int price){
		this.price = price;
	}
	public void getPrice() {
		// TODO Auto-generated method stub
		System.out.println("伊利草莓味价格："+this.price);
	}

}

 

定义原味接口：

package iv.factory.feidanyi.yuanshi.interfaces;

public interface YuanWei {
	
	void getPrice();
}

定义原味接口的实现类：蒙牛原味：

package iv.factory.feidanyi.yuanshi.classes;

import iv.factory.feidanyi.yuanshi.interfaces.YuanWei;

public class MengNiuYw implements YuanWei{
	private short price =0;
	private String brand ="";
	public MengNiuYw(int price){
		this.price = (short) price;
	}
	public void getPrice() {
		// TODO Auto-generated method stub
		System.out.println("原味价格："+this.price);
	}
	public void getBrand() {
		// TODO Auto-generated method stub
		System.out.println("品牌："+this.brand);
	}

}

定义原味接口的实现类：伊利原味：

package iv.factory.feidanyi.yuanshi.classes;

import iv.factory.feidanyi.yuanshi.interfaces.YuanWei;

public class YiLiYw implements YuanWei{
	
	private int price =0;
	private String brand = "";
	
	public YiLiYw(int price){
		this.price = price;
	}

	public void getPrice() {
		// TODO Auto-generated method stub
		System.out.println("原味价格："+this.price);
	}

}

定义厂家的接口：

package iv.factory.feidanyi.yuanshi.interfaces;

public interface AbstractFactory {

	YuanWei createYuanWei();
	CaoMeiWei createCaoMeiWei();
}

定义厂家的接口的实现类：蒙牛厂家：

package iv.factory.feidanyi.yuanshi.classes;

import iv.factory.feidanyi.yuanshi.interfaces.AbstractBrandFactory;
import iv.factory.feidanyi.yuanshi.interfaces.AbstractFactory;
import iv.factory.feidanyi.yuanshi.interfaces.CaoMeiWei;
import iv.factory.feidanyi.yuanshi.interfaces.YuanWei;

public class MengNiuFactory implements AbstractFactory,AbstractBrandFactory {

	public CaoMeiWei createCaoMeiWei() {
		// TODO Auto-generated method stub
		return new MengNiuCmw(14);
	}

	public YuanWei createYuanWei() {
		// TODO Auto-generated method stub
		return new MengNiuYw(15);
	}
	public String getBrand() {
		// TODO Auto-generated method stub
		return new MengNiu().getBrand();
	}
}

定义厂家的接口的实现类：伊利厂家：

package iv.factory.feidanyi.yuanshi.classes;

import iv.factory.feidanyi.yuanshi.interfaces.AbstractBrandFactory;
import iv.factory.feidanyi.yuanshi.interfaces.AbstractFactory;
import iv.factory.feidanyi.yuanshi.interfaces.CaoMeiWei;
import iv.factory.feidanyi.yuanshi.interfaces.YuanWei;

public class YiLiFactory implements AbstractFactory,AbstractBrandFactory {

	public CaoMeiWei createCaoMeiWei() {
		// TODO Auto-generated method stub
		return new YiLiCmw(11);
	}

	public YuanWei createYuanWei() {
		// TODO Auto-generated method stub
		return new YiLiYw(12);
	}

	public String getBrand() {
		// TODO Auto-generated method stub
		return new YiLi().getBrand();
	}
}

定义顾客类：

package iv.factory.feidanyi.yuanshi.classes;

import iv.factory.feidanyi.yuanshi.interfaces.AbstractFactory;
import iv.factory.feidanyi.yuanshi.interfaces.CaoMeiWei;
import iv.factory.feidanyi.yuanshi.interfaces.YuanWei;

public class Customer {
	private YuanWei yw =null;
	private CaoMeiWei cmw = null;
	
	public void buyMilk(AbstractFactory af){
		
		yw = af.createYuanWei();
		cmw = af.createCaoMeiWei();
		yw.getPrice();
		cmw.getPrice();
	}
	
}

定义main方法类：

package iv.factory.feidanyi.yuanshi.classes;

import iv.factory.feidanyi.yuanshi.interfaces.AbstractBrandFactory;
import iv.factory.feidanyi.yuanshi.interfaces.AbstractFactory;

public class client {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Customer cus = new Customer();
		AbstractBrandFactory af0 = new MengNiuFactory();
		AbstractFactory af = new MengNiuFactory();
		System.out.println(af0.getBrand());
		cus.buyMilk(af);
		
		AbstractBrandFactory af11 = new YiLiFactory();
		AbstractFactory af1 = new YiLiFactory();
		System.out.println(af11.getBrand());
		cus.buyMilk(af1);
	}

}

完毕。

动态装载类：

Class.forName(String类型的类的包路径).newInstance();

 

==================

封装“改变”是设计模式的原则.

什么时候使用工厂模式：如果在项目中有很多地方都需要生产某个对象的实例的话，则可以考虑使用工厂模式，让工厂来生产实例，当需要修改生产实例的方式时，只需要修改工程即可，不用到处修改。

在什么情况下应当使用抽象工厂模式

　　1.一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节，这对于所有形态的工厂模式都是重要的。

　　2.这个系统的产品有多于一个的产品族，而系统只消费其中某一族的产品。

　　3.同属于同一个产品族的产品是在一起使用的，这一约束必须在系统的设计中体现出来。（比如：Intel主板必须使用Intel CPU、Intel芯片组）

　　4.系统提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于实现。

抽象工厂模式的优点

• 分离接口和实现

　　客户端使用抽象工厂来创建需要的对象，而客户端根本就不知道具体的实现是谁，客户端只是面向产品的接口编程而已。也就是说，客户端从具体的产品实现中解耦。

• 使切换产品族变得容易

　　因为一个具体的工厂实现代表的是一个产品族，比如上面例子的从Intel系列到AMD系列只需要切换一下具体工厂。

抽象工厂模式的缺点

• 不太容易扩展新的产品

　　如果需要给整个产品族添加一个新的产品，那么就需要修改抽象工厂，这样就会导致修改所有的工厂实现类。