设计模式：简单工厂，工厂模式，抽象工厂模式

 

参考：http://www.cnblogs.com/Bobby0322/p/4178412.html

简单工厂：

水果工厂：只需知道水果的名字就可以得到相应的水果。可以根据参数的不同返回不同类的实例。简单工厂模式专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。

客户端只需知道产品对应的参数（通过名字或者参数），就可以得到对应的实例。

Product是抽象接口或者抽象类，有两个实现类，Factory根据传入的参数判断返回A还是B。

Product是接口，Factory是类不是接口

创建对象的职责交给工厂类，工厂类职责过重，一旦出现新的产品，工厂类就得变化，不符合开闭原则。

代码：

工厂类Factory，专门生产产品,根据参数返回不同的产品。

package 简单工厂模式;

public class Factory {

	public Product createProduct(String name){
		if(name.equals("A")){
			return new ConcreteProductA();
		}else if(name.equals("B")){
			return new ConcreteProductB();
		}else {
			System.out.println("暂时没有"+name+"类产品");
			return null;
		}
	}
}

抽象产品类Product,抽象类或者接口：

package 简单工厂模式;

/**
 * 产品类的接口
 * @author Administrator
 *
 */
public interface Product {

}

具体产品类A,B，继承或者实现抽象产品类

package 简单工厂模式;

public class ConcreteProductA implements Product{

	public ConcreteProductA(){
		System.out.println("生产产品A");
	}
}


package 简单工厂模式;

public class ConcreteProductB implements Product {

	public ConcreteProductB(){
		System.out.println("生产产品B");
	}
}

客户端测试：

package 简单工厂模式;

import org.junit.Test;

public class Client {

	@Test
	public void main(){
		Product p = null;
		Factory f = new Factory();
		p = f.createProduct("A");
		System.out.println(p);
		p = f.createProduct("B");
		System.out.println(p);
		p = f.createProduct("C");
		System.out.println(p);
	}
}

测试结果：

工厂模式：

用户无须关心创建细节，只关心所需产品对应的工厂。加入新产品，无须修改抽象工厂，客户端，以及其他具体工厂产品。符合开闭原则。

Product是抽象的，Factory也是抽象的。

代码：

抽象工厂Factory,抽象类或者接口

package 工厂模式;
/**
 * 抽象工厂
 * @author Administrator
 *
 */
public interface Factory {
	public Product createProduct();
}

具体工厂：

package 工厂模式;

/**
 * 具体工厂
 * @author Administrator
 *
 */
public class ConcreteFactoryA implements Factory {

	@Override
	public Product createProduct() {
		System.out.println("具体工厂类A");
		return new ConcreteProductA();
	}

}

抽象产品Product,抽象类或者接口

package 工厂模式;
/**
 * 抽象产品
 * @author Administrator
 *
 */
public interface Product {
	public void show();

}

具体产品

package 工厂模式;

public class ConcreteProductA implements Product{

	public ConcreteProductA(){
		System.out.println("具体商品");
	}

	@Override
	public void show() {
		System.out.println("正在生产具体产品A");
		
	}
}

客户端测试：

package 工厂模式;

import org.junit.Test;

public class Client {
	@Test
	public void main(){
		Factory f;
		Product p;
		f = (Factory)XMLUtil.getBean();
		p = f.createProduct();
		p.show();
	}
	
}

读取配置文件的工具类：

package 工厂模式;

import java.io.File;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;

import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

public class XMLUtil {

	public static Object getBean(){
		DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
		try {
			DocumentBuilder builder = factory.newDocumentBuilder();
			Document doc = builder.parse(new File("src/config.xml"));
			NodeList node = doc.getElementsByTagName("className");
			Node classNode = node.item(0).getFirstChild();
			String value = classNode.getNodeValue();
			return Class.forName(value).newInstance();
		} catch (Exception e) {
			e.printStackTrace();
		}//
		return null;
	}
}

测试结果：

抽象工厂模式：

又称kit模式，提供一个创建一系列相关或相互依赖对象的接口的商品，比如，海尔工厂生产海尔电视机，海尔洗衣机等。

代码：

抽象工厂，生产某个品牌一系列商品

package 抽象工厂模式;

public interface Factory {
	//生产电视
	public Television produceTelevision();
	//生产空调
	public AirConditioner produceAirConditioner();
}

具体工厂HaierFactory，生产海尔电视机，空调：

package 抽象工厂模式;

/**
 * 具体工厂
 * @author Administrator
 *
 */
public class HaierFactory implements Factory {


	@Override
	public Television produceTelevision() {
		return new HaierTelevision();
	}

	@Override
	public AirConditioner produceAirConditioner() {
		return new HaierAirConditioner();
	}

}

具体工厂TCLFactory，生产TCL电视机，空调： 

package 抽象工厂模式;

/**
 * 具体工厂
 * @author Administrator
 *
 */
public class TCLFactory implements Factory {

	@Override
	public Television produceTelevision() {
		// TODO Auto-generated method stub
		return new TCLTelevision();
	}

	@Override
	public AirConditioner produceAirConditioner() {
		// TODO Auto-generated method stub
		return new TCLAirConditioner();
	}

}

抽象产品空调：

package 抽象工厂模式;

/**
 * 抽象产品
 * 空调
 * @author Administrator
 *
 */
public interface AirConditioner {
	public void change();
}

 抽象产品电视机：

package 抽象工厂模式;

/**
 * 抽象电视机
 * 抽象产品
 * @author Administrator
 *
 */
public interface Television {
	public void play();
}

具体产品，海尔电视机：

package 抽象工厂模式;

/**
 * 具体产品
 * @author Administrator
 *
 */
public class HaierTelevision implements Television {

	@Override
	public void play() {
		System.out.println("海尔电视放映");
	}

}

 具体产品海尔空调：

package 抽象工厂模式;

/**
 * 具体产品
 * 空调
 * @author Administrator
 *
 */
public class HaierAirConditioner implements AirConditioner {

	@Override
	public void change() {
		System.out.println("海尔空调");
	}

}

具体产品，TCL空调：

package 抽象工厂模式;

/**
 * 具体产品
 * 空调
 * @author Administrator
 *
 */
public class TCLAirConditioner implements AirConditioner {

	@Override
	public void change() {
		System.out.println("TCL空调");
	}

}

具体产品，TCL电视机：

package 抽象工厂模式;

public class TCLTelevision implements Television {

	@Override
	public void play() {
		System.out.println("TCL电视放映");
	}

}

客户端测试：

package 抽象工厂模式;

import org.junit.Test;

import 工厂模式.XMLUtil;


public class Client {

	@Test
	public void main(){
		Factory f;
		Television t;//电视机
		AirConditioner a;//空调
		f = (Factory)XMLUtil.getBean();
		a = f.produceAirConditioner();
		a.change();
		t = f.produceTelevision();
		t.play();
	}
}

测试结果：

配置文件confog.xml：

<?xml version="1.0" encoding="UTF-8"?>
<!-- <config>
	<className>工厂模式.ConcreteFactoryA</className>
</config> -->

<config>
	<className>抽象工厂模式.HaierFactory</className>
</config>