【java】Factory工厂模式的应用

一、简介

 

工厂模式（factory）是设计模式的一种，它类比了工厂中的生产方式：对外只提供产品的选择，整个产品的生成由内部完成。

工厂模式由工厂方法和抽象工厂两种实现方式。

 

工厂模式简单来说，就是使用一个工厂类来代替new关键字，完成对各种对象的实例化。这样做的好处，就是可以避免重复使用new关键字。在实际编程过程中，对于人来说，重复的简单工作容易出现错误，而机器不会，这也是工厂模式的最大意义之一。

 

二、工厂方法（factory method）

 

首先，我们需要的是产品，假设产品共有三种，分别为car、motorbike和bike。

 

建立一个Product接口：

publicinterfaceProduct {

    publicabstractvoid report();//输出产品生产成功的消息

}

随后是三种具体产品的实现：

 

Car.java

publicclassCar implementsProduct{

 
    @Override

    publicvoid report() {

       System.out.println("A car was created!");

    }

}

Motorbike.java

publicclassMotorbike implementsProduct{

 
    @Override

    publicvoid report() {

       System.out.println("A motorbike was created!");

    }

}

Bike.java

publicclassBike implementsProduct{


    @Override

    publicvoid report() {

       System.out.println("A bike was created!");

    }

}

有了三种产品之后，就可以建立工厂类了。

 

1.简单工厂

 

简单工厂是工厂方法的一种，使用简单的判断条件来判断需要生产哪种产品。

 

建立工厂类如下：

publicclassSimpleFactory {

   
    public Product produce(intindex) {

       if (index == 0) {

           returnnew Car();

       }elseif(index== 1) {

           returnnew Motorbike();

       }elseif(index== 2) {

           returnnew Bike();

       }else{

           returnnull;//异常处理

       }

    }

}

在具体使用时：

publicclassMain {

 
    publicstaticvoid main(String[] args) {

       SimpleFactorySimpleFactory= newSimpleFactory();

       Productproduct1= SimpleFactory.produce(0);//生产汽车

       Productproduct2= SimpleFactory.produce(1);//生产摩托车

       Productproduct3= SimpleFactory.produce(2);//生产自行车

      

       //报告生产信息

       product1.report();

       product2.report();

       product3.report();

    }

}

输出信息为：

A car was created!

A motorbike was created!

A bike was created!

 

该方法的思路比较简单，只需要记住产品对应的序号即可，但是每当需要增加一种产品的时候，就必须要更改工厂类中的判断条件。

 

2.工厂方法（多产品工厂）

 

工厂类也可以不是依靠接收特定标识而生产产品，而是直接使用不同的方法来生产不同的产品。

创建工厂类如下：

publicclassFactoryMethod {

   

    public Product createCar() {

       returnnew Car();//生产汽车

    }

   

    public ProductcreateMotorbike() {

       returnnew Motorbike();//生产摩托车

    }

   

    public Product createBike() {

       returnnew Bike();//生产自行车

    }

}

 

在使用时：

FactoryMethod FactoryMethod = new FactoryMethod();

Product product4 = FactoryMethod.createCar();//生产汽车

Product product5 = FactoryMethod.createMotorbike();//生产摩托车

Product product6 = FactoryMethod.createBike();//生产自行车

 

//报告生产信息

product4.report();

product5.report();

product6.report();

输出信息为：

A car was created!

A motorbike was created!

A bike was created!

 

该方法相比于简单工厂，更加易于使用，因为采用不同的方式创建不同产品对于用户来说更加容易理解。但是，简单工厂的缺点也仍然存在。

 

三、抽象工厂

 

通过将工厂类抽象化，就能够实现多个工厂，并且各个工厂之间可以有一个或多个产品。按照具体工厂类的产品数量，抽象工厂方法还能够细分，但是这里不再划分。

 

首先，建立一个抽象工厂类：

publicabstractclassAbstractFactory {

   
    publicabstract ProductcreateCar();

   
    publicabstract ProductcreateMotorbike();

   
    publicabstract ProductcreateBike();

}

它的具体实现类可以是多个不同的工厂，这些工厂同样能够生产出汽车、摩托车、自行车，但是具体的产品可以不同。

接下来，我们需要更多的产品：

 

Car2.java

publicclassCar2 implementsProduct{

 
    @Override

    publicvoid report() {

       System.out.println("A car2 was created!");

    }

}

Motorbike2.java

publicclassMotorbike2 implementsProduct{

 

    @Override

    publicvoid report() {

       System.out.println("A motorbike2 was created!");

    }

}

Bike2.java

publicclassBike2 implementsProduct{

 

    @Override

    publicvoid report() {

       System.out.println("A bike2 was created!");

    }

}

为了方便，我们直接将前面例子中的FactoryMethod作为工厂之一：

publicclassFactoryMethod extends AbstractFactory{

   
    public Product createCar() {

       returnnew Car();

    }

   
    public Product createMotorbike() {

       returnnew Motorbike();

    }

   
    public Product createBike() {

       returnnew Bike();

    }

}

随后，再创建一个新的工厂：

publicclassFactoryMethod2 extends AbstractFactory{

   
    public Product createCar() {

       returnnew Car2();

    }

   
    public ProductcreateMotorbike() {

       returnnew Motorbike2();

    }

   
    public Product createBike() {

       returnnew Bike2();

    }

}

实际使用时：

AbstractFactory FactoryMethod = new FactoryMethod();

AbstractFactory FactoryMethod2 = new FactoryMethod2();

Product product4 = FactoryMethod.createCar();//生产汽车

Product product5 = FactoryMethod.createMotorbike();//生产摩托车

Product product6 = FactoryMethod.createBike();//生产自行车

Product product7 = FactoryMethod2.createCar();//生产另一种汽车

Product product8 = FactoryMethod2.createMotorbike();//生产另一种摩托车

Product product9= FactoryMethod2.createBike();//生产另一种自行车

 

//报告生产信息

product4.report();

product5.report();

product6.report();

product7.report();

product8.report();

product9.report();

输出信息为：

A car was created!

A motorbike was created!

A bike was created!

A car2 was created!

A motorbike2 was created!

A bike2 was created!

 

可见，两个工厂分别生产了不同的汽车、摩托车和自行车产品，当然，也可以生产部分一样的产品。

抽象工厂方法相比于其他方法更加易于扩展，并且具有更大的灵活性。但是，缺点就是类数量可能会过于庞大。