工厂模式学习笔记（java版）

最新推荐文章于 2023-10-11 14:50:16 发布

风絮_

最新推荐文章于 2023-10-11 14:50:16 发布

阅读量245

点赞数

分类专栏：设计模式（java）文章标签：设计模式 java 工厂模式静态工厂工厂方法

本文链接：https://blog.csdn.net/li3455277925/article/details/89105274

版权

设计模式（java）专栏收录该内容

10 篇文章 0 订阅

订阅专栏

作用：

实现了创建者和调用者的分离。

面向对象设计原则：

开闭原则（OCP，Open-Closed Principle）：一个软件的实体应当对扩展开放，对修改关闭。
依赖倒转原则（DIP，Dependence Inversion Principle）：要针对接口编程，不要针对实现编程。
迪米特法则（LoD，Law of Demeter）：只与你直接的朋友通信，而避免和陌生人通信。
单一职责原则（Single Responsibility Principle）：每一个类应该专注于做一件事情。
里氏替换原则（Liskov Substitution Principle）：超类存在的地方，子类是可以替换的。
接口隔离原则（Interface Segregation Principle）：应当为客户端提供尽可能小的单独的接口，而不是提供大的总的接口。
组合/聚合复用原则（Composite/Aggregate Reuse Principle CARP）：尽量使用合成/聚合达到复用，尽量少用继承。原则：一个类中有另一个类的对象。

核心本质

实例化对象，用工厂方法代替new操作。
将选择实现类、创建对象统一管理和控制。从而将调用者跟我们的实现类解耦。

几种工厂模式的用途

简单工厂模式：用来生产同一等级结构中的任意产品。（对于增加新的产品，需要修改已有代码，违反开闭原则）
工厂方法模式：用来生产同一等级结构中的固定产品。（支持增加任意产品）
抽象工厂模式：用来生产不同产品族的全部产品。（对于增加新的产品，无能为力；支持增加产品族）

不使用工厂模式的时候

package com.qianyu.gof.factory.simpleFactory;

/**
 * @author lijing
 * @date 2019-04-08-19:22
 * @discription 车接口
 */
public interface Car {
    public void run();
}

package com.qianyu.gof.factory.simpleFactory;

/**
 * @author lijing
 * @date 2019-04-08-19:42
 * @discription 比亚迪车实现了车接口
 */
public class BydCar implements Car {
    @Override
    public void run() {
        System.out.println("比亚迪在跑");
    }
}

package com.qianyu.gof.factory.simpleFactory;

/**
 * @author lijing
 * @date 2019-04-08-19:43
 * @discription 奥迪车实现了车接口
 */
public class AudiCar implements Car {
    @Override
    public void run() {
        System.out.println("奥迪在跑");
    }
}

package com.qianyu.gof.factory.simpleFactory;

/**
 * @author lijing
 * @date 2019-04-08-19:44
 * @discription 没有工厂模式的测试类
 */
public class NoFactoryTest {
    public static void main(String[] args) {
        BydCar bydCar = new BydCar();
        AudiCar audiCar = new AudiCar();

        bydCar.run();
        audiCar.run();
    }
}

UML图如下，测试类需要和实现了Car接口的所有类关联：
在这里插入图片描述

简单工厂模式

简单工厂模式也叫静态工厂模式，就是工厂类一般是使用静态方法，通过接收的参数的不同来返回不同的对象实例。
对于增加新产品无能为力！不修改代码的话，是无法扩展的。
代码如下：在原有的类基础上增加一个工厂类：

package com.qianyu.gof.factory.simpleFactory;

/**
 * @author lijing
 * @date 2019-04-08-19:48
 * @discription 简单工厂模式
 */
public class SimpleCarFactory {
    public static Car createCar(String name) {
        if ("奥迪".equals(name)) {
            return new AudiCar();
        } else if ("比亚迪".equals(name)) {
            return new BydCar();
        }
        return null;
    }
}

此时的测试类如下：

package com.qianyu.gof.factory.simpleFactory;

/**
 * @author lijing
 * @date 2019-04-08-19:51
 * @discription 简单工厂模式测试类
 */
public class SimpleCarFactoryTest {
    public static void main(String[] args) {
        Car audi = SimpleCarFactory.createCar("奥迪");
        Car byd = SimpleCarFactory.createCar("比亚迪");

        audi.run();
        byd.run();
    }
}

UML图如下，测试类只用和SimpleCarFactory类和Car接口打交道即可：
在这里插入图片描述
此外，简单工厂还有另一种实现：

package com.qianyu.gof.factory.simpleFactory;

/**
 * @author lijing
 * @date 2019-04-08-19:48
 * @discription 简单工厂模式的另一种实现
 */
public class SimpleCarFactory2 {
    public static Car createAudi(){
        return new AudiCar();
    }
    public static Car createByd(){
        return new BydCar();
    }
}

工厂方法模式

为了避免简单工厂模式的缺点，不完全满足OCP。
工厂方法模式和简单工厂模式最大的不同在于，简单工厂模式只有一个（对于一个项目或者一个独立模块而言）工厂类，而工厂方法模式有一组实现了相同接口的工厂类。
还以上面的Car类、BydCar类和Audi类为例，添加工厂类的接口：

package com.qianyu.gof.factory.factoryMethod;

import com.qianyu.gof.factory.simpleFactory.Car;

/**
 * @author lijing
 * @date 2019-04-08-20:49
 * @discription 工厂接口
 */
public interface CarFactory {
    public Car create();
}

工厂类的实现类：

package com.qianyu.gof.factory.factoryMethod;

import com.qianyu.gof.factory.simpleFactory.AudiCar;
import com.qianyu.gof.factory.simpleFactory.Car;

/**
 * @author lijing
 * @date 2019-04-08-20:50
 * @discription 奥迪工厂类
 */
public class AudiFactory implements CarFactory {
    @Override
    public Car create() {
        return new AudiCar();
    }
}

package com.qianyu.gof.factory.factoryMethod;

import com.qianyu.gof.factory.simpleFactory.BydCar;
import com.qianyu.gof.factory.simpleFactory.Car;

/**
 * @author lijing
 * @date 2019-04-08-20:51
 * @discription 比亚迪工厂类
 */
public class BydFactory implements CarFactory {
    @Override
    public Car create() {
        return new BydCar();
    }
}

测试类：

package com.qianyu.gof.factory.factoryMethod;

import com.qianyu.gof.factory.simpleFactory.Car;

/**
 * @author lijing
 * @date 2019-04-08-20:39
 * @discription 工厂方法设计模式测试类
 */
public class FactoryMethodTest {
    public static void main(String[] args) {
        Car audi = new AudiFactory().create();
        Car byd = new BydFactory().create();

        audi.run();
        byd.run();
    }
}

UML图：
在这里插入图片描述

简单工厂模式和工厂方法模式比较

结构复杂度
从这个角度比较，显然简单工厂模式要占优。简单工厂模式只需一个工厂类，而工厂方法模式的工厂类随着产品类个数增加而增加，这无疑会使类的个数越来越多，从而增加了结构的复杂程度。
代码复杂度
代码复杂度和结构复杂度是一对矛盾，既然简单工厂模式在结构方面相对简洁，那么它在代码方面肯定是比工厂方法模式复杂的了。简单工厂模式的工厂类随着产品类的增加需要增加很多方法（或代码），而工厂方法模式每个具体工厂类只完成单一任务，代码简洁。
客户端编程难度
工厂方法模式虽然在工厂类结构中引入了接口从而满足了OCP，但是在客户端编码中需要对工厂类进行实例化。而简单工厂模式的工厂类是个静态类，在客户端无需实例化，这无疑是个吸引人的优点。
管理上的难度
这是个关键的问题。我们先谈扩展。众所周知，工厂方法模式完全满足OCP，即它有非常良好的扩展性。那是否就说明了简单工厂模式就没有扩展性呢？答案是否定的。简单工厂模式同样具备良好的扩展性——扩展的时候仅需要修改少量的代码（修改工厂类的代码）就可以满足扩展性的要求了。尽管这没有完全满足OCP，但我们不需要太拘泥于设计理论，要知道，sun提供的java官方工具包中也有想到多没有满足OCP的例子啊。然后我们从维护性的角度分析下。假如某个具体产品类需要进行一定的修改，很可能需要修改对应的工厂类。当同时需要修改多个产品类的时候，对工厂类的修改会变得相当麻烦（对号入座已经是个问题了）。反而简单工厂没有这些麻烦，当多个产品类需要修改是，简单工厂模式仍然仅仅需要修改唯一的工厂类（无论怎样都能改到满足要求吧？大不了把这个类重写）。
根据设计理论建议：工厂方法模式。但实际上，我们一般都用简单工厂模式。

抽象工厂模式

用来生产不同产品族的全部产品。（对于增加新的产品，无能为力；支持增加产品族）
抽象工厂模式是工厂方法模式的升级版本，在有多个业务品种、业务分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方式。

package com.qianyu.gof.factory.abstractFactory;

/**
 * @author lijing
 * @date 2019-04-08-21:56
 * @discription 轮胎接口以及实现类
 */
public interface Tyre {
    void revolve();
}

/**
 * 高端轮胎类
 */
class LuxuryTyre implements Tyre {

    @Override
    public void revolve() {
        System.out.println("质量好轮胎，耐磨");
    }
}

/**
 * 低端轮胎类
 */
class LowTyre implements Tyre {

    @Override
    public void revolve() {
        System.out.println("质量差的轮胎，不耐用");
    }
}

package com.qianyu.gof.factory.abstractFactory;

/**
 * @author lijing
 * @date 2019-04-08-22:01
 * @discription 发动机接口和其实现类
 */
public interface Engine {
    void run();
}

/**
 * 高端发动机类
 */
class LuxuryEngine implements Engine {
    @Override
    public void run() {
        System.out.println("高端发动机，转的快");
    }
}

/**
 * 低端发动机类
 */
class LowEngine implements Engine {

    @Override
    public void run() {
        System.out.println("低端发动机，转的慢");
    }
}

package com.qianyu.gof.factory.abstractFactory;

/**
 * @author lijing
 * @date 2019-04-08-22:08
 * @discription 座椅接口及其实现类
 */
public interface Seat {
    void massage();
}

/**
 * 高端座椅类
 */
class LuxurySeat implements Seat {

    @Override
    public void massage() {
        System.out.println("高端座椅，可以按摩");
    }
}

/**
 * 地端座椅类
 */
class LowSeat implements Seat {

    @Override
    public void massage() {
        System.out.println("低端座椅，不可以按摩");
    }
}

package com.qianyu.gof.factory.abstractFactory;

/**
 * @author lijing
 * @date 2019-04-08-22:12
 * @discription 汽车工厂类接口以及其实现类
 */
public interface CarFactory {
    Tyre createTyre();

    Engine createEngine();

    Seat createSeat();
}

/**
 * 高端车工厂类
 */
class LuxuryCarFactory implements CarFactory {

    @Override
    public Tyre createTyre() {
        return new LuxuryTyre();
    }

    @Override
    public Engine createEngine() {
        return new LuxuryEngine();
    }

    @Override
    public Seat createSeat() {
        return new LuxurySeat();
    }
}

/**
 * 低端车工厂类
 */
class LowCarFactory implements CarFactory {

    @Override
    public Tyre createTyre() {
        return new LowTyre();
    }

    @Override
    public Engine createEngine() {
        return new LowEngine();
    }

    @Override
    public Seat createSeat() {
        return new LowSeat();
    }
}

测试类：

package com.qianyu.gof.factory.abstractFactory;

/**
 * @author lijing
 * @date 2019-04-08-21:51
 * @discription 抽象工厂设计模式测试类
 */
public class AbstractFactoryTest {
    public static void main(String[] args) {
        LuxuryCarFactory luxuryCarFactory = new LuxuryCarFactory();
        Tyre luxuryTyre = luxuryCarFactory.createTyre();
        Engine luxuryEngine = luxuryCarFactory.createEngine();

        LowCarFactory lowCarFactory = new LowCarFactory();
        Engine lowEngine = lowCarFactory.createEngine();
        Tyre lowTyre = lowCarFactory.createTyre();

        luxuryTyre.revolve();
        luxuryEngine.run();

        lowEngine.run();
        lowTyre.revolve();
    }
}

UML图：
在这里插入图片描述

总结

工厂模式要点：

简单工厂模式(静态工厂模式)
虽然某种程度不符合设计原则，但实际使用最多。
工厂方法模式
不修改已有类的前提下，通过增加新的工厂类实现扩展。
抽象工厂模式
不可以增加产品，可以增加产品族！

应用场景

JDK中Calendar的getInstance方法
JDBC中Connection对象的获取
Hibernate中SessionFactory创建Session
spring中IOC容器创建管理bean对象
XML解析时的DocumentBuilderFactory创建解析器对象
反射中Class对象的newInstance()

——基于高淇老师的《java300集》

风絮_

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
工厂模式学习笔记（java版）

作用：实现了创建者和调用者的分离。分类：简单工厂模式工厂方法模式抽象工厂模式面向对象设计原则：开闭原则（OCP，Open-Closed Principle）：一个软件的实体应当对扩展开放，对修改关闭。依赖倒转原则（DIP，Dependence Inversion Principle）：要针对接口编程，不要针对实现编程。迪米特法则（LoD，Law of Demeter）：只与...
复制链接

扫一扫