谜一般的设计模式：工厂方法模式和抽象工厂模式

工厂方法模式

• 简单描述：也是创建型模式的一种，目的就是对象的创建和使用解耦。不需要关心对象的创建过程，说白了张嘴要就行。

• 应用场景：网上那些冠冕堂皇的应用场景，真的懒得粘了，啥时候补充一个具体的项目应用场景

  工厂方法模式是从简单工厂模式演变过来的，来一段简单的代码。现场需要对接两种类型的摄像头设备，分别为型号A,B,现在要通过两台设备进行拍照并获得照片

简单工厂模式代码

public interface Camera {
    String getPicUrl();
}
public class CameraA implements Camera{
    @Override
    public String getPicUrl() {
        System.out.println("获取A摄像头的图片地址");
    }
}
public class CameraB implements Camera{
    @Override
    public String getPicUrl() {
        System.out.println("获取B摄像头的图片地址");
    }
}
public class CameraFactory{
    public static Camera getCamera(String code){
        if("1".equals(code)){
            return new CameraA();
        }else if("2".equals("code")){
            return new CameraB();
        }
        return null;
    }

    public static void main(String[] args) {
        Camera camera = CameraFactory.getCamera("1");
        if(camera!=null){
            product.getPicUrl();
        }
    }
}

从上面代码分析看，完全符合目前的需求，但是随着业务的增长，现在平台又接入了一台型号是C的摄像机，这样我们对接的时候就要修改cameraFactory里的代码了，如果单纯加这么一个也没啥，但是以后又多了个D、E、F…呢？是不是感觉每次都要改代码，有点不爽？因为我们这样设计违反了开放-封闭原则，所以有了改良版的工厂方法模式，代码如下：

public interface CameraFactory {
    Camera getCamera();
}

public interface Camera {
    String getPicUrl();
}
public class CameraA implements Camera{
    @Override
    public String getPicUrl() {
        System.out.println("获取A摄像头的图片地址");
    }
}
public class CameraB implements Camera{
    @Override
    public String getPicUrl() {
        System.out.println("获取B摄像头的图片地址");
    }
}


public class CameraAFactory implements CameraFactory{
    @Override
    public Camera getCamera() {
        return new CameraA();
    }
}
public class CameraBFactory implements CameraFactory{
   @Override
    public Camera getCamera() {
        return new CameraB();
    }
}
public class Test {
    public static void main(String[] args) {
        CameraFactory a = new CameraAFactory();
        a.getCamera().getPicUrl();
    }
}

来欣赏一下这次的改造，为每个型号的摄像机都分配了一个工厂，这样，新增加一个型号的时候，只要新增对应的工厂类就行了。然而，到这里大家也发现了，如果增加一个新的型号，就要多两个类，一个工厂类，一个具体的型号类。这样随着型号的增多，紧随着类的数量会暴涨，慎重哦！！！

抽象工厂模式

抽象工厂模式就是在工厂模式上进行的扩展，从另一方面来说，工厂方法模式是抽象工厂模式的一个特例。就想正方形和长方形的概念是的，正方形是一个特殊的长方形。

对于上述的需求我们加以改造，如果再加一套门禁设备，我们负责控制门禁设备的开关。则进行改造下，就变成如下代码

public interface BasicFactory {
    BasicCamera getCamera();
    BasicDoorDevice getDoorDevice();
}
public interface BasicCamera {
    String getImgUrl();
}
public interface BasicDoorDevice {
    boolean setDoorStatus(boolean flag);
}
public class FactoryA implements BasicFactory{
    @Override
    public BasicCamera getCamera() {
        return new CameraA();
    }

    @Override
    public BasicDoorDevice getDoorDevice() {
        return new DoorDeviceA();
    }
}
public class FactoryB implements BasicFactory{
    @Override
    public BasicCamera getCamera() {
        return new CameraB();
    }

    @Override
    public BasicDoorDevice getDoorDevice() {
        return new DoorDeviceB();
    }
}
public class CameraA implements BasicCamera {
    @Override
    public String getImgUrl() {
        System.out.println("摄像机A");
        return null;
    }
}
public class CameraB implements BasicCamera {
    @Override
    public String getImgUrl() {
        System.out.println("摄像机B");
        return null;
    }
}
public class DoorDeviceA implements BasicDoorDevice {
    @Override
    public boolean setDoorStatus(boolean flag) {
        System.out.println("控制门禁A");
        return false;
    }
}
public class DoorDeviceB implements BasicDoorDevice {
    @Override
    public boolean setDoorStatus(boolean flag) {
        System.out.println("控制门禁B");
        return false;
    }
}
public class Test {
    public static void main(String[] args) {
        BasicFactory fac = new FactoryA();
        fac.getCamera().getImgUrl();
        fac.getDoorDevice().setDoorStatus(true);
    }
}