设计模式之工厂模式

最新推荐文章于 2024-09-15 16:31:23 发布

原创最新推荐文章于 2024-09-15 16:31:23 发布 · 146 阅读

0 ·

CC 4.0 BY-SA版权

设计模式专栏收录该内容

12 篇文章

订阅专栏

工厂模式

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

面向对象设计基本原则

OCP 开闭原则：对扩展开放，对修改关闭
DIP 依赖倒转原则：针对接口编程，不要针对实现编程
LoD 迪米特法则：与直接朋友通信，避免与陌生人通信

核心本质

实例化对象，用工厂方法代替new操作
将选择实现类、创建对象统一管理和空值。从而将调用者和我们的实现者解耦

工厂模式

简单工厂模式

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

工厂方法模式

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

抽象工厂模式

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

简单工厂模式

简单工厂模式也叫静态工厂模式，就是工厂类一般使用静态方法，通过接收参数的不同来返回不同的实例对象
对于增加新产品无能为力，不修改代码，无法扩展

定义实体类：

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();
    }

}