设计模式实例（简单工厂模式，工厂方法模式，抽象工厂模式）

一、题目分析

(1)、简单工厂模式
使用简单工厂模式模拟女娲（Nvwa）造人（Person），如果传入参数M，则返回一个Man对象，如果传入参数W，则返回一个Woman对象，请实现该场景。现需要增加一个新的Robot类，如果传入参数R，则返回一个Robot对象，对代码进行修改并注意女娲的变化。
(2)、工厂方法模式
海尔工厂(Haier)生产海尔空调(HaierAirCondition)，美的工厂(Midea)生产美的空调(MideaAirCondition) 。使用工厂方法模式描述该场景，绘制类图并编程实现。
(3)、抽象工厂模式
电脑配件生产工厂生产内存、CPU等硬件设备，这些内存、CPU的品牌、型号并不一定相同，根据下面的“产品等级结构-产品族”示意图，使用抽象工厂模式实现电脑配件生产过程并绘制相应的类图，绘制类图并编程实现。

二、类图设计

简单工厂模式

工厂方法模式

抽象工厂模式

三、程序实现

简单工厂模式

package 简单工厂模式;

public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		try
        {
        	Person person;
        	String type=XMLUtilPerson.getType();
        	person=PersonFactory.producePerson(type);
        	person.play();
        }
        catch(Exception e)
        {
        	System.out.println(e.getMessage());
        }
	}

}
package 简单工厂模式;

public class Man implements Person {
	public void play()
	{
		System.out.println("女娲造男人中......");
	}
}
package 简单工厂模式;

public interface Person {
	void play();
}
package 简单工厂模式;

public class PersonFactory {
	public static Person producePerson(String type) throws Exception
	{
		if(type.equalsIgnoreCase("M"))
		{
			System.out.println("女娲造男人！");
			return new Man();
		}
		else if(type.equalsIgnoreCase("W"))
		{
			System.out.println("女娲造女人！");
			return new Woman();
		}
		else if(type.equalsIgnoreCase("R"))
		{
			System.out.println("女娲造机器人！");
			return new Robot();
		}
		else
		{
			throw new Exception("对不起，暂不能生产该类型人！");
		}
	}
}
package 简单工厂模式;

public class Robot implements Person {
	public void play()
	{
		System.out.println("女娲造机器人中......");
	}
}
package 简单工厂模式;

public class Woman implements Person {
	public void play()
	{
		System.out.println("女娲造女人中......");
	}
}
package 简单工厂模式;

import javax.xml.parsers.*;
import org.w3c.dom.*;
import org.xml.sax.SAXException;
import java.io.*;
public class XMLUtilPerson {
	//该方法用于从XML配置文件中提取造人信息，并返回该信息
		public static String getType()
		{
			try
			{
				//创建文档对象
				DocumentBuilderFactory dFactory = DocumentBuilderFactory.newInstance();
				DocumentBuilder builder = dFactory.newDocumentBuilder();
				Document doc;							
				doc = builder.parse(new File("SimpleFactoryconfigPerson.xml")); 
			
				//获取包含品牌名称的文本节点
				NodeList nl = doc.getElementsByTagName("type");
	            Node classNode=nl.item(0).getFirstChild();
	            String type=classNode.getNodeValue().trim();
	            return type;
	           }   
	           	catch(Exception e)
	           	{
	           		e.printStackTrace();
	           		return null;
	           	}
			}
}

工厂方法模式

package factorymethod;

public interface AC {
	void play();
}
package factorymethod;

public interface ACFactory {
	AC produceAC();
}
package factorymethod;

public class HaierAirCondition implements AC {
	public void play()
	{
		System.out.println("海尔空调使用中......");
	}
}
package factorymethod;

public class HaierAirConditionFactory implements ACFactory {
	public AC produceAC()
    {
    	System.out.println("海尔空调工厂生产海尔空调。");
    	return new HaierAirCondition();
    }
}
package factorymethod;

public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		try
        {
        	AC ac;
        	ACFactory factory;
        	factory=(ACFactory)XMLUtil.getBean();
        	ac=factory.produceAC();
        	ac.play();
        }
        catch(Exception e)
        {
        	System.out.println(e.getMessage());
        }
	}

}
package factorymethod;

public class MideaAirCondition implements AC {
	public void play()
	{
		System.out.println("美的空调使用中......");
	}
}
package factorymethod;

public class MideaAirConditionFactory {
	public AC produceAC()
    {
    	System.out.println("美的空调工厂生产海尔空调。");
    	return new MideaAirCondition();
    }
}
package factorymethod;
import javax.xml.parsers.*;
import org.w3c.dom.*;
import org.xml.sax.SAXException;
import java.io.*;
public class XMLUtil {
	//该方法用于从XML配置文件中提取具体类类名，并返回一个实例对象
		public static Object getBean()
		{
			try
			{
				//创建文档对象
				DocumentBuilderFactory dFactory = DocumentBuilderFactory.newInstance();
				DocumentBuilder builder = dFactory.newDocumentBuilder();
				Document doc;							
				doc = builder.parse(new File("FactoryMethodconfig.xml")); 
			
				//获取包含类名的文本节点
				NodeList nl = doc.getElementsByTagName("className");
	            Node classNode=nl.item(0).getFirstChild();
	            String cName=classNode.getNodeValue();
	            
	            //通过类名生成实例对象并将其返回
	            Class c=Class.forName(cName);
		  	    Object obj=c.newInstance();
	            return obj;
	           }   
	           	catch(Exception e)
	           	{
	           		e.printStackTrace();
	           		return null;
	           	}
			}
}

抽象工厂模式

package abstractfactory;

public interface CPU {
	void play();
}
package abstractfactory;

public interface Factory {
	CPU produceCPU();
	RAM produceRAM();
}
package abstractfactory;

public class MacCPU implements CPU{
	public void play()
	{
		System.out.println("Mac工厂生产CPU中......");
	}
}
package abstractfactory;

public class MacFactory implements Factory {
	public CPU produceCPU()
	{
		return new MacCPU();
	}
	
	public RAM produceRAM()
	{
		return new MacRAM();
	}
}
package abstractfactory;

public class MacRAM implements RAM{
	public void play()
	{
		System.out.println("Mac工厂生产内存中......");
	}
}
package abstractfactory;

public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
	         try
	         {
	         	Factory factory;
	         	RAM ram;
	         	CPU cpu;
	         	factory=(Factory)XMLUtil.getBean();
	         	ram=factory.produceRAM();
	         	ram.play();
	         	cpu=factory.produceCPU();
	         	cpu.play();
	         }
	         catch(Exception e)
	         {
	         	System.out.println(e.getMessage());
	         }
		}
	}


package abstractfactory;

public class PcCPU implements CPU {
	public void play()
	{
		System.out.println("Pc工厂生产CPU中......");
	}
}
package abstractfactory;

public class PcFactory implements Factory {
	public CPU produceCPU()
	{
		return new PcCPU();
	}
	
	public RAM produceRAM()
	{
		return new PcRAM();
	}
}
package abstractfactory;

public class PcRAM implements RAM{
	public void play()
	{
		System.out.println("Pc工厂生产内存中......");
	}
}
package abstractfactory;

public interface RAM{
	public void play();
}
package abstractfactory;
import javax.xml.parsers.*;
import org.w3c.dom.*;
import org.xml.sax.SAXException;
import java.io.*;
public class XMLUtil {
	//该方法用于从XML配置文件中提取具体类类名，并返回一个实例对象
		public static Object getBean()
		{
			try
			{
				//创建文档对象
				DocumentBuilderFactory dFactory = DocumentBuilderFactory.newInstance();
				DocumentBuilder builder = dFactory.newDocumentBuilder();
				Document doc;							
				doc = builder.parse(new File("AbstractFactoryconfig.xml")); 
			
				//获取包含类名的文本节点
				NodeList nl = doc.getElementsByTagName("className");
	            Node classNode=nl.item(0).getFirstChild();
	            String cName=classNode.getNodeValue();
	            
	            //通过类名生成实例对象并将其返回
	            Class c=Class.forName(cName);
		  	    Object obj=c.newInstance();
	            return obj;
	           }   
	           	catch(Exception e)
	           	{
	           		e.printStackTrace();
	           		return null;
	           	}
			}
}

四、调试、测试及运行结果

简单工厂模式

更改XML文件中的信息继续测试

简单工厂模式测试完成
工厂方法模式


更改XML文件中信息继续测试

工厂方法模式测试完成
抽象工厂模式

更改XML文件中的信息继续测试

抽象工厂模式测试完成

五、经验归纳

完成这次作业时遇到了以下问题：
书写多个关于抽象和实现的代码时，将抽象与实现的关系弄混淆导致程序无法正常运行，对比老师的代码发现了问题修改后程序正常运行。
没有理解将XML文件中的信息传给程序的原理，只会照猫画虎，之后慢慢理解。