三种工厂模式Java实现

一、题目分析

（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：具体产品。