Java——》谈谈你对工厂模式的理解

一、工厂模式的作用

作用：帮助我们 创建对象

二、工厂模式的分类

根据需要创建的对象的复杂度，可以把工厂模式分为 简单工厂 、 工厂方法 、抽象工厂。

1、简单工厂

只有一个工厂，根据不同的参数而返回不同的实例
专门定义一个类，负责创建其他类的实例
被创建的实例通常都具有共同的父类

/**
 * 简单工厂
 */
public class SimpleFactory {

    public static void main(String[] args) {
        // 根据对应的类型返回相关产品
        CarFactory.createCar("奥迪").run();
        CarFactory.createCar("Byd").run();
    }
}

// 定义公共的接口
interface Car {
    void run();
}

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

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

// 创建对应的简单工厂类
class CarFactory {
    public static Car createCar(String type) {
        if ("奥迪".equals(type)) {
            return new Audi();
        } else if ("Byd".equals(type)) {
            return new Byd();
        } else {
            throw new RuntimeException("该产品不能生产");
        }
    }
}

DateFormat类也用到了简单工单模式

2、工厂方法

定义一个用户创建对象的接口，让子类决定实例化哪个类，工厂方法使一个类的实例化延迟到了其子类中。

/**
 * 工厂方法模式
 */
public class FactoryMethod {

    public static void main(String[] args) {
        new AudiCarFactory().createCar().run();
        new BydCarFactory().createCar().run();
    }


    public interface Car {
        void run();
    }

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

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

    public interface CarFactory {
        Car createCar();
    }

    // 扩展的工厂
    public static class AudiCarFactory implements CarFactory {
        @Override
        public Car createCar() {
            return new Audi();
        }
    }

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

3、抽象工厂

上面的两种方式实现的工厂都是生产同一大类的产品，如果要实现生产不同类型的产品这时我们就可以用抽象工厂模式来实现。

package com.example.test.factory;

/**
 * 抽象工厂：多个产品族
 */
public class AbstractFactory {

    public static void main(String[] args) {
        Car car = new LuxuryEngineCarFacory().createCar();
        Engine engine = new LuxuryEngineCarFacory().createEngine();
        car.run();
        engine.run();
    }

    // 抽象工厂
    public interface AbstarctComponentFactory {
        Car createCar();

        Engine createEngine();
    }

    public static class LuxuryEngineCarFacory implements AbstarctComponentFactory {
        @Override
        public Engine createEngine() {
            return new LuxuryEngineFactory().createEngine();
        }

        @Override
        public Car createCar() {
            return new BydCarFactory().createCar();
        }
    }

    public static class LowEngineCarFacory implements AbstarctComponentFactory {
        @Override
        public Car createCar() {
            return new AudiCarFactory().createCar();
        }

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

    // 汽车产品族
    public interface Car {
        void run();
    }

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

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

    public interface CarFactory {
        Car createCar();
    }

    // 扩展的工厂
    public static class AudiCarFactory implements CarFactory {
        @Override
        public Car createCar() {
            return new Audi();
        }
    }

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

    // 发动机产品族
    public interface Engine {
        void run();
    }

    public static class LuxuryEngine implements Engine {
        @Override
        public void run() {
            System.out.println("豪华版发动机...");
        }
    }

    public static class LowEngine implements Engine {
        @Override
        public void run() {
            System.out.println("低配版发动机...");
        }
    }

    public interface EngineFactory {
        Engine createEngine();
    }

    public static class LuxuryEngineFactory implements EngineFactory {
        @Override
        public Engine createEngine() {
            return new LuxuryEngine();
        }
    }

    public static class LowEngineFactory implements EngineFactory {
        @Override
        public Engine createEngine() {
            return new LowEngine();
        }
    }
}

三、简单工厂 VS 工厂方法

1. 简单工厂只有一个工厂，而工厂方法有多个工厂
2. 简单工厂不支持扩展，而工厂方法支持扩展，扩展的方式就是添加对应的工厂类即可
3. 简单工厂代码复杂度低，工厂方法代码复杂度高