设计模式之工厂模式

╰+攻爆jí腚メ 2021-09-18 04:08 416阅读 0赞

### 工厂模式 ###

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

#### 分类 ####

1.  简单工厂模式
2.  工厂方法模式
3.  抽象工厂模式

#### 面向对象设计基本原则 ####

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

#### 核心本质 ####

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

#### 工厂模式 ####

1.  简单工厂模式

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

1.  工厂方法模式

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

1.  抽象工厂模式

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

#### 简单工厂模式 ####

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

定义实体类：

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