设计模式之工厂模式

工厂模式

功能： 实现创建者和调用者的分离

分类

1. 简单工厂模式

2. 工厂方法模式

3. 抽象工厂模式

面向对象设计基本原则

1. OCP 开闭原则 ： 对扩展开放，对修改关闭

2. DIP 依赖倒转原则 ： 针对接口编程，不要针对实现编程

3. LoD 迪米特法则 ：与直接朋友通信，避免与陌生人通信

核心本质

• 实例化对象，用工厂方法代替new操作

• 将选择实现类、创建对象统一管理和空值。从而将调用者和我们的实现者解耦

工厂模式

1. 简单工厂模式

用来生产同一等级结构中的结构产品。（对于增加新的产品，需要修改已有代码）

2. 工厂方法模式

用来生产同一等级结构中的固定产品。（支持增加任意产品）

3. 抽象工厂模式

用来生产不用产品族的全部产品。（对于新增加的产品，无能为力；支持增加产品族）

简单工厂模式

• 简单工厂模式也叫静态工厂模式，就是工厂类一般使用静态方法，通过接收参数的不同来返回不同的实例对象

• 对于增加新产品无能为力，不修改代码，无法扩展

定义实体类：

public interface Car {
    void run();
}

public class Audi implements Car {
    @Override
    public void run() {
        System.out.println("奥迪 is running ...");
    }
}

public class Byd implements Car {
    @Override
    public void run() {
        System.out.println("比亚迪 is running...");
    }
}

工厂类：

/**
 * 简单工厂模式（违反开闭原则）
 */
public class CarFactory {

    private CarFactory() {

    }

    public static Car createCar(String type) {
        if ("audi".equals(type)) {
            return createAudi();
        } else if ("byd".equals(type)) {
            return createByd();
        } else {
            return null;
        }
    }

    public static Car createAudi() {
        return new Audi();
    }

    public static Car createByd() {
        return new Byd();
    }

}

Main:

/**
 * 简单工厂模式
 */
public class Main {

    public static void main(String[] args) {

        Car audi = CarFactory.createCar("audi");
        Car byd = CarFactory.createCar("byd");

        audi.run();
        byd.run();

    }
}

工厂方法模式

• 为了避免简单工厂模式的缺点，不完全满足 OCP

• 工厂方法模式和简单工厂模式的最大不同在于，简单工厂模式只有一个（对于一个项目或者一个模块而言）工厂类，工厂方法模式有一组实现了相同接口的工厂类

抽象接口：

public interface Car {
    void run();
}

public interface CarFactory {
    Car createCar();
}

实体类:

public class Audi implements Car {

    @Override
    public void run() {
        System.out.println("奥迪 is running ...");
    }

}

public class Benz implements Car {

    @Override
    public void run() {
        System.out.println("奔驰 is running...");
    }

}

public class Byd implements Car {

    @Override
    public void run() {
        System.out.println("比亚迪 is running...");
    }

}

工厂类实现：

public class AudiFactory implements CarFactory {
    @Override
    public Car createCar() {
        return new Audi();
    }
}

public class BenzFactory implements CarFactory {
    @Override
    public Car createCar() {
        return new Benz();
    }
}

public class BydFactory implements CarFactory {
    @Override
    public Car createCar() {
        return new Byd();
    }
}

Main:

/**
 * 工厂方法模式（将行为抽象，将创建车的行为抽象） 
 */
public class Main {

    public static void main(String[] args) {

        // 面向接口编程
        Car audi = new AudiFactory().createCar();
        Car byd = new BydFactory().createCar();

        audi.run();
        byd.run();

    }
}

抽象工厂模式

• 用来生产不用产品族的全部产品。（对于新增加的产品，无能为力；支持增加产品族）

• 抽象工厂模式是工厂方法模式的升级版本，在有多个业务品种、业务分类时，通过抽象工厂模式生产需要的对象是一种非常好的解决方案

抽象类：

/**
 * 抽象工厂模式
 */
public interface CarFactory {

    Engine createEngine();

    Tyre createTyre();

    Seat createSeat();
}

Engine 接口及实现类：

public interface Engine {

    void run();

    void start();
}

class LuckEngine implements Engine {

    @Override
    public void run() {
        System.out.println("跑的快");
    }

    @Override
    public void start() {
        System.out.println("启动快");
    }

}

class LowEngine implements Engine {

    @Override
    public void run() {
        System.out.println("跑的慢");
    }

    @Override
    public void start() {
        System.out.println("启动慢");
    }

}

Seat 接口以及实现类：

public interface Seat {

    void release();
}

class LuckSeat implements Seat {

    @Override
    public void release() {
        System.out.println("高端软座椅");
    }

}

class LowSeat implements Seat {

    @Override
    public void release() {
        System.out.println("低端应座椅");
    }

}

Tyre 接口以及实现类：

public interface Tyre {
    void resolve();
}

class LuckTyre implements Tyre {

    @Override
    public void resolve() {
        System.out.println("山地防滑");
    }

}

class LowTyre implements Tyre {

    @Override
    public void resolve() {
        System.out.println("山地不防滑");
    }

}

工厂类：

public class LowCarFactory implements CarFactory {

    @Override
    public Engine createEngine() {
        return new LowEngine();
    }

    @Override
    public Tyre createTyre() {
        return new LowTyre();
    }

    @Override
    public Seat createSeat() {
        return new LowSeat();
    }

}

public class LuckCarFactory implements CarFactory {

    @Override
    public Engine createEngine() {
        return new LuckEngine();
    }

    @Override
    public Tyre createTyre() {
        return new LuckTyre();
    }

    @Override
    public Seat createSeat() {
        return new LuckSeat();
    }

}

Main:

/**
 * 抽象工厂模式
 */
public class Main {

    public static void main(String[] args) {
        CarFactory factory = new LuckCarFactory();
        Engine engine = factory.createEngine();
        engine.start();
        engine.run();
    }

}