简单易懂的工厂模式_工厂模式易懂-优快云博客

本文链接：https://blog.youkuaiyun.com/yyxxppyypp/article/details/111883602

工厂顾名思意就是用来生产产品的。
通过工厂模式，我们可以减少使用new 的操作。而转而调用工厂帮我们生产对象。
实现生产者与调用者的分离。
下面我们来用实例来写一下三种工厂模式

假设我们现在去买车。

简单工厂模式

车有不同的型号。
所以我们给它一个接口
车接口

public interface Car {
    void name();
}

不同的车实现这个接口
Tesla

public class Tesla implements Car {
    @Override
    public void name() {
        System.out.println("Tesla");
    }
}

五菱宏光

public class Wuling implements Car {

    @Override
    public void name() {
        System.out.println("五菱宏光");
    }
}

我们去买车，不是直接去原厂地要而是找工厂。
生产车的工厂。

public class CarFactory {
    public static Car getCar(String name){
    //通过判断 输入的参数，从而造不同的车
        if("五菱".equals(name)){
            return new Wuling();
        }else if("Tesla".equals(name)){
            return new Tesla();
        }else
            return null;
    }
}

现在我们去买车

public class Consumer {
    public static void main(String[] args) {
    //通过工厂的方法  代替我们手动new 的操作。
        Car car = CarFactory.getCar("五菱");
        Car tesla = CarFactory.getCar("Tesla");
        car.name();
        tesla.name();
    }
}

结果
在这里插入图片描述
结构图

uml 图

简单的工厂模式通过判断输入的参数而造不同的车。
而如果我又要造宝马车，我就需要去改动工厂的源代码。
这是我们不想看到的。使用另外一种模式解决这个问题。
工厂方法模式。

工厂方法模式

既然 有新车。 那工厂直接不生产车，交给具体的厂商去生产。 
将工厂也进行一层封装

具体的代码会是这样
同样会有车接口。
但会增加特定的工厂与工厂接口。
工厂接口

public interface CarFactory {
    Car getCar();
}

Tesla 工厂

public class TeslaFactory implements CarFactory{
    @Override
    public Car getCar() {
        return new Tesla();
    }
}

五菱工厂

public class WulingFactory implements CarFactory{

    @Override
    public Car getCar() {
        return new Wuling();
    }
}

现在我们去拿车就直接去不同的工厂里要了。

public class Consumer {
    public static void main(String[] args) {
        Car car = new TeslaFactory().getCar();
        Car car1 = new WulingFactory().getCar();
        car.name();
        car1.name();
    }
}

而现在如果我们要去买宝马车。就不需要修改工厂的代码。直接实现工厂接口就可以了。然后去找宝马工厂拿车。
具体会是这样

 Car bmw = new BMWFactory().getCar();
        bmw.name();

结构图
在这里插入图片描述
新增的宝马车。
uml 图

这种模式，我们的代码量一下子多了很多。

我们接着说下一种工厂模式。

抽象工厂模式

刚才都是生产同一系列产品，车子。如果要生产不同类型的产品，
比如 华为 有 手机 也有路由器，小米也有手机，也有路由器
那该咋办？

抽象工厂能够解决这种问题。

简单的讲就是又增加了一层封装。

同样以实例来说明。

手机接口

public interface IPhoneProduct {
    void start();//开机功能
}

路由器接口

public interface IRouterProduct {
    void openWifi();//打开wifi 功能
}

产品工厂接口

public interface IProductFacory {
	//接口 抽象的产品工厂。
    //生产手机
    IPhoneProduct iphoneProduct();
    //生产路由器
    IRouterProduct irouterProduct();
}

不同的厂商分别实现接口
小米实现手机路由器工厂实现

public class XiaomiPhone implements IPhoneProduct {
    @Override
    public void start() {
        System.out.println("小米开机中");
    }
}

public class XiaomiRouter implements IRouterProduct {
    @Override
    public void openWifi() {
        System.out.println("小米路由器打开wifi");
    }
}

public class XiaoMiFactory implements IProductFacory {
    @Override
    public IPhoneProduct iphoneProduct() {
        return new XiaomiPhone();
    }

    @Override
    public IRouterProduct irouterProduct() {
        return new XiaomiRouter();
    }
}

华为实现接口

public class HuaweiPhone implements IPhoneProduct {
    @Override
    public void start() {
        System.out.println("华为开机中");
    }
}

public class HuaweiRouter implements IRouterProduct {
    @Override
    public void openWifi() {
        System.out.println("华为路由器打开wifi");
    }
}

public class HuaweiFactory implements IProductFacory {
    @Override
    public IPhoneProduct iphoneProduct() {
        return new HuaweiPhone();
    }

    @Override
    public IRouterProduct irouterProduct() {
        return new HuaweiRouter();
    }
}

客户端去使用

public class Client {
    public static void main(String[] args) {
        IPhoneProduct iPhoneProduct = new HuaweiFactory().iphoneProduct();
        iPhoneProduct.start();//华为开机中

        IRouterProduct iRouterProduct = new XiaoMiFactory().irouterProduct();
        iRouterProduct.openWifi();//小米路由器打开wifi
    }
}