设计模式——工厂模式

一、定义
     工厂方法模式定义了一个创建对象的接口，但由子类决定实例化的类是哪一个。工厂方法让类把实例化对象推迟到子类。
     抽象工厂模式提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。

二、适用场景
在任何场景下需要生成复杂对象的地方，都可以使用工厂模式。
其次，需要灵活的、可扩展的框架。
三、注意事项
作为一种创建类模式，在任何需要生成复杂的对象的地方，都可以使用工厂模式。有一点需要注意的地方就是复杂的对象适合使用工厂模式，而简单的对象，特别是只需要通过new就可以创建的对象，无需使用工厂模式。如果使用工厂模式，就需要引入一个工厂类，会增加系统的复杂度。
三、代码实现
1、工厂方法模式

public abstract class BMCarFactory{
    abstract Car createBM();
}

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

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

public class BM320Factory extends BMCarFactory{

    @Override
    public Car createBM() {
        return new BM320();
    }
}

public class BM520Factory extends BMCarFactory {
    @Override
    public Car createBM() {
        return new BM520();
    }
}

public class Client {
    public static void main(String[] args){
        BMCarFactory factory = new BM520Factory()
        Car bm520 = factory.createBM();
        bm520.run();
        BMCarFactory factory = new BM320Factory()
        Car bm320 =  factory.createBM();
        bm320.run();
    }
}

2、简单工厂模式

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

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

public class BMCarFactory {

    public static <T extends Car> T createBM(Class<T> c) {
        Car car = null;
        try {
             car = (Car) Class.forName(c.getName()).newInstance();

        } catch (Exception e) {

        }
        return (T) car;
    }
}

public class Client {
    public static void main(String[] args){
        Car bm520 =  BMCarFactory.createBM(BM520.class);
        bm520.run();
        Car bm320 =  BMCarFactory.createBM(BM320.class);
        bm320.run();
    }
}

3、抽象工厂模式

public class HighEngine implements IEngine {
    @Override
    public void engine() {
        System.out.println("高级发动机");
    }
}

public class NormalEngine implements IEngine {
    @Override
    public void engine() {
        System.out.println("普通发动机");
    }
}

public class HighTire implements ITire {
    @Override
    public void tire() {
        System.out.println("高级轮胎");
    }
}

public class NormalTire implements ITire {
    @Override
    public void tire() {
        System.out.println("普通轮胎");
    }
}

public abstract class CarFactory {
    public abstract IEngine createEngine() ;
    public abstract ITire createTire();
}


public class BM520Factory extends CarFactory {


    @Override
    public IEngine createEngine() {
        return new HighEngine();
    }

    @Override
    public ITire createTire() {
        return new NormalTire();
    }
}

public class BM320Factory extends CarFactory {


    @Override
    public IEngine createEngine() {
        return new NormalEngine();
    }

    @Override
    public ITire createTire() {
        return new HighTire();
    }

public class Client {
    public static void main(String[] args){
        CarFactory bm520CarFactory = new BM520Factory();
        System.out.println("宝马520使用的是:");
        bm520CarFactory.createEngine().engine();
        bm520CarFactory.createTire().tire();
        CarFactory bm320CarFactory = new BM320Factory();
        System.out.println("宝马320使用的是:");
        bm320CarFactory.createEngine().engine();
        bm320CarFactory.createTire().tire();
    }
}

四、总结

工厂方法模式：
一个抽象产品类，可以派生出多个具体产品类。
一个抽象工厂类，可以派生出多个具体工厂类。
每个具体工厂类只能创建一个具体产品类的实例。
抽象工厂模式：
多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。
一个抽象工厂类，可以派生出多个具体工厂类。
每个具体工厂类可以创建多个具体产品类的实例。
区别：
工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。
工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。
两者皆可。