Java设计模式（二）之工厂模式（Factory）

目录

简单工厂

静态工厂

抽象工厂

---

简单工厂

先创建两个类Car和Bike，看成是工厂要生成的两类产品，代码如下：

/**
 * Created by leboop on 2020/5/23.
 */
public interface Movable {
    void go();
}

/**
 * Created by leboop on 2020/5/23.
 */
public class Car implements Movable{
    @Override
    public void go() {
        System.out.println("Car going!");
    }
}

/**
 * Created by leboop on 2020/5/23.
 */
public class Bike implements Movable {
    @Override
    public void go() {
        System.out.println("Bike going!");
    }
}

 通常做法是在客户端直接通过new方式创建各类产品对象，但是很多时候需要在创建对象前后做一些其他操作，比如权限管理等，这些代码如果暴露在客户端是不合适的，所以可以将这些代码整合到单独的一个简单工厂类中实现：

/**
 * Created by leboop on 2020/5/23.
 */
public class SimpleFactory {
    public  Car createCar() {
        /*
         * 创建对象前的一些预处理
         */
        Car car = new Car();
        /*
         * 创建对象后的一些预处理
         */

        return car;
    }

    public Bike createBike() {
        /*
         * 创建对象前的一些预处理
         */
        Bike bike = new Bike();
        /*
         * 创建对象后的一些预处理
         */
        return bike;
    }
}

简单工厂类中可以做很多复杂操作。客户端就可以如下简单调用了：

/**
 * Created by leboop on 2020/5/23.
 */
public class Main {
    public static void main(String[] args) {
        SimpleFactory factory = new SimpleFactory();
        Movable car = factory.createCar();
        car.go();
        Movable bike = factory.createBike();
        bike.go();
    }
}

这样对使用的客户来说非常友好。

 

静态工厂

        所谓静态工厂，指的是工厂类中创建实例的方法是静态的，这样的话就可以直接通过工厂类调用创建实例了，而不需要先实例化工厂类了，代码如下：

/**
 * Created by leboop on 2020/5/23.
 */
public class StaticFactory {
    public static Car createCar() {
        /*
         * 创建对象前的一些预处理
         */
        Car car = new Car();
        /*
         * 创建对象后的一些预处理
         */

        return car;
    }

    public static Bike createBike() {
        /*
         * 创建对象前的一些预处理
         */
        Bike bike = new Bike();
        /*
         * 创建对象后的一些预处理
         */
        return bike;
    }
}

客户端代码如下：

/**
 * Created by leboop on 2020/5/23.
 */
public class StaticFactoryMain {
    public static void main(String[] args) {
        Movable car=StaticFactory.createCar();
        car.go();
        Movable bike=StaticFactory.createBike();
        bike.go();
    }
}

现在就不用如下创建工厂类了：

StaticFactoryfactory = new StaticFactory();

简单工厂存在的一个弊端是每次新增一个产品，比如现在要新增火车，就需要修改原来的工厂类StaticFactory，能不能不修改原来的工厂类呢？可以的。可以通过抽象工厂实现，为每类产品创建一个单独工厂，该工厂仅生产对应类别产品。

 

抽象工厂

        先创建一个抽象工厂（也可以使用接口），含有一个可以创建所有产品的抽象方法，代码如下：

/**
 * Created by leboop on 2020/5/23.
 */
public abstract class AbstractFactory {
    abstract Movable create();
}

 为每个产品创建一个具体的抽象类，只生产对应的产品，比如CarFactory只生产Car，代码如下：

/**
 * Created by leboop on 2020/5/23.
 */
public class CarFactory extends  AbstractFactory{
    @Override
    Movable create() {
        /*
         * 创建对象前的一些预处理
         */
        Car car = new Car();
        /*
         * 创建对象后的一些预处理
         */

        return car;
    }
}

/**
 * Created by leboop on 2020/5/23.
 */
public class BikeFactory extends AbstractFactory{
    @Override
    Movable create() {
        /*
         * 创建对象前的一些预处理
         */
        Bike bike = new Bike();
        /*
         * 创建对象后的一些预处理
         */

        return bike;
    }
}

 客户端代码如下：

/**
 * Created by leboop on 2020/5/23.
 */
public class AbstractFactoryMain {
    public static void main(String[] args) {
        CarFactory carFactory=new CarFactory();
        Movable car=carFactory.create();
        car.go();

        BikeFactory bikeFactory=new BikeFactory();
        Movable bike=bikeFactory.create();
        bike.go();
    }
}

现在如有新增产品火车的时候，就不需要修改原来的工厂类代码。具体如下：

创建产品Train的类

/**
 * Created by leboop on 2020/5/23.
 */
public class Train implements Movable {
    @Override
    public void go() {
        System.out.println("train going!");
    }
}

创建该产品的工厂类

/**
 * Created by leboop on 2020/5/23.
 */
public class TrainFactory extends AbstractFactory {
    @Override
    Movable create() {

        /*
         * 创建对象前的一些预处理
         */
        Train train = new Train();
        /*
         * 创建对象后的一些预处理
         */
        return train;
    }
}

在客户端代码中添加创建train的代码，如下：

/**
 * Created by leboop on 2020/5/23.
 */
public class AbstractFactoryMain {
    public static void main(String[] args) {
        CarFactory carFactory=new CarFactory();
        Movable car=carFactory.create();
        car.go();

        BikeFactory bikeFactory=new BikeFactory();
        Movable bike=bikeFactory.create();
        bike.go();
        
        TrainFactory trainFactory=new TrainFactory();
        Movable train=trainFactory.create();
        train.go();
    }
}

从上面我们能看到，使用了抽象工厂模式之后，新增产品时只需要修改客户端少量代码，新增两个类即可，总体来看，新增的代码有所增加，但是不要修改原先的工厂类代码，隔离性非常好。