三种设计模式
实验内容
（1）简单工厂模式
使用简单工厂模式模拟女娲（Nvwa）造人（Person），如果传入参数M，则返回一个Man对象，如果传入参数W，则返回一个Woman对象，请实现该场景。现需要增加一个新的Robot类，如果传入参数R，则返回一个Robot对象，对代码进行修改并注意女娲的变化。
（2）工厂方法模式
海尔工厂(Haier)生产海尔空调(HaierAirCondition)，美的工厂(Midea)生产美的空调(MideaAirCondition) 。使用工厂方法模式描述该场景，绘制类图并编程实现。
（3）抽象工程模式
电脑配件生产工厂生产内存、CPU等硬件设备，这些内存、CPU的品牌、型号并不一定相同，根据下面的“产品等级结构-产品族”示意图，使用抽象工厂模式实现电脑配件生产过程并绘制相应的类图，绘制类图并编程实现。
- 题目分析
1.在简单工厂模式中，可以根据参数的不同返回不同类的实例。简单工厂模式专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。
简单工厂模式需创建以下几个角色：
2.在工厂方法模式中，工厂父类负责定义创建产品对象的公共接口，而工厂子类则负责生成具体的产品对象，这样做的目的是将产品类的实例化操作延迟到工厂子类中完成，即通过工厂子类来确定究竟应该实例化哪一个具体产品类。
- 工厂角色Nvwa
- 抽象产品角色People
- 具体产品角色Man、Woman、Robot
工厂方法模式需创建以下几个角色：
（1）抽象产品Conditioner
（2）具体产品HaierCon、MideaCon
（3）抽象工厂Factory
（4）具体工厂HaierFactory、MideaFactory
3.抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。
抽象工厂模式需创建以下几个角色：
（1）抽象工厂EFactory
（2）具体工厂PcFactry、MacFactory
（3）抽象产品RAM、CPU
（4）具体产品PcRAM、MacCPU
二、类图设计
1.简单工厂模式
2.工厂方法模式
3.抽象工厂模式
三、程序实现（源代码）
1.简单工厂模式
People.java
package 简单工厂;
public interface People {
public void makePeople();
}
Man.java
package 简单工厂;
public class Man implements People {
public void makePeople() {
System.out.println("女娲创造了一个男人");
}
}
Woman.java
package 简单工厂;
public class Woman implements People{
public void makePeople() {
System.out.println("女娲创造了一个女人");
}
}
Robot.java
package 简单工厂;
public class Robot implements People{
public void makePeople() {
System.out.println("女娲创造了一个机器人");
}
}
Nvwa.java
package 简单工厂;
public class Nvwa {
public static People producePeople(String sex) throws Exception
{
if(sex.equalsIgnoreCase("M"))
{
System.out.println("女娲正在创造男人");
return new Man();
}
else if(sex.equalsIgnoreCase("W"))
{
System.out.println("女娲正在创造女人");
return new Woman();
}
else if(sex.equalsIgnoreCase("R"))
{
System.out.println("女娲正在创造机器人");
return new Robot();
}
else
{
throw new Exception("对不起，此时女娲不造人");
}
}
}
Client.java
package 简单工厂;
public class Client {
public static void main(String args[])
{
try
{
People p;
String sexName=XMLUtilPeople.getSexName();
p=Nvwa.producePeople(sexName);
p.makePeople();
}
catch(Exception e)
{
System.out.println(e.getMessage());
}
}
}
XMLUtilPeople.java
package 简单工厂;
import javax.xml.parsers.*;
import java.io.*;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
public class XMLUtilPeople
{
//该方法用于从XML配置文件中提取品牌名称，并返回该品牌名称
public static String getSexName()
{
try
{
//创建文档对象
DocumentBuilderFactory dFactory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = dFactory.newDocumentBuilder();
Document doc;
doc = builder.parse(new File("SimpleFactoryconfigPeople.xml"));
//获取包含品牌名称的文本节点
NodeList nl = doc.getElementsByTagName("sexName");
Node classNode=nl.item(0).getFirstChild();
String sexName=classNode.getNodeValue().trim();
return sexName;
}
catch(Exception e)
{
e.printStackTrace();
return null;
}
}
}2.工厂方法模式
Conditioner.java
package 工厂方法;
public interface Conditioner {
public void work();
}
Factory.java
package 工厂方法;
public interface Factory {
public Conditioner produceCon();
}
HaierCon.java
package 工厂方法;
public class HaierCon implements Conditioner
{
public void work()
{
System.out.println("海尔空调运行中......");
}
}
MideaCon.java
package 工厂方法;
public class MideaCon implements Conditioner
{
public void work()
{
System.out.println("美的空调运行中......");
}
}
HaierFactory.java
package 工厂方法;
public class HaierFactory implements Factory
{
public Conditioner produceCon()
{
System.out.println("海尔工厂生产海尔电视机空调。");
return new HaierCon();
}
}
MideaFactory.java
package 工厂方法;
public class MideaFactory implements Factory
{
public Conditioner produceCon()
{
System.out.println("美的工厂生产美的空调。");
return new MideaCon();
}
}
Client.java
package 工厂方法;
public class Client
{
public static void main(String args[])
{
try
{
Conditioner c;
Factory factory;
factory=(Factory)XMLUtil.getBean();
c=factory.produceCon();
c.work();
}
catch(Exception e)
{
System.out.println(e.getMessage());
}
}
}
XMLUtil.java
package 工厂方法;
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;
}
}
}3.抽象工厂模式
RAM.java
package 抽象工厂;
public interface RAM{
public void produce();
}
CPU.java
package 抽象工厂;
public interface CPU{
public void make();
}
PcRAM.java
package 抽象工厂;
public class PcRAM implements RAM{
public void produce(){
System.out.println("生产了电脑配件PcRAM......");
}
}
MacRAM.java
package 抽象工厂;
public class MacRAM implements RAM{
public void produce(){
System.out.println("生产了电脑配件MacRAM......");
}
}
PcCPU.java
package 抽象工厂;
public class PcCPU implements CPU{
public void make(){
System.out.println("制作了电脑配件PcCPU......");
}
}
MacCPU.java
package 抽象工厂;
public class MacCPU implements CPU{
public void make(){
System.out.println("制作了电脑配件MacCPU......");
}
}
EFactory.java
package 抽象工厂;
public interface EFactory{
public RAM produceRAM();
public CPU produceCPU();
}
PcFactory.java
package 抽象工厂;
public class PcFactory implements EFactory{
public RAM produceRAM(){
return new PcRAM();
}
public CPU produceCPU(){
return new PcCPU();
}
}
MacFactory.java
package 抽象工厂;
public class MacFactory implements EFactory{
public RAM produceRAM()
{
return new MacRAM();
}
public CPU produceCPU()
{
return new MacCPU();
}
}
Client.java
package 抽象工厂;
public class Client
{
public static void main(String args[])
{
try
{
EFactory factory;
CPU c;
RAM r;
factory=(EFactory)XMLUtil.getBean();
c=factory.produceCPU();
c.make();
r=factory.produceRAM();
r.produce();
}
catch(Exception e)
{
System.out.println(e.getMessage());
}
}
}
XMLUtil.java
package 抽象工厂;
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;
}
}
}四、运行结果
1.简单工厂模式
2.工厂方法模式
3.抽象工厂模式
五、经验归纳
此次实验主要掌握了简单工厂模式、工厂方法模式和抽象工厂模式的应用，对其有了一定的理解。在编写代码过程中，对XML文件不理解浪费了很长时间，通过查看老师给的示例代码并查找了相关资料后，仿照老师给的代码改写了自己的代码才得以实现。此次实验对类图也有了一定的掌握，通过上述三种模式的类图也更加深层次的理解了三种模式其工厂和产品的关系。