简单工厂、工厂方法、抽象工厂模式比较

工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

一、简单工厂模式

简单工厂的本质是：选择实现
重点在选择，实现是已经做好了的，不需要在简单工厂里面实现。简单工厂的目的在于为客户端来选择相应的实现，从而使客户端和实现之间解耦。这样一来如果具体的实现发生了变化，就不用变动客户端了

使用传统方式创建一辆车

//接口
public interface Car{
    void name();
}

//奥迪车
public class Audi implements Car{
    public void name(){
       System.out.println("我是一辆奥迪车"); 
    }
    
}

//宝马车
public class BMW implements Car{
     public void name(){
    System.out.println("我是一辆宝马车");
    }
}

//传统方式
public class Client{
    public static void main(String[] args){
        Car car=new Audi();
        Car car2=new BMW();
        
        car.name();
        car2.name();
    }
}

这是通过传统方式来造车，那么现在我们来看看使用简单工厂模式如何实现

简单工厂模式

//接口
public interface Car{
    void name();
}

//奥迪车
public class Audi implements Car{
    public void name(){
       System.out.println("我是一辆奥迪车"); 
    }
    
}

//宝马车
public class BMW implements Car{
     public void name(){
    System.out.println("我是一辆宝马车");
    }
}

public class CarFactory{
    //方式一
    public static Car getCar(String car){
        if("宝马".equals(car)){
            return new BMW();
        }else if("奥迪".equals(car)){
            return new Audi();
        }else{
            return null;
        }
    }
    
    //方式二
    public static Car getBMW(){
         return new BMW();
    }
    public static Car getAudi(){
         return new Audi();
    }
}

//简单工厂模式方式，又叫静态工厂模式
public class Client{
    public static void main(String[] args){
       CarFactory carfactory=new CarFactory();
       Car car1=carfactory.getCar("宝马");
        Car car2=carfactory.getCar("奥迪");
        
        car1.name();
        car2.name();
    }
}

比较两种方式的区别，传统方式是客户端自己造车，也就是客户端自己new Car()，而使用简单工厂模式后，是工厂帮助我们来造车，我们只需要调用工厂中的方法就好了。从而达到了一个解耦的目的。
如果了解设计模式中的七大原则，你会发现其实简单工厂模式违反了开闭原则

简单工厂模式的优缺点
优点：
1、帮助封装
2、解耦，实现客户端和具体实现类的解耦

缺点：
1、可能增加客户端的复杂度，比如说我们通过客户端参数来选择具体的实现类，那么就必须让客户端能够理解各个参数所代表的具体功能和含义，这样会增加客户端的使用难度
2、不方便扩展，比如说我现在想增加一款车，那就得修改CarFactory中的业务代码了

二、工厂方法模式

工厂方法模式的本质：要延迟到子类来选择实现。和简单工厂模式差不多，不过工厂方法里面的工厂类依赖于抽象，而不是依赖于具体实现，这里也很好的提现了依赖倒置原则，并且工厂方法模式也符合开闭原则

//接口
public interface Car{
    void name();
}

//奥迪车
public class Audi implements Car{
    public void name(){
       System.out.println("我是一辆奥迪车"); 
    }
    
}

//宝马车
public class BMW implements Car{
     public void name(){
    System.out.println("我是一辆宝马车");
    }
}

//接口
public interface CarFactory{
    Car getCar();
}

//宝马工厂
public class BMWFactory implements CarFactory{
    public Car getCar(){
        return new BMW();
    }
}

//奥迪工厂
public class AudiFactory implements CarFactory{
    public Car getCar(){
        return new Audi();
    }
}

//工厂方法模式
public class Client{
    public static void main(String[] args){
       Car car1= new BMWFactory().getCar();
       Car car2= new AudiFactory().getCar();
       car1.name();
       car2.name();
    }
}

工厂方法模式的优缺点：
优点：
1、可以在不知道具体实现的情况下编程，工厂方法模式可以让你在实现功能的时候，如果需要某个产品的对象，只需要使用产品的接口即可，无需关心具体实现
2、更容易扩展对象的新版本

缺点：
具体产品对象和工厂方法的耦合性

三、抽象工厂模式

抽象工厂模式的本质：选择产品簇的实现。工厂方法模式一般是针对单独的产品对象的创建，而抽象工厂模式注重产品簇对象的创建

//手机接口
public interface IphoneProduct{
    void start();
    void shutdown();
    void callup();
    void sengSMS();
}

//路由器接口
public interface IRouteProduct{
    void start();
    void shutdown();
    void openWifi();
    void setting();
}

//小米手机
public class XiaomiPhone implements IphoneProduct{
    public void start(){
        System.out.println("开启小米手机");
    }
    public void shutdown(){
        System.out.println("关闭小米手机");
    }
    public void calldown(){
        System.out.println("小米手机打电话");
    }
    public void sendSMS(){
       System.out.println("小米手机发短信"); 
    }
}

//华为手机
public class HuaWeiPhone implements IphoneProduct{
    public void start(){
        System.out.println("开启华为手机");
    }
    public void shutdown(){
        System.out.println("关闭华为手机");
    }
    public void calldown(){
        System.out.println("华为手机打电话");
    }
    public void sendSMS(){
       System.out.println("华为手机发短信"); 
    }
}

//小米路由器
public class XiaomiRouter implements IRouteProduct{
    public void start(){
        System.out.println("启动小米路由器");
    }
    public void shutdown(){
        System.out.println("关闭小米路由器");
    }
    public void openWifi(){
        System.out.println("打开小米wifi");
    }
    public void setting(){
        System.out.println("小米设置");
    }
}

//华为路由器
public class HuaWeiRouter implements IRouteProduct{
    public void start(){
        System.out.println("启动华为路由器");
    }
    public void shutdown(){
        System.out.println("关闭华为路由器");
    }
    public void openWifi(){
        System.out.println("打开华为wifi");
    }
    public void setting(){
        System.out.println("华为设置");
    }
}

//抽象工厂
public interface AbsProductFactory{
    IphoneProduct iphoneProduct();
    IRouteProduct routeProduct();
}

//华为工厂
public class HuaWeiFactory implements AbsProductFactory{
    public IphoneProduct iphoneProduct(){
        return new HuaWeiPhone();
    }
    
    public IRouteProduct routeProduct(){
        return new HuaweiRouter();
    }
}

//小米工厂
public class XiaomiFactory implements AbsProductFactory{
     public IphoneProduct iphoneProduct(){
        return new XiaomiPhone();
    }
    
    public IRouteProduct routeProduct(){
        return new XiaomiRouter();
    }
}

public class Client{
    public static void main(String[] args){
        System.out.println("===============小米系列======================")
        XiaomiFactory xiaomiFactory=new XiaomiFactory();
        IphoneProduct iphoneProduct=xiaomiFactory.iphoneProduct();
        iphoneProduct.callup();
        iphoneProduct.sendSMS();
        
        IRouteProduct iRouteProduct=xiaomiFactory.routeProduct();
        iRouteProduct.openWifi();
        
    }
}

抽象工厂的优缺点
优点：
1、分离接口和实现，面向接口编程
2、使得切换产品簇变得容易

缺点：
1、不太容易扩展新的产品，比如说上述代码中，我想在原有的手机、路由器中新增一个电脑产品，那么就需要修改抽象工厂，这就会导致修改所有的工厂实现类
2、容易造成类层次太复杂