简单工厂模式

简介

工厂模式是一种常用的对象创建型设计模式，此模式的核心精神是封装类中不变的部分，提取其中个性化善变的部分为独立类，通过依赖注入以达到解耦、复用和方便后期维护拓展的目的。

代码实现

说简单一点，工厂模式的作用就是根据不同的参数实例化出不同的类，就相当于你想吃零食的时候你不需要直接生产制作零食，你只需要告诉“工厂”想要某某某零食，生产制作的工作交给工厂来做，你只需要从“工厂”那拿到直接吃就行了，在代码中实现的思路也就是这样。

这里为了方便编码，我们以工厂生产车的例子来演示。

/**
 * @Author beifengtz
 * @Site www.beifengtz.com
 * @Date Created in 10:25 2018/11/20
 * @Description: 车
 */
public interface Vehicle {
    // 鸣笛
    void blow();

    // 跑
    void run();

    // 点火起步
    void start();
}

这里我给车接口定义三个动作分别是鸣笛、跑和点火起步，然后我再定义三类车去实现车的接口，分别是小轿车、公交车、越野车。

小轿车

/**
 * @Author beifengtz
 * @Site www.beifengtz.com
 * @Date Created in 10:29 2018/11/20
 * @Description: 小轿车
 */
public class Car implements Vehicle {
    @Override
    public void blow() {
        System.out.println("小轿车鸣笛~~~~~");
    }

    @Override
    public void run() {
        System.out.println("小轿车奔跑ing~~~~~");
    }

    @Override
    public void start() {
        System.out.println("小轿车点火起步~~~~~");
    }
}

公交车

/**
 * @Author beifengtz
 * @Site www.beifengtz.com
 * @Date Created in 10:30 2018/11/20
 * @Description: 公交车
 */
public class Bus implements Vehicle {
    @Override
    public void blow() {
        System.out.println("公交车鸣笛~~~~~");
    }

    @Override
    public void run() {
        System.out.println("公交车奔跑ing~~~~~");
    }

    @Override
    public void start() {
        System.out.println("公交车点火起步~~~~~");
    }
}

越野车

/**
 * @Author beifengtz
 * @Site www.beifengtz.com
 * @Date Created in 10:31 2018/11/20
 * @Description: 越野车
 */
public class SUV implements Vehicle {
    @Override
    public void blow() {
        System.out.println("越野车鸣笛~~~~~");
    }

    @Override
    public void run() {
        System.out.println("越野车奔跑ing~~~~~");
    }

    @Override
    public void start() {
        System.out.println("越野车点火起步~~~~~");
    }
}

接下来我们需要一个工厂来生产上面的车型

/**
 * @Author beifengtz
 * @Site www.beifengtz.com
 * @Date Created in 10:35 2018/11/20
 * @Description: 车工厂
 */
public class VehicleFactory {
    enum VehicleType{
        CAR,BUS,SUV
    }
    public Vehicle make(VehicleType type){
        Vehicle vehicle = null;
        switch (type){
            case BUS:
                vehicle = new Bus();
                break;
            case CAR:
                vehicle = new Car();
                break;
            case SUV:
                vehicle = new SUV();
                break;
        }
        return vehicle;
    }
}

测试

/**
 * @Author beifengtz
 * @Site www.beifengtz.com
 * @Date Created in 10:40 2018/11/20
 * @Description: 工厂测试类
 */
public class FactoryTest {

    public static void main(String[] args) {
        // 实例化工厂类
        VehicleFactory vehicleFactory = new VehicleFactory();
        // 生产小轿车
        System.out.println("************************下面是小轿车***********************");
        Vehicle car = vehicleFactory.make(VehicleFactory.VehicleType.CAR);
        car.blow();
        car.start();
        car.run();
        // 生产公交车
        System.out.println("************************下面是公交车***********************");
        Vehicle bus = vehicleFactory.make(VehicleFactory.VehicleType.BUS);
        bus.blow();
        bus.start();
        bus.run();
        // 生产越野车
        System.out.println("************************下面是越野车***********************");
        Vehicle SUV = vehicleFactory.make(VehicleFactory.VehicleType.SUV);
        SUV.blow();
        SUV.start();
        SUV.run();
    }
}

控制台打印结果

************************下面是小轿车***********************
小轿车鸣笛~~~~~
小轿车点火起步~~~~~
小轿车奔跑ing~~~~~
************************下面是公交车***********************
公交车鸣笛~~~~~
公交车点火起步~~~~~
公交车奔跑ing~~~~~
************************下面是越野车***********************
越野车鸣笛~~~~~
越野车点火起步~~~~~
越野车奔跑ing~~~~~

工厂方法模式

简介

工厂方法模式是简单工厂的进一步深化，在工厂方法模式中，我们不再提供一个统一的工厂类来创建所有的对象，而是针对不同的对象提供不同的工厂。也就是说每个对象都有一个与之对应的工厂。我们还是以上面的车来举例。（这也是我最喜欢用的一种设计模式）

我们需要生产的车以及车型仍然不变

public interface Vehicle {
    // 鸣笛
    void blow();

    // 跑
    void run();

    // 点火起步
    void start();
}

小轿车

public class Car implements Vehicle {
    @Override
    public void blow() {
        System.out.println("小轿车鸣笛~~~~~");
    }

    @Override
    public void run() {
        System.out.println("小轿车奔跑ing~~~~~");
    }

    @Override
    public void start() {
        System.out.println("小轿车点火起步~~~~~");
    }
}

公交车

public class Bus implements Vehicle {
    @Override
    public void blow() {
        System.out.println("公交车鸣笛~~~~~");
    }

    @Override
    public void run() {
        System.out.println("公交车奔跑ing~~~~~");
    }

    @Override
    public void start() {
        System.out.println("公交车点火起步~~~~~");
    }
}

越野车

public class SUV implements Vehicle {
    @Override
    public void blow() {
        System.out.println("越野车鸣笛~~~~~");
    }

    @Override
    public void run() {
        System.out.println("越野车奔跑ing~~~~~");
    }

    @Override
    public void start() {
        System.out.println("越野车点火起步~~~~~");
    }
}

工厂类我们需要做一些改变了，首先需要一个总的车工厂

public interface VehicleFactory {
    Vehicle getVehicle();
}

然后需要对每一个车型定义不同的工厂，并且每一个工厂都需要去复写getVehicle()方法。

小轿车工厂类

public class CarFactory implements VehicleFactory {
    @Override
    public Vehicle getVehicle() {
        return new Car();
    }
}

公交车工厂类

public class BusFactory implements VehicleFactory {
    @Override
    public Vehicle getVehicle() {
        return new Bus();
    }
}

越野车工厂类

public class SUVFactory implements VehicleFactory {
    @Override
    public Vehicle getVehicle() {
        return new SUV();
    }
}

测试

我们在使用的时候只需要实例化不同的工厂类就可以了

public class FactoryTest {

    public static void main(String[] args) {
        // 生产小轿车
        System.out.println("************************下面是小轿车***********************");
        Vehicle car = new CarFactory().getVehicle();
        car.blow();
        car.start();
        car.run();
        // 生产公交车
        System.out.println("************************下面是公交车***********************");
        Vehicle bus = new BusFactory().getVehicle();
        bus.blow();
        bus.start();
        bus.run();
        // 生产越野车
        System.out.println("************************下面是越野车***********************");
        Vehicle SUV = new SUVFactory().getVehicle();
        SUV.blow();
        SUV.start();
        SUV.run();
    }
}

测试结果和简单工厂一样

************************下面是小轿车***********************
小轿车鸣笛~~~~~
小轿车点火起步~~~~~
小轿车奔跑ing~~~~~
************************下面是公交车***********************
公交车鸣笛~~~~~
公交车点火起步~~~~~
公交车奔跑ing~~~~~
************************下面是越野车***********************
越野车鸣笛~~~~~
越野车点火起步~~~~~
越野车奔跑ing~~~~~

使用场景

客户端不需要知道它所创建的对象的类。例子中我们不知道每个图片加载器具体叫什么名，只知道创建它的工厂名就完成了床架过程。
客户端可以通过子类来指定创建对应的对象。以上场景使用于采用工厂方法模式。

抽象工厂模式

简介

抽象工厂模式是工厂方法的进一步深化，在这个模式中的工厂类不单单可以创建一个对象，而是可以创建一组对象。这是和工厂方法最大的不同点。（实际应用中局限性比较大，因为它并不符合开闭原则）

代码实现

个人觉得抽象工厂与上面两种方法最大的不同就是把需要生产的实体进行了属性或方法拆分，就好比现实生活中生产车的厂商不一定需要生产该车需要的所有零部件或子系统，对于在编码中的变化，相当于一个工厂不一定要一次性生产出整个车。

这里我们把整个车分成几个板块，分别是引擎系统、操作系统、安全系统（三个板块仅仅是简单举例~~）

/**
 * 引擎系统
 */
public interface EngineSystem {
    void engine();
}

/**
 * 操作系统
 */
 public interface OperatingSystem {
    void operating();
}

/**
 * 安全系统
 */
public interface SecuritySystem {
    void security();
}

这里只以小轿车举例，其他的类似

public class CarEngineSystem implements EngineSystem {
    @Override
    public void engine() {
        System.out.println("这是小轿车的引擎系统~~~~~");
    }
}

public class CarOperatingSystem implements OperatingSystem {
    @Override
    public void operating() {
        System.out.println("这是小轿车的操作系统~~~~");
    }
}

public class CarSecurtySystem implements SecuritySystem {
    @Override
    public void security() {
        System.out.println("这是小轿车的安全系统~~~~");
    }
}

下面定义一个抽象工厂接口

/**
 * 抽象系统工厂接口，该工厂可以创建三个子系统
 */
public interface SystemFactory {
    EngineSystem makeEngineSystem();
    OperatingSystem makeOperatingSystem();
    SecuritySystem makeSecuritySystem();
}

小轿车抽象工厂类

public class CarAbstractFactory implements SystemFactory {
    @Override
    public EngineSystem makeEngineSystem() {
        return new CarEngineSystem();
    }

    @Override
    public OperatingSystem makeOperatingSystem() {
        return new CarOperatingSystem();
    }

    @Override
    public SecuritySystem makeSecuritySystem() {
        return new CarSecurtySystem();
    }
}

测试

真对不同车型生产不同类型的子系统

public class FactoryTest {

    public static void main(String[] args) {
        // 实例化小轿车抽象工厂
        SystemFactory systemFactory = new CarAbstractFactory();

        // 生产小轿车的三个子系统
        EngineSystem engineSystem = systemFactory.makeEngineSystem();
        OperatingSystem operatingSystem = systemFactory.makeOperatingSystem();
        SecuritySystem securitySystem = systemFactory.makeSecuritySystem();

        engineSystem.engine();
        operatingSystem.operating();
        securitySystem.security();
    }
}

测试结果

这是小轿车的引擎系统~~~~
这是小轿车的操作系统~~~~
这是小轿车的安全系统~~~~

使用场景

和工厂方法一样客户端不需要知道它所创建的对象的类。
需要一组对象共同完成某种功能时。并且可能存在多组对象完成不同功能的情况。
系统结构稳定，不会频繁的增加对象。（因为一旦增加就需要修改原有代码，不符合开闭原则）

本站文章除注明转载/出处外，均为本站原创或翻译，转载前请务必署名,转载请标明出处
最后编辑时间为: 2018/11/20 11:41

微信公众号浏览体验更佳，在这里还有更多优秀文章为你奉上，快来关注吧！

北风IT之路

设计模式（四）——工厂模式

简单工厂模式

简介

代码实现

测试

工厂方法模式

简介

测试

使用场景

抽象工厂模式

简介

代码实现

测试

使用场景