Java设计模式——工厂设计模式

• 定义
• 简单工厂模式
• • 利用反射实现简单工厂设计模式
• 工厂方法模式

什么是工厂设计模式？
生活中：批量生产产品
Java中：批量生产对象

好处：
为了解耦合，把对象的创建者与对象的使用者分开。

Java：
没有工厂，需要对象，自己new。
如果把生产（创建）对象与使用对象分开了，可以解耦合

public class TestFactory {
    @Test
    public void test03(){
        Car c = SimpleFactory.getCar("奔驰");
        c.run();
    }
    @Test
    public void test01(){
        //没有工厂
        BMW b = new BMW();
        //使用对象，调用方法
        b.run();
    }
}
    interface Car{
        void run();
    }
    class BMW implements Car{
        @Override
        public void run() {
            System.out.println("宝马让你在车里面哭");
        }
    }
    class Benz implements Car{
        @Override
        public void run() {
            System.out.println("奔驰让你在车盖上哭");
        }
    }
    class Audi implements Car{
        @Override
        public void run() {
            System.out.println("奥迪让你在...");
        }
    }//如果增加了Audi类，则需要继续更改SimpleFactory类
    
class SimpleFactory{
    public static Car getCar(String type){
        if("宝马".equals(type)){
            return new BMW();
        }else if("奔驰".equals(type)){
            return new Benz();
        }
        return null;
    }
}

优点：代码比较简洁
缺点：如果增加新的产品类型，需要修改工厂类，违反了面向对象的一个开发原则：对扩展开放，对修改关闭。

为了解决对于工厂类的修改，可以使用反射实现工厂类。

public class TestFactory3 {
    public static void main(String[] args) throws Exception {
        Vehicle c = SimpleFactory3.getVehicle("main.Aoto");
        c.run();//奥拓

        Vehicle c2 = SimpleFactory3.getVehicle("main.QQ");
        c2.run();//qq车
    }
}
interface Vehicle {
    void run();
}
class QQ implements Vehicle {
    @Override
    public void run() {
        System.out.println("qq车");
    }
}

class Aoto implements Vehicle {
    @Override
    public void run() {
        System.out.println("奥拓");
    }
}

class SimpleFactory3 {
    public static Vehicle getVehicle(String className) throws Exception {
        Class clazz = Class.forName(className);
        return (Vehicle) clazz.newInstance();
    }
}

（1）生产对象与使用对象分开
（2）如果增加新产品，且不需要修改原来的工厂类

public class TestFactory2 {
    public static void main(String[] args) {
        BaoMaFactory bf = new BaoMaFactory();
        Che c = bf.getChe();
        c.run();//宝马
    }
}
interface Che{
    void run();
}
class BaoMa implements Che{
    @Override
    public void run() {
        System.out.println("宝马");
    }
}

class BenChi implements Che{
    @Override
    public void run() {
        System.out.println("奔驰");
    }
}
class AoDi implements Che{
    @Override
    public void run() {
        System.out.println("奥迪");
    }
}

interface GongChang{
   public abstract Che getChe();
}
class BaoMaFactory implements GongChang{
    @Override
    public Che getChe() {
        return new BaoMa();
    }
}
class BenChiFactory implements  GongChang{
    @Override
    public Che getChe() {
        return new BenChi();
    }
}

优点：遵循了增加新产品，不修改原来的类的原则，
缺点：工厂类过多