Java设计模式之工厂模式

Java设计模式之工厂模式

---

前言

工厂模式，我这里总要讲两种常用的工厂方法模式和抽象工厂模式；我会用我们生活中接触的比较多的车来比较这2种模式的区别。

工厂方法模式

这里用宝马和奔驰两种车来模拟场景，假设车需要引擎(engine),离合器(clutch)两种部件组成；

我们首先用工厂来产品这2个部件,通过createEngine(int type)来创建相应的引擎，通过createClutch(int type)来创建相应的离合器;

public class CarPartsFactory {
public final static int ENGINE_BENCHI_TYPE = 0;
public final static int ENGINE_BMW_TYPE = 1;
public final static int CLUTCH_BENCHI_TYPE = 2;
public final static int CLUTCH_BMW_TYPE = 3;

public static Engine createEngine(int type) {
    Engine engine = null;
    switch (type) {
        case ENGINE_BENCHI_TYPE:
            engine = new BenchiEngine();
        case ENGINE_BMW_TYPE:
            engine = new BMWEngine();
            break;
    }
    return engine;
}

public static Clutch createClutch(int type) {
    Clutch clutch = null;
    switch (type) {
        case CLUTCH_BENCHI_TYPE:
            clutch = new BenchiClutch();
            break;
        case CLUTCH_BMW_TYPE:
            clutch = new BMWClutch();
            break;
    }
    return clutch;
    }
}

引擎(Engine)的相关代码

public interface Engine {
    void start();
}

public class BenchiEngine implements Engine {
    @Override
    public void start() {
        System.out.println("benchi engine start....");
    }
}

public class BMWEngine implements Engine {
    @Override
    public void start() {
        System.out.println("BMW engine start...");
    }
}

离合器(Clutch)的相关代码

public interface Clutch {
    void press();
}

public class BenchiClutch implements Clutch {
    @Override
    public void press() {
        System.out.println("benchi clutch press....");
    }
}

public class BMWClutch implements Clutch {
    @Override
    public void press() {
        System.out.println("bmw clutch press...");
    }
}

有了上面的基本部件，现在就可以组装Car

public class Car {
private Engine engine;
private Clutch clutch;

public Car(Engine engine, Clutch clutch) {
    this.engine = engine;
    this.clutch = clutch;
}

public void start() {
    engine.start();
        clutch.press();
    }
}

如果奔驰的离合器只能搭配奔驰的引擎，宝马的离合器只能搭配宝马的引擎使用；工厂方法模式就会出现Car跑步起来的后果了。现在介绍一种抽象工厂模式也是工厂模式的一种，我们把能一起搭配的部件放同一个工厂里,组成Car的一套部件（能搭配的部件)成为产品族，然后产品族里里的单个产品成为产品结构；

抽象工厂模式

首先创建的抽象工厂，后面会让具体的工厂类继承该抽象工厂

public abstract class AbsFactory {
    public abstract Engine createEngine();

    public abstract Clutch createClutch();
}
public class BenchiFactory extends AbsFactory {
    @Override
    public Engine createEngine() {
        return new BenchiEngine();
    }

    @Override
    public Clutch createClutch() {
        return new BenchiClutch();
    }
}
public class BMWFactory extends AbsFactory {
    @Override
    public Engine createEngine() {
        return new BMWEngine();
    }

    @Override
    public Clutch createClutch() {
        return new BMWClutch();
    }
}

一些部件的代码同工厂方法模式，我就不贴了，如果你感兴趣你可以看我的demo地址，现在可以组装Car啦

public class Car {
    private Engine engine;
    private Clutch clutch;
    private AbsFactory factory;

public Car(AbsFactory factory) {
    this.factory = factory;
}

public void start() {
    if (factory != null) {
        this.engine = factory.createEngine();
        this.clutch = factory.createClutch();
    }
    engine.start();
        clutch.press();
    }
}

抽象工厂模式完美的解决了部件不匹配的情况，我们可以更加具体的业务采用适合的工厂模式。
如果你觉得不错的话，例子的demo地址