设计模式篇|工厂模式

1.工厂模式简介

实现了创建者和调用者的分离。其核心本质是用工厂方法代替new操作，将选择实现类、创建对象统一管理和控制，从而将调用者和实现类解耦。

详细分类

• 简单工厂模式（也叫静态工厂模式）
  用来生产同一等级结构中的任意产品。（对应增加新的产品，需要修改已有代码）
• 工厂方法模式
  用来生产同一等级结构中的固定产品（支持增加任意产品）
• 抽象工厂模式
  用来生产不同产品族的全部产品（对于增加新的产品，无能为力，支持增加产品族）。

2.面向对象设计的基本原则

• 单一职责原则（Single Responsibility Principle）：每一个类应该专注于做一件事。
• 里氏替换原则（Liskov Substitution Principle）：父类存在的地方，子类是可以替换。
• 开闭原则（Open-Closed Principle）：软件的实体应当对添加操作开放，对修改操作关闭。
• 依赖倒置（Dependence Inversion Principle）：实现尽量依赖抽象，不依赖具体实现。例如，A-->B，A和B都是具体实现类，此时A应该和B实现的接口进行调用，不应该直接与B接触。
• 接口隔离原则（Interface Segregation Principle）：应当为客户端提供尽可能小而专的接口，而不是提供大的全的接口。
• 迪米特法则（Law Of Demeter）：又叫最少知识原则，一个软件实体应当尽可能少的与其他实体发生相互作用。例如，应该多和你的朋友练习，少和陌生人联系。
• 组合/聚合复用原则（Composite/Aggregate Reuse Principle CARP）：尽量使用合成/聚合达到复用，尽量少用继承。原则： 一个类中有另一个类的对象

3.简单工厂模式实现

• 创建接口

public interface Car {

    void run();
}

• 创建实现类
  Audi.java

public class Audi implements Car {

    @Override
    public void run() {
        System.out.println("奥迪在跑!");
    }
}

Benz.java

public class Benz implements Car {
    @Override
    public void run() {
        System.out.println("奔驰在跑!");
    }
}

• 创建工厂

public class CarFactory {

    public static Car createCar(String type){
        if ("奥迪".equals(type)){
            return new Audi();
        }else if ("奔驰".equals(type)){
            return new Benz();
        }else{
            return null;
        }
    }
}

• 测试

public class Test02 {

    public static void main(String[] args) {

        Car car1 = CarFactory.createCar("奥迪");
        Car car2 = CarFactory.createCar("奔驰");

        if (car1 != null){
            car1.run();
        }
        if (car2 != null){
            car2.run();
        }

    }
}

运行结果

image.png

简单工厂模式总结

优点：
实现简单，外部只需传入名字即可获取对象，方便了调用者。

缺点：
简单工厂模式无法添加新的功能，如果添加新功能则违反了面向对象设计原则中的开闭原则。

4.工厂方法模式

• 创建接口Car

public interface Car {

    void run();
}

• 创建接口实现类

public class Audi implements Car {

    @Override
    public void run() {
        System.out.println("奥迪在跑!");
    }
}

public class Benz implements Car {
    @Override
    public void run() {
        System.out.println("奔驰在跑!");
    }
}

• 创建接口CarFactory

public interface CarFactory {

    Car createCar();
}

• 创建工厂实现类

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 Client {

    public static void main(String[] args) {
        Car c1 = new AudiFactory().createCar();
        Car c2 = new BenzFactory().createCar();

        c1.run();
        c2.run();
    }
}

运行结果：

image.png

工厂方法模式总结
优点：
易于扩展，添加新功能只需创建新的实体类以及实现类即可。符合开闭原则。
缺点：
接口与类的数量急剧增大

5.抽象工厂模式

抽象工厂模式主要用于生产产品族，下面我们使用汽车的生产为例

下列代码编写会有些违反规范，主要用作示例

• 创建发动机接口 Engine.java 以及实现类

public interface Engine {

    //跑
    void run();

    //启动
    void start();
}

class LuxuryEngine 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.java 以及实现类

public interface Seat {

    //按摩
    void massage();
}

class LuxurySeat implements Seat{

    @Override
    public void massage() {
        System.out.println("可以按摩");
    }
}

class LowSeat implements Seat{

    @Override
    public void massage() {
        System.out.println("不能按摩");
    }
}

• 创建轮胎接口 Tyre.java 以及实现类

public interface Tyre {

    //旋转
    void revolve();
}

class LuxuryTyre implements Tyre{

    @Override
    public void revolve() {
        System.out.println("磨损慢");
    }
}

class LowTyre implements Tyre{

    @Override
    public void revolve() {
        System.out.println("磨损快");
    }
}

• 创建汽车工厂

public interface CarFactory {

    Engine createEngine();

    Seat createSeat();

    Tyre createTyre();
}

• 高端汽车以及低端汽车实现类

public class LuxuryCarFactory implements CarFactory {

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

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

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

public class LowCarFactory implements CarFactory {
    @Override
    public Engine createEngine() {
        return new LowEngine();
    }

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

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

• 测试

public class Client {

    public static void main(String[] args) {

        //创建高端汽车
        CarFactory factory = new LuxuryCarFactory();
        Engine engine = factory.createEngine();
        Seat seat = factory.createSeat();
        Tyre tyre = factory.createTyre();

        engine.run();
        engine.start();

        seat.massage();

        tyre.revolve();
    }
}

运行效果图

image.png