设计模式系列教程（05） - 工厂模式

代码已上传至Github，有兴趣的同学可以下载来看看：https://github.com/ylw-github/Java-DesignMode

1. 什么是工厂模式

实现了创建者和调用者分离，工厂模式分为简单工厂、工厂方法、抽象工厂模式

2. 工厂模式好处

1. 工厂模式是我们最常用的实例化对象模式了，是用工厂方法代替new操作的一种模式。

2. 利用工厂模式可以降低程序的耦合性，为后期的维护修改提供了很大的便利。

3. 将选择实现类、创建对象统一管理和控制。从而将调用者跟我们的实现类解耦。

3. 工厂模式分类 3.1 简单工厂模式

简单工厂模式相当于是一个工厂中有各种产品，创建在一个类中，客户无需知道具体产品的名称，只需要知道产品类所对应的参数即可。但是工厂的职责过重，而且当类型过多时不利于系统的扩展维护。 例子：

// 1.定义车的接口类
public interface Car {
    void run();
}

//2.奥迪车
public class AudiCar implements Car {
    @Override
    public void run() {
        System.out.println("我是奥迪...");
    }
}

//3.宝马车
public class BMWCar implements Car {
    @Override
    public void run() {
        System.out.println("我是宝马...");
    }
}

//4.定义工厂
public class CarFactoryDemo1 {

    public static Car createCar(String carName){

        if("audi".equalsIgnoreCase(carName)){
            return new AudiCar();
        }else if("bmw".equalsIgnoreCase(carName)){
            return new BMWCar();
        }
        return null;
    }
}

//5. 运行
public static void main(String[] args) {
    Car audi = CarFactoryDemo1.createCar("audi");
    Car bmw = CarFactoryDemo1.createCar("bmw");

    audi.run();
    bmw.run();
}

运行结果： 简单工厂的优点/缺点：

优点： 简单工厂模式能够根据外界给定的信息，决定究竟应该创建哪个具体类的对象。明确区分了各自的职责和权力，有利于整个软件体系结构的优化。

缺点： 很明显工厂类集中了所有实例的创建逻辑，容易违反GRASPR的高内聚的责任分配原则。

3.2 工厂方法模式

什么是工厂方法模式？ 工厂方法模式Factory Method，又称多态性工厂模式。在工厂方法模式中，核心的工厂类不再负责所有的产品的创建，而是将具体创建的工作交给子类去做。该核心类成为一个抽象工厂角色，仅负责给出具体工厂子类必须实现的接口，而不接触哪一个产品类应当被实例化这种细节。

// 1.定义车的接口类
public interface Car {
    void run();
}

//2.奥迪车
public class AudiCar implements Car {
    @Override
    public void run() {
        System.out.println("我是奥迪...");
    }
}

//3.宝马车
public class BMWCar implements Car {
    @Override
    public void run() {
        System.out.println("我是宝马...");
    }
}

//4.定义工厂接口
public interface CarFactory {

    Car createCar();
}

//5.实现工厂接口
public class AudiCarFactory implements CarFactory {

    @Override
    public Car createCar() {
        return new AudiCar();
    }
}
//6.实现工厂接口
public class BMWCarFactory implements CarFactory {
    @Override
    public Car createCar() {
        return new BMWCar();
    }
}

//5. 运行
public static void main(String[] args) {
   Car audi = new AudiCarFactory().createCar();
   Car bmw = new BMWCarFactory().createCar();
   audi.run();
   bmw.run();
}

运行结果：

3.3 抽象工厂模式

什么是抽象工厂模式？

抽象工厂简单地说是工厂的工厂，抽象工厂可以创建具体工厂，由具体工厂来产生具体产品。 下面使用代码讲解，首先先看下包结构： 看看示例代码：

// 1.定义引擎接口
public interface Engine {

    void start();//启动

    void stop();//关闭
}

//2.定义座椅接口
public interface Chair {
    void transfer(int level);//调整角度
}

//3.定义工厂接口
public interface CarFactory {

    Engine createEngine();//生产引擎
    
    Chair createChair();//生产座椅

}

//4.定义奥迪引擎（比亚迪的类似）
public class AudiEngine implements Engine {
    @Override
    public void start() {
        System.out.println("奥迪一键启停...");
    }

    @Override
    public void stop() {
        System.out.println("奥迪自动关闭...");
    }
}

//5.定义奥迪座椅（比亚迪的类似）
public class AudiChair implements Chair {
    @Override
    public void transfer(int level) {
        System.out.println("奥迪电子调座位...");
    }
}

//6.奥迪生产工厂（比亚迪生产工厂类似）
public class AudiCarFactory implements CarFactory {
    @Override
    public Engine createEngine() {
        return new AudiEngine();
    }

    @Override
    public Chair createChair() {
        return new AudiChair();
    }
}

//7.开始生产
AudiCarFactory audiCarFactory = new AudiCarFactory();
BYDCarFactory bydCarFactory = new BYDCarFactory();
Engine audiEngine = audiCarFactory.createEngine();
Chair audiChair = audiCarFactory.createChair();
Engine bydEngine = bydCarFactory.createEngine();
Chair bydChair = bydCarFactory.createChair();

audiEngine.start();
audiEngine.stop();
audiChair.transfer(100);
bydEngine.start();
bydEngine.stop();
bydChair.transfer(50);

运行结果：

总结