设计模式之简单工厂模式、工厂方法模式、抽象工程模式

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

二.类图
1.简单工厂模式

2.工厂方法模式

3.抽象工程模式

三.具体代码
1.简单工厂模式
(1)PersonFactory接口

 package 程序设计方法与优化.简单工厂模式;
public interface PersonFactory {
    public void makepeople();
}

（2 ) Men类

package 程序设计方法与优化.简单工厂模式;
public class Men implements PersonFactory{
    public void makepeople(){
        System.out.println("女娲制造了男人！");
    }
}

(3) Women类

package 程序设计方法与优化.简单工厂模式;
public class Women implements PersonFactory{
    public void makepeople(){
        System.out.println("女娲制造了女人！");
    }
}

(4) Robot类

package 程序设计方法与优化.简单工厂模式;
public class Robot implements PersonFactory {
    public void makepeople(){
        System.out.println("女娲制造了机器人！");
    }
}

（5)Nvwa类

package 程序设计方法与优化.简单工厂模式;
public class Nvwa {
    public static PersonFactory getpeople(String str){
           PersonFactory  people=null;
           if(str.equalsIgnoreCase("M")){
               people=new Men();
               System.out.println("出现了男人");
           }else if(str.equalsIgnoreCase("W")){
               people=new Women();
               System.out.println("出现了女人");
           }else if(str.equalsIgnoreCase("R")){
               people=new Robot();
               System.out.println("出现了机器人");
           }
           return people;
    }
}

(6)Quest类

package 程序设计方法与优化.简单工厂模式;
public class Quest {
    public static void main(String[] args) {
        PersonFactory p=Nvwa.getpeople("R");
        p.makepeople();
    }
    

2. 工厂方法模式
   (1) RobotFactory接口

package 程序设计方法与优化.工厂方法模式;
public interface RobotFactory {
    public void produce();
}

(2 ) Factory接口

package 程序设计方法与优化.工厂方法模式;
public interface Factory {
    RobotFactory produceAirCondition();
}

(3) Haier类

package 程序设计方法与优化.工厂方法模式;
public class Haier implements RobotFactory {
    public void produce() {
        System.out.println("海尔空调");
    }
}

(4) Midea类

package 程序设计方法与优化.工厂方法模式;
public class Midea implements RobotFactory {
    @Override
    public void produce() {
        System.out.println("美的空调");
    }
}

(5) HaierAirCondition类

package 程序设计方法与优化.工厂方法模式;
public class HaierAirCondition implements Factory {
   public RobotFactory produceAirCondition(){
       System.out.print("海尔工厂生产了");
       return new Haier();
    }
}

(6) MideaAirCondition类

package 程序设计方法与优化.工厂方法模式;
public class MideaAirCondition implements Factory {
    public RobotFactory produceAirCondition(){
        System.out.print("美的工厂生产了");
        return new Midea();
    }
}

(7) Test类

package 程序设计方法与优化.工厂方法模式;
public class Test {
    public static void main(String[] args) {
        RobotFactory robotfactory;
        Factory factory;
        factory=new HaierAirCondition();
        robotfactory=factory.produceAirCondition();
        robotfactory.produce();
        System.out.println(" ");
        factory=new MideaAirCondition();
        robotfactory=factory.produceAirCondition();
        robotfactory.produce();
    }
}

3. 抽象工程模式
   (1) EFactory接口

public interface EFactory {
    public RAM produceRAM();
    public CPU produceCPU();
}

(2) RAM接口

public interface RAM {
    public void show();
}

(3) CPU接口

public interface CPU {
    public void change();
}

（4) PcFactory类

public class PcFactory implements EFactory {
    public PcRAM produceRAM(){
        return new PcRAM();
    }
    public PcCPU produceCPU(){
        return new PcCPU();
    }
}

(5) MacFactory类

public class MacFactory implements EFactory {
    public MacRAM produceRAM(){
        return new MacRAM();
    }
    public MacCPU produceCPU(){
        return new MacCPU();
    }
}

(6) MacRAM类

public class MacRAM implements RAM {
    public void show(){
        System.out.println("Mac内存正在运行中……");
    }
}

(7) MacCPU类

public class MacCPU implements CPU {
    public void change(){
        System.out.println("MacCPU正在使用中……");
    }
}

(8) PcRAM类

public class PcRAM implements RAM{
    public void show(){
        System.out.println("Pc内存正在运行中……");
    }
}

(9)PcCPU类

public class PcCPU implements CPU{
    public void change(){
        System.out.println("PcCPU正在使用中……");
    }
}

（10)Client类

public class Client {
    public static void main(String[] args) {
        try{
            EFactory factory;
            RAM ram;
            CPU cpu;
            factory=(EFactory)XMLUtil.getBean();
            ram=factory.produceRAM();
            ram.show();
            cpu=factory.produceCPU();
            cpu.change();
            ram=factory.produceRAM();
            ram.show();
            cpu=factory.produceCPU();
            cpu.change();
        }catch (Exception e){
            System.out.println(e.getMessage());
        }
     }
}

四.总结
1.简单工厂模式
在简单工厂模式中，可以根据参数的不同返回不同类的实例。它专门定义一个类来负责创建其他类的实例，被创建的实例通常具有共同的父类。一般是在xml文件中改写参数，我是直接在程序中传不同的参数就会有不同的结果。
2.工厂方法模式
在工厂方法模式中，工厂父类负责定义创建产品对象的公共接口，工厂子类负责生成具体的产品对象，目的是将产品类的实例化延迟到工厂子类中完成。符合“开闭原则”
3.抽象工程模式
在抽象工程模式中，分产品等级结构（产品的继承结构）和产品族（由一个工厂生产的，位于不同产品等级结构中）。提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

望采纳！