Java--简单工厂模式、工厂方法模式、抽象工厂模式

一．实验目的

1. 熟悉建模工具。
2. 掌握简单工厂模式、工厂方法模式、抽象工厂模式，并进行设计应用。

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

三．简单工厂模式
1.题目分析：Human抽象产品类，它可以是一个接口，也可以是一个抽象类，其中包含了所有产品 具有的业务方法。具体产品类（Man、Women、Robot）是抽象产品类Human接口的子类，是一种具体产品，实现了在Human接口中定义的业务方法。
工厂类HumanFactory,是工厂类，它是整个系统的核心，它提供了静态工厂方法makeHuman（）工厂方法中包含一个字符串类型的参数，在内部业务逻辑根据参数值的不同实例化不同的具体产品类，返回相应的对象。

2.UML类图

3.程序实现

public class Client {
    public static void main(String[] args) {
        try{
            HumanFac h = Nvwa.producehuman("M");
            h.makehuman();
        }catch(Exception e){
            System.out.println(e.getMessage());
        }
    }
}
public interface HumanFac {
    public void makehuman();
}
 public class Nvwa {
    public static HumanFac producehuman(String gender) throws Exception {
        if (gender.equalsIgnoreCase("M")) {
            System.out.println("女娲造出一个男孩！");
            return new Man();
        } else if (gender.equalsIgnoreCase("W")) {
            System.out.println("女娲造出一个女孩！");
            return new Woman();
        } else if (gender.equalsIgnoreCase("R")) {
            System.out.println("女娲造出一个机器人！");
            return new Robot();
        }else{
            throw new Exception("女娲造人出错！");
        }
    }
} 
public class Man implements HumanFac {
    public void makehuman(){
        System.out.println("女娲造人——男人！");
    }
} 
public class Woman implements HumanFac {
    public void makehuman(){
        System.out.println("女娲造人——女人！");
    }
} 
public class Robot implements HumanFac {
    public void makehuman(){
        System.out.println("女娲造人——机器人！");
    }
}

运行结果：

四．工厂方法模式

1. 题目分析：
   （1）创建抽象工厂：AirConditionFactory 抽象方法：productAirCondition()暗指工厂实现类功能为生产空调。
   （2）创建抽象产品：AirCondition（空调） 抽象方法：produced()
   （3）创建具体产品：HaierAirCondition（海尔空调）和MideaAirCondition （美的空调）实现抽象方法produced()：这里可以输出一个信息，提示空调已生产或者正在使用，在后期控制台可以看。（4）创建具体工厂：HaierFactory（海尔工厂）和MideaFactory（美的工厂） 用来生产各自的空调；实现抽象方法：productAir() 返回类型是 Air(空调)，各自工厂，返回的Air也不同。美的工厂返回MideaAirCondition,海尔工厂返回HaierAirCondition.

2. UML类图
   

3. 程序实现

public interface AirConditionFactory {
    AirCondition produceAirCondition();
}
public class HaierAirConditionFactory implements AirConditionFactory {
    public HaierAirCondition produceAirCondition(){
        System.out.println("Haier Air Condition produced!");
        return new HaierAirCondition();
    }
} 
public class MideaAirConditionFactory implements AirConditionFactory{
    public MideaAirCondition produceAirCondition(){
        System.out.println("Midea Air Condition produced！");
        return new MideaAirCondition();
    }
} 
public interface AirCondition {
    void work();
} 
public class HaierAirCondition implements AirCondition {
    public void work(){
        System.out.println("Haier AirCondition is working!");
    }
} 
public class MideaAirCondition implements AirCondition {
    public void work(){
        System.out.println("Midea Air Condition is working!");
    }
} 
public class AirConditionClient {
    public static void main(String[] args) {
        AirCondition haierCondition,mideaCondition;

        AirConditionFactory haierConditionFactory = new HaierAirConditionFactory();
        AirConditionFactory mideaConditionFactory = new MideaAirConditionFactory();

        haierCondition = haierConditionFactory.produceAirCondition();
        mideaCondition = mideaConditionFactory.produceAirCondition();
        haierCondition.work();
        System.out.println();
        mideaCondition.work();
    }
} 

4.运行结果

五．抽象工程模式
1.UML类图

2.程序实现

public interface CPU {
    void describe();
} 
public class PcCPU implements CPU {
    public void describe(){
        System.out.println("PcCPU");
    }
} 
public class MacCPU implements CPU {
    public void describe(){
        System.out.println("MacCPU");
    }
} 
public interface RAM {
    void describe();
} 
public class PcRAM implements RAM {
    public void describe(){
        System.out.println("PcRAM");
    }
} 
public class MacRAM implements RAM{
    public void describe(){
        System.out.println("MacRAM");
    }
} 
public interface ComputerPartsFactory {
    CPU produceCPU();
    RAM produceRAM();
} 
abstract class PcFactory implements ComputerPartsFactory{
    public PcCPU produceCPU(){
        System.out.println("PcCPU produced!");
        return new PcCPU();
    }
    public PcRAM produceRAM(){
        System.out.println("PcRAM produced!");
        return new PcRAM();
    }
} 
abstract class MacFactory implements ComputerPartsFactory {
    public MacCPU produceCPU(){
        System.out.println("MacCPU produced!");
        return new MacCPU();
    }
    public MacRAM produceRAM(){
        System.out.println("MacRAM produced!");
        return new MacRAM();
    }

public class ComputerPartsClient {
    public static void main(String[] args) {
        ComputerPartsFactory factory;
        CPU cpu;
        RAM ram;
        factory = (ComputerPartsFactory) XMLUtil.getBean();
        cpu = factory.produceCPU();
        cpu.describe();
        ram = factory.produceRAM();
        ram.describe();
    }
}

public class ComputerPartsClient {
    public static void main(String[] args) {
        try{
            //ComputerPartsFactory factory = new MacFactory();
            ComputerPartsFactory factory = new PcFactory();
            RAM ram = factory.produceRAM();
            CPU cpu = factory.produceCPU();
            cpu.describe();
            ram.describe();
        }catch(Exception e){
            System.out.println(e.getMessage());
        }
    }
}

运行结果