一、题目分析
（1）、简单工厂模式
使用简单工厂模式模拟女娲（Nvwa）造人（Person），如果传入参数M，则返回一个Man对象，如果传入参数W，则返回一个Woman对象，请实现该场景。现需要增加一个新的Robot类，如果传入参数R，则返回一个Robot对象，对代码进行修改并注意女娲的变化。
（2）、工厂方法模式
海尔工厂(Haier)生产海尔空调(HaierAirCondition)，美的工厂(Midea)生产美的空调(MideaAirCondition) 。使用工厂方法模式描述该场景，绘制类图并编程实现。（3）、抽象工程模式
电脑配件生产工厂生产内存、CPU等硬件设备，这些内存、CPU的品牌、型号并不一定相同，根据下面的“产品等级结构-产品族”示意图，使用抽象工厂模式实现电脑配件生产过程并绘制相应的类图，绘制类图并编程实现。
二、类图设计
（1）、简单工厂模式、
（2）、工厂方法模式
（3）、抽象工程模式
三、程序实现
1、简单工厂模式（SimpleFactoryPattern）
package
SimpleFactoryPattern;
//定义抽象类Person
public abstract class Person {
public void eat(){}//定义抽象方法
public void run() {}
}
package
SimpleFactoryPattern;
//定义一个Man类继承Person类
public class Man extends Person {
public void eat() {
System.out.println("男人吃东西...");
super.eat();//重写父类方法eat()
}
public void run() {
System.out.println("男人跑步..");
super.run();//重写父类方法run()
}
}
package
SimpleFactoryPattern;
//定义一个Woman类继承Person类
public class Woman extends Person {
public void eat() {
System.out.println("女人吃东西..");
super.eat();
}
public void run() {
System.out.println("女 人跑步..");
super.run();
}
}
package
SimpleFactoryPattern;
//定义一个Robot类继承Person类
public class Robot extends Person{
public void eat() {
System.out.println("机器人在吃东西...");
super.eat();//调用父类的eat()方法
}
public void run() {
System.out.println("机器人在跑步...");
super.run();
}
}
package
SimpleFactoryPattern;
//创建Nvwa类来获得人类方法
public class Nvwa {
public static Person getPerson(String people) {
Person person=null;
if(people.equalsIgnoreCase("Man")) {
person=new Man();//将Man类的对象当做Person类来使用
}else if(people.equalsIgnoreCase("Woman")) {
person=new Woman();//将Woman类的对象当做Person类来使用
}else if(people.equalsIgnoreCase("Robot")) {
person=new Robot();//将Robot类的对象当做Person类来使用
}
return person;
}
}
package
SimpleFactoryPattern;
//NvwaMakePeople类实现各种方法
public class NvwaMakePeople {
public static void main(String[] args) {
Person person;//创建一个对象
person=Nvwa.getPerson("Man");
person.eat();//实现方法
person.run();
person=Nvwa.getPerson("Woman");
person.eat();
person.run();
person=Nvwa.getPerson("Robot");
person.eat();
person.run();
}
}2、工厂方法模式（FactoryPattern）
package
FactoryPattern;
//定义一个接口Air
public interface Air {
void work();//抽象方法
}
package
FactoryPattern;
//HaierAir实现接口Air
public class HaierAir implements Air{
public void work() {
System.out.println("HaierAir is working...");
}
}
package
FactoryPattern;
//实现接口Air
public class MideaAir implements Air{
public void work() {
System.out.println("MideaAir is working...");
}
}
package
FactoryPattern;
//定义一个接口AirFactory
public interface AirFactory {
Air
productAir();//Air类的抽象方法
}
package
FactoryPattern;
//实现接口AirFactory
public class HaierFactory implements AirFactory
{
public HaierAir productAir() {
System.out.println("HaierAir Produced...");
return new HaierAir();
}
}
package
FactoryPattern;
//实现接口AirFactory
public class MideaFactory implements AirFactory{
public MideaAir productAir() {
System.out.println("MideaAir produced...");
return new MideaAir();
}
}
package
FactoryPattern;
//FactoryTest来实现各种方法
public class FactoryTest {
public static void main(String[] args) {
AirFactory airfactoryH=new HaierFactory();//将HaierFactory实例转为AirFactory引用
AirFactory airfactoryM=new MideaFactory();//将MideaFactory实例转为AirFactory引用
Air airH=airfactoryH.productAir();//接口Air来创建一个对象airH用airFactoryH来调用productAir()
airH.work();
Air airM=airfactoryM.productAir();
airM.work();
}
}3、抽象工厂模式（AbstactFactoryPattern）
package
AbstractProjectPattern;
//定义一个接口CPU
public interface CPU {
public void describe();
}
package
AbstractProjectPattern;
//实现接口CPU
public class MacCPU implements CPU{
public void describe() {
System.out.println("MacCPU is producing...");
}
}
package
AbstractProjectPattern;
//PcCPU具体实现接口CPU
public class PcCPU implements CPU{
public void describe() {
System.out.println("PcCPU is producing...");
}
}
package
AbstractProjectPattern;
//定义一个接口RAM
public interface RAM {
public void describe();
}
package
AbstractProjectPattern;
//实现接口RAM
public class PcRAM implements RAM{
public void describe() {
System.out.println("PcRAM");
}
}
package
AbstractProjectPattern;
//实现接口RAM
public class MacRAM implements RAM{
public void describe() {
System.out.println("MacRAM");
}
}
package
AbstractProjectPattern;
//定义一个接口ComputerAccessoriesFactory电脑配件工厂
public interface ComputerAccessoriesFactory {
CPU productCPU();//CPU接口类的抽象方法
RAM productRAM();//RAM接口类的抽象方法
}
package
AbstractProjectPattern;
//实现接口ComputerAccessoriesFactory{
public class PcFactory implements ComputerAccessoriesFactory{
public PcCPU productCPU() {
System.out.println("PcCPU produced...");
return new PcCPU();
}
public PcRAM productRAM() {
System.out.println("PRAM produced...");
return new PcRAM();
}
}
package
AbstractProjectPattern;
//实现接口ComputerAccessoriesFactory
public class MacFactory implements ComputerAccessoriesFactory{
public MacCPU productCPU() {
System.out.println("MacCPU produced...");
return new MacCPU();
}
public MacRAM productRAM() {
System.out.println("MacRAM produced...");
return new MacRAM();
}
}
package
AbstractProjectPattern;
public class ComputerTest {
public static void main(String[] args) {
ComputerAccessoriesFactory pcfactory=new PcFactory();//将PcFactory实例转为ComputerAccessoriesFactory引用
ComputerAccessoriesFactory macfactory=new MacFactory();//将PcFactory实例转为ComputerAccessoriesFactory引用
CPU cpu=pcfactory.productCPU();//用工厂创建的对象去调用工厂类CPU接口定义的方法
RAM ram=macfactory.productRAM();
cpu.describe();//调用具体实现CPU中的方法
ram.describe();//调用具体实现RAM中的方法
}
}测试及运行结果
（1）女娲造人
（2）海尔和美的工厂
（3）电脑CPU和RAM
五、经验归纳
本次作业我们做了三种工厂模式，第一种是简单工厂模式：简单工厂模式(Simple Factory Pattern)：又称为静态工厂方法(Static
Factory Method)模式，它属于类创建型模式。在简单工厂模式中，可以根据参数的不同返回不同类的实例。简单工厂模式专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。简单工厂模式包含如下角色：Factory：工厂角色Product：抽象产品角色ConcreteProduct：具体产品角色。简单工厂解决女娲造人的问题，首先我们应该创建一个抽象类或者接口Person类，在Person类中定义抽象方法，再分别创建Man类和Woman类还有Robot类来继承Person类在这些类中分别具体描述在父类中的抽象方法，创建Nvwa类来写一个getPerson()的方法来分别获得每个类中的对象，最后创建了一个测试类，分别来实现方法。
第二种是工厂方法模式：工厂方法模式(Factory Method Pattern)简称工厂模式，也叫虚拟构造器(Virtual Constructor)模式或者多态工厂(Polymorphic
Factory)模式，它属于类创建型模式。
在工厂方法模式中，工厂父类负责定义创建产品对象的公共接口，而工厂子类则负责生成具体的产品对象，这样做的目的是将产品类的实例化操作延迟到工厂子类中完成，即通过工厂子类来确定究竟应该实例化哪一个具体产品类。工厂方法模式包含如下角色：Product：抽象产品ConcreteProduct：具体产品Factory：抽象工厂ConcreteFactory：具体工厂。在海尔工厂和美的工厂实现的题目中，我们先创建两个接口一个是Air,另一个是AirFactory；在Air接口中写一个抽象方法，在AirFactory中产生Air类的创建产品对象的抽象方法。在接口Air中在写两个子类HaierAir和MideaAir来生成具体的产品工作的方法。在接口AirFactory中也有两个子类HaierFactory和MideaFactory来生成具体的产品对象。
第三种是抽象工厂模式：抽象工厂模式(Abstract Factory Pattern)：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。抽象工厂模式又称为Kit模式，属于对象创建型模式。抽象工厂模式包含如下角色：AbstractFactory：抽象工厂
ConcreteFactory：具体工厂，AbstractProduct：抽象产品
ConcreteProduct：具体产品。
