设计模式（一）工厂模式_自行车工厂设计模式-CSDN博客

本文链接：https://blog.csdn.net/weixin_42898446/article/details/108792710

在学习完面向对象编程之后，学会了创建对象使用关键字"new" 来创建对象，但是这样创建对象在一个复杂且有多个对象需要被创建的时候显得有些冗余和耦合度过高，不易被人理解。工厂模式就是被用来去创建对象的

一、简单工厂模式。

简单工厂模式是基于工厂方法模式的一种特殊情况，简单工厂模式通俗易懂的话说就是：“基于抽象商品去构建具体的商品，之后再使用工厂类根据不同的情况去创建具体的商品供客户端去调用”具体的代码如下

抽象商品

//抽象商品接口   就以宝马车为例子
public interface Bmw {
    public void run();
}

以下是具体的实现类

public class BmwX3 implements Bmw{
    @Override
    public void run() {
        System.out.println("宝马x3正在制造");
    }
}

public class BmwX5 implements Bmw{
    @Override
    public void run() {
        System.out.println("宝马x5正在制造");
    }
}

具体的工厂

public class SimpleFactory {
    public static Bmw CreateCar(String sign){
        switch (sign){
            case "x3" :
                return new BmwX3();
            case "x5" :
                return new BmwX5();
            default:
                break;
        }
        return null;
    }
}

客户端调用代码

public class Client {
    public static void main(String[] args) {
        Bmw x3 = SimpleFactory.CreateCar("x3");
        x3.run();
        Bmw x5 = SimpleFactory.CreateCar("x5");
        x5.run();
    }
}

简单工厂的缺点：首先在商品接口中如果有新的商品需要被添加增加实现类即可，但是在添加完实现类之后再工厂类中需要添加新的case进行判断去选择创建新的返回具体的商品对象。每一次的添加新的商品都需要对工厂类进行大动干戈这样写不太好违背了开闭原则。所以进一步优化推出工厂方法模式

二、工厂方法模式

简单工厂模式是一个工厂创建多个商品实例但是当有多个不同类型的商品时就变得不合时宜。例如大众品牌下边有奔驰，奥迪，兰博基尼等具体的品牌，如果这时候还使用一个厂去生产太过于繁琐，就如现实生活中的收购，让具体的工厂去生产具体的商品。具体的代码如下：

抽象产品定义

public interface CarProduct {
    public void introduce();
}

具体的产品

public class Bike implements CarProduct{
    @Override
    public void introduce() {
        System.out.println("我是自行车");
    }
}

public class Bmw implements CarProduct{
    @Override
    public void introduce() {
        System.out.println("我是宝马车");
    }
}

public class Train implements CarProduct{
    @Override
    public void introduce() {
        System.out.println("我是火车");
    }
}

工厂接口定义

public interface ProductFactory {
    public CarProduct generate();
}

具体工厂的实现

//自行车工厂
public class BikeFactory implements ProductFactory{
    @Override
    public CarProduct generate() {
        return new Bike();
    }
}

//宝马车工厂
public class BmwFactory implements ProductFactory{
    @Override
    public CarProduct generate() {
        return new Bmw();
    }
}

//火车工厂实现
public class TrainFactory implements ProductFactory{
    @Override
    public CarProduct generate() {
        return new Train();
    }
}

客户端调用

public class Client {
    public static void main(String[] args) {
        //自行车工厂生产自行车
        ProductFactory bikeFactory = new BikeFactory();
        bikeFactory.generate().introduce();

        //宝马工厂生产 宝马车
        ProductFactory bmwFactory = new BmwFactory();
        bmwFactory.generate().introduce();

        //火车工厂生产 火车
        ProductFactory trainFactory = new TrainFactory();
        trainFactory.generate().introduce();
    }
}

总结：工厂方法模式个人感觉就是将工厂进一步的剥离抽象定义接口规则。当有新的产品生产的时候直接新建工厂实现接口并且返回新创建的产品的一个过程。单一工厂负责创建单一产品。功能更加清晰且明了

三、抽象工厂模式

当工厂再一次升级需要在一辆车上组装不同的轮胎和不同的发动机则有不同维度的商品抽象。所以需要工厂去组装这些不同维度的商品，代码如下:

抽象发动机以及具体发动机产品

//抽象 发动机 产品
public abstract class Engine {
    public abstract void equipment();
}

// 具体的 雪域 发动机
public class HongDouEngine extends Engine{
    @Override
    public void equipment() {
        System.out.println("装备雪域发动机");
    }
}

public class KunLunEngine extends Engine{
    @Override
    public void equipment() {
        System.out.println("装配昆仑发动机");
    }
}

抽象轮胎以及具体轮胎产品

//抽象 轮胎 产品
public abstract class Tires {
    public abstract void product();
}

//具体的红豆 轮胎产品
public class HongDouTires extends Tires{
    @Override
    public void product() {
        System.out.println("使用红豆 牌轮胎");
    }
}

// 具体的米奇 轮胎
public class KunLunTires extends Tires{
    @Override
    public void product() {
        System.out.println("使用昆仑 牌的轮胎");
    }
}

抽象工厂以及工厂的具体实现

//抽象的 汽车工厂 需要具体的汽车工厂去组装具体的 轮胎和 发动机
public interface  CarFactory {
    public Engine CreateEngine();

    public Tires CreateTires();
}

//给宝马 320 使用 红豆发动机 和红豆 轮胎
public class Bmw320Factory implements CarFactory{
    @Override
    public Engine CreateEngine() {
        return new HongDouEngine();
    }

    @Override
    public Tires CreateTires() {
        return new HongDouTires();
    }
}

//给宝马X5 装配 昆仑发动机 以及昆仑 轮胎
public class BmwX5Factory implements CarFactory{
    @Override
    public Engine CreateEngine() {
        return new KunLunEngine();
    }

    @Override
    public Tires CreateTires() {
        return new KunLunTires();
    }
}

客户端调用

//客户端调用
public class Client {
    public static void main(String[] args) {
        System.out.println("===========================>宝马320组装");
        CarFactory bmw320 = new Bmw320Factory();
        bmw320.CreateEngine().equipment();
        bmw320.CreateTires().product();

        System.out.println("===========================>宝马X5组装");
        CarFactory bmwX5 = new BmwX5Factory();
        bmwX5.CreateEngine().equipment();
        bmwX5.CreateTires().product();
    }
}