工厂模式的一些思考和总结

最新推荐文章于 2022-03-21 15:30:14 发布

MasonShang

最新推荐文章于 2022-03-21 15:30:14 发布

阅读量311

点赞数

分类专栏：设计模式文章标签：设计模式 java

本文链接：https://blog.csdn.net/flyer5/article/details/103950230

版权

设计模式专栏收录该内容

1 篇文章 0 订阅

订阅专栏

工厂模式Factory Pattern简介

工厂模式（Factory Pattern）是日常开发过程中使用频率较高的一种设计模式。工厂模式属于设计模式三大类（创建型模式（Creational Patterns）、结构型模式（Structural Patterns）、行为型模式（Behavioral Patterns））中的创建型模式（Creational Patterns），它简化了调用方创建对象的方式。工厂模式基本上会被分为三种——简单工厂模式、工厂方式模式、抽象工厂模式。

简单工厂模式

简单工厂模式（Simple Factory pattern）:由一个工厂对象决定创建哪一种产品的实例。

简单工厂一般用在创建产品不多，一个工厂即可完成，下面代码描述了汽车的简单工厂模式的基本实现思路。

定义汽车ICar接口：

public interface ICar {
    /**
     * 汽车启动
     */
    void run();
}

具体汽车：

public class MPVCar implements ICar {
    @Override
    public void run() {
        System.out.println("MPV car is running!");
    }
}

public class SedanCar implements ICar {
    @Override
    public void run() {
        System.out.println("Sedan car is running!");
    }
}

public class SUVCar implements ICar{
    @Override
    public void run() {
        System.out.println("SUV car is running!");
    }
}

工厂类：

public class CarFactory {
    public static ICar create(String model) {
        ICar iCar = null;
        if ("sedan".equalsIgnoreCase(model)) {
            iCar = new SedanCar();
        } else if ("suv".equalsIgnoreCase(model)) {
            iCar = new SUVCar();
        } else if ("mpv".equalsIgnoreCase(model)) {
            iCar = new MPVCar();
        }
        return iCar;
    }
}

通过调用工厂类，创建汽车对象：

public class CarMain {
    public static void main(String[] args) {
        ICar car = CarFactory.create("sedan");
        car.run();
    }
}

执行结果：

Sedan car is running!

通过以上代码示例描述，会发现简单工厂模式有以下特点：

适用用产品较少的场景（如产品太多，Factory将很难维护，不利于扩展）
隐藏了创建对象的具体细节，调用方不用关注如何创建了对象，只用关心调用方自己的业务细节。

简单工厂模式的缺点也很明显：上面已经提到，单一工厂需要维护过多的产品，增加一个产品需要升级一次工厂，增加了未来的改造成本，违背了设计原则的开闭原则（对扩展开放，对修改关闭）。

工厂方法模式（Factory Method Pattern）

工厂方法模式（Factory Method Pattern）：定义一个创建对象的接口，让其实现这个接口的方法决定创建哪个对象，将产品对象的的创建工作推迟到子类中进行。

工厂方法模式，是对简单工厂模式的改进，对简单工厂的进一步抽象化。好处是可在不修改原有代码的基础上引进新的产品，实现开闭原则的对扩展开放，对修改关闭。

改进后的工厂方法，创建的对象工厂接口如下：

public interface IFactory {
    /**
     * 创建方法
     * @return
     */
    ICar create();
}

具体实现工厂：

public class SedanFactory implements IFactory {
    @Override
    public ICar create() {
        return new SedanCar();
    }
}

public class SUVFactory implements IFactory {
    @Override
    public ICar create() {
        return new SUVCar();
    }
}

public class MPVFactory implements IFactory {
    @Override
    public ICar create() {
        return new MPVCar();
    }
}

调用工厂类：

public class CarMain {
    public static void main(String[] args) {
        IFactory sedanFactory = new SedanFactory();
        ICar car = sedanFactory.create();
        car.run();
    }
}

运行测试结果：

Sedan car is running!

工厂方法模式适用用于以下场景：

创建对象需要大量重复的代码。
调用方不关心创建对象的细节。
类通过其子类指定创建具体对象。

同时工厂方法也有缺点：

工厂类容易过多，增加复杂度。

抽象工厂模式（Abstract Factory Pattern）

抽象工厂模式（Abstract Factory Pattern）：是一种为访问类提供一个创建一组相关或相互依赖对象的接口，且访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构。

需要一个对象类库，所有的对象通过同样的接口出现，从而使调用放不依赖具体实现。比如汽车工厂分很多品牌，这些品牌有奔驰、宝马、奥迪等，每个工厂都能生产很多型号车辆，但是他们不可能使用一个工厂生产汽车。所以需第一个奔驰工厂、一个宝马工厂、一个奥迪工厂用于生产各自品牌的不同型号的汽车。
用代码实现则如下定义工厂接口：

public interface IFactory {
    /**
     * 创建轿车
     *
     * @return
     */
    ICar createSedanCar();

    /**
     * 创建SUV
     *
     * @return
     */
    ICar createSUVCar();

    /**
     * 创建MVP
     *
     * @return
     */
    ICar createMPVCar();
}

实现一个奔驰工厂：

public class BenzFactory implements IFactory{
    @Override
    public ICar createSedanCar() {
        return new SedanCar();
    }

    @Override
    public ICar createSUVCar() {
        return new SUVCar();
    }

    @Override
    public ICar createMPVCar() {
        return new MPVCar();
    }
}

调用工厂类：

public class CarMain {
    public static void main(String[] args) {
        IFactory sedanFactory = new BenzFactory();
        ICar car = sedanFactory.createSedanCar();
        car.run();
    }
}

运行结果：