深刻理解Java的三种工厂模式

1、简单工厂模式

简单工厂的定义：提供一个建立对象实例的功能，而无须关心其具体实现。被建立实例的类型能够是接口、抽象类，也能够是具体的类

实现汽车接口

public interface Car {
    String getName();
}

奔驰类

public class Benz implements Car {
    @Override
    public String getName() {
        return "Benz";
    }
}

宝马类

public class BMW implements Car {
    @Override
    public String getName() {
        return "BMW";
    }
}

简单工厂，既能生产宝马又能生产奔驰

public class SimpleFactory {
    public Car getCar(String name){
        if (name.equals("BMW")){
            return new BMW();
        }else if (name.equals("benz")){
            return new Benz();
        }else {
            System.out.println("很差意思，这个品牌的汽车生产不了");
            return null;
        }
    }
}

测试类

public class SimpleFactoryTest {
    public static void main(String[] args){
        SimpleFactory simpleFactory = new SimpleFactory();
        Car car = simpleFactory.getCar("BMW");
        System.out.println(car.getName());
    }
}

测试结果

BMW

根据简单工厂的定义，用户只要产品而不在意产品如何生产，看起来好像很完美的样子。但你们想一想，这个世界存在什么都生产的工厂吗？

显然是不存在的，每个汽车品牌都有本身的生产工厂，都有本身生产技术。映射到spring框架中，咱们有不少不少种的bean须要生产，若是只依靠一个简单工厂来实现，那么咱们得在工厂类中嵌套多少个if..else if啊？

并且咱们在代码中生产一辆汽车只是new一下就出来了，但实际操做中殊不知道须要进行多少操做，加载、注册等操做都将体如今工厂类中，那么这个类就会变得紊乱，管理起来也很不方便，因此说每一个品牌应该有本身的生产类。

由于专注，因此专业嘛，这个时候工厂方法就出现了。

2、工厂方法

工厂接口

//定义一个工厂接口，功能就是生产汽车
public interface Factory {
    Car getCar();
}

奔驰工厂

public class BenzFactory implements Factory {
    @Override
    public Car getCar() {
        return new Benz();
    }
}

宝马工厂

public class BMWFactory implements Factory{
    @Override
    public Car getCar() {
        return new BMW();
    }
}

测试类

public class FactoryTest {
   public static void main(String[] args){
       Factory bmwFactory = new BMWFactory();
       System.out.println(bmwFactory.getCar().getName());
       Factory benzFactory = new BenzFactory();
       System.out.println(benzFactory.getCar().getName());
   }
}

测试结果

BMW
Benz

根据上述代码能够看出，不一样品牌的汽车是由不一样的工厂生产的，貌似又是很完美的。但你们看一下测试类，当一我的想要去买一辆宝马汽车的时候（假设没有销售商），那么他就要去找宝马工厂给他生产一辆，过几天又想要买一辆奔驰汽车的时候，又得跑到奔驰工厂请人生产，这无疑就增长了用户的操做复杂性。因此有没有一种方便用户操做的方法呢？这个时候抽象工厂模式就出现了。

3、抽象工厂

 抽象工厂

public abstract class AbstractFactory {

     protected abstract Car getCar();
     
     //这段代码就是动态配置的功能
     //固定模式的委派
     public Car getCar(String name){
        if("BMW".equalsIgnoreCase(name)){
            return new BmwFactory().getCar();
        }else if("Benz".equalsIgnoreCase(name)){
            return new BenzFactory().getCar();
        }else if("Audi".equalsIgnoreCase(name)){
            return new AudiFactory().getCar();
        }else{
            System.out.println("这个产品产不出来");
            return null;
        }
    }
}

默认工厂

public class DefaultFactory extends AbstractFactory {

    private AudiFactory defaultFactory = new AudiFactory();
    
    public Car getCar() {
        return defaultFactory.getCar();
    }

}

宝马工厂

public class BMWFactory extends AbstractFactory {
    @Override
    public Car getCar() {
        return new BMW();
    }
}

奔驰工厂

public class BenzFactory extends AbstractFactory {
    @Override
    public Car getCar() {
        return new Benz();
    }
}

 测试类

public class AbstractFactoryTest {
    public static void main(String[] args) {        
        DefaultFactory factory = new DefaultFactory();        
        System.out.println(factory.getCar("Benz").getName());            
    }
}

测试结果

Benz

根据上述代码能够看出，用户须要一辆汽车，只须要去找默认的工厂提出本身的需求（传入参数），便能获得本身想要产品，而不用根据产品去寻找不一样的生产工厂，方便用户操做。

注：对于设计模式，有些人嗤之以鼻，有些人敬若神明，但我是承认的。

按我粗浅的理解，设计模式的经典之处，就在于解决了编写代码的人和调用代码的人双方的痛楚，不一样的设计模式也只适用于不一样的场景。至于用或者不用，如何使用，那就须要各位看官着重考虑了。

但为了使用而使用是不该该的，细微之处，只有留给你们慢慢品味了。