工厂方法与抽象工厂模式

最新推荐文章于 2024-08-01 20:10:37 发布
最新推荐文章于 2024-08-01 20:10:37 发布
阅读量490 收藏
点赞数
分类专栏： 架构设计 文章标签： 工厂模式 面向对象 对象 继承
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/micro_hz/article/details/51493736
版权

面向对象设计六大原则：
开闭原则
依赖倒置
里氏替换原则
单一职责
接口隔离
迪米特法则
结构原则：
面向接口编程，原则上对象之间的关系尽量采用组合的方式而不是继承的方式，集成尽量不重写超类的方法。

工厂方法有三种：简单工厂方法，静态工厂方法，抽象工厂方法。
工厂方法模式为创建对象的模式，为了解决的问题是对象创建的问题。

1.简单工厂方法：
类图
这里写图片描述
代码实现如下：

interface Product {
    void print();
}

class P1 implements Product {

    @Override
    public void print() {
        System.out.println("生产出产品p1");
    }

}

class P2 implements Product {

    @Override
    public void print() {
        System.out.println("生产出产品p2");
    }

}
//简单工厂方法
class SimpleFactory {
    public Product getProduct(String productName) {
        if(productName.equals("p1"))
            return new P1();
        else if(productName.endsWith("p2"))
            return new P2();
        else 
            return null;
    }
}

客户端调用：

// 简单工厂模式
        SimpleFactory simpleFactory = new SimpleFactory();

        simpleFactory.getProduct("p1").print();

        simpleFactory.getProduct("p2").print();

结果：

生产出产品p1
生产出产品p2

分析：简单工厂在产品的种类不多的情况下，可以解决问题，但是增加产品要去修改工厂类
这里我们提出三个问题：
1、字符串这样去选择控制对象生成很不方便，容易出错，而且一个函数的功能太臃肿不利于维护。
2、每次需要工厂都需要实例化，浪费内存。
3、如果增加产品，会修改原来的类，不符合开闭原则。

接下来我们进一步优化这个架构，增加它的健壮性。

第一个问题的解决方案

拆分成不同的方法，直接调用方法，生成不同的产品，不用传入参数

class SimpleFactory2 {
    public Product getP1() {
        return new P1();
    }
    public Product getP2() {
        return new P2();
    }
}

客户端调用：

    // 字符串容易出错，拆分函数改进
        System.out.println("----拆封方法，消除字符串----");

        SimpleFactory2 simpleFactory2 = new SimpleFactory2();

        simpleFactory2.getP1().print();

        simpleFactory2.getP2().print();

运行结果：

----拆封方法，消除字符串----
生产出产品p1
生产出产品p2

这样直接调用方法，不用传入参数，分离了接口方法，解决了问题。
然后我们来解决第二个问题。我们创建对象为了节省内存，应该采用静态方法的模式去解决。不用每次都新生成对象吧。

// 第二个问题的解决方案
/*
 * 太过于浪费内存，可以采用静态方法的模式去生成
 */
class SimpleFactory3 {
    public static P1 p1;
    public static P2 p2;
    public static Product getP1() {
        if(p1 == null) 
            p1 = new P1();
        return p1;
    }
    public static Product getP2() {
        if(p2 == null)
            p2 = new P2();
        return p2;
    }
}

运行结果：

---修改静态方法----
生产出产品p1
生产出产品p2

第三个问题就是如果要增加新的具体的产品p3，那就要修改工厂类了，按现在的情况，必须要在类中添加新的方法。这样：

class SimpleFactory3 {
    public static P1 p1;
    public static P2 p2;
    public static P3 p3;
    public static Product getP1() {
        if(p1 == null) 
            p1 = new P1();
        return p1;
    }
    public static Product getP2() {
        if(p2 == null)
            p2 = new P2();
        return p2;
    }
    public static Product getP3() {
        if(p3 == null)
            p3 = new P3();
        return p3;
}

想象如果具体的产品非常多，难道每次都要去修改这个工厂么。这样明显是不符合开闭原则的。好吧。工厂的目的就是生产出产品，我们应该把稳定不变的部分抽象出来，这里工厂的抽象功能就是创造产品。我们定义一个抽象类。

abstract class AbsctractFactory {
    public abstract Product getProduct();
}

我们具体要生产什么产品，由具体的工厂来实现，例如生产产品P1的工厂修改为：

class P1SimpleFactory extends AbsctractFactory {

    @Override
    public Product getProduct() {
        return new P1();
    }

}

同理生产产品P2修改为：

class P2SimpleFactory extends AbsctractFactory {

    @Override
    public Product getProduct() {
        return new P2();
    }

}

客户端运行如下

// 添加产品，不用修改原来的类了
        System.out.println("--抽象出工厂--");

        AbsctractFactory absctractFactoryP1 = new P1SimpleFactory();

        absctractFactoryP1.getProduct().print();

        AbsctractFactory absctractFactoryP2 = new P2SimpleFactory();

        absctractFactoryP2.getProduct().print();

这个时候我们如果需要产品P3：

// 添加新的具体产品，不需要修改现成的代码，只需定义一个新的产品P3实现原来的产品接口，再添加一个具体工厂即可
class P3 implements Product {

    @Override
    public void print() {
        System.out.println("生产出新的产品p3");
    }

}

增加新产品工厂代码

class P3SimpleFactory extends AbsctractFactory {

    @Override
    public Product getProduct() {
        return new P3();
    }

}

客户端调用：

// 添加新的产品

        AbsctractFactory absctractFactoryP3 = new P3SimpleFactory();

        absctractFactoryP3.getProduct().print();

运行结果：

生产出新的产品p3

我们已经将工厂进行了抽象，现在的结构如下
这里写图片描述
这样的好处就是增加新的产品可以不用再修改原来的工厂了，满足了开闭原则。

————-分割线————-
到此我们完成了单一产品接口的创建，但我们如果是后期需要抽象出更多的产品接口，那我们这个系统就不是那么好了。我们可以重新定义抽象工厂的方法。
我们来举个例子，那就是生产CPU和GPU，GPU是图形显卡的核心，AMD和Intel可以设计CPU，AMD,NVIDIA公司设计GPU。一般制造工作交给代工厂TSMC或则是SAMSUNG，多个产品类别，那我们就在抽象工厂方法里添加产品的方法：
两个产品类别（接口）：

// 如果要添加新的，添加新的产品类别
interface CPU {
    void print();
}
interface GPU {
    void print();
}
class AMD implements CPU,GPU {

    @Override
    public void print() {
        System.out.println("我是AMD，设计出了CPU,GPU");
    }

}
class Intel implements CPU {

    @Override
    public void print() {
        System.out.println("我是intel，设计出CPU");
    }

}
class NVIDIA implements GPU {

    @Override
    public void print() {
        System.out.println("我是nVIdia,设计出GPU");
    }

}
// 抽象工厂具有两个函数生产产品
abstract class OEMFactory {
    public abstract CPU produceCPU();
    public abstract GPU produceGPU();
}

具体的工厂类：

/class TSMC extends OEMFactory {

    static {
        System.out.println("TSMC生产...");
    }

    @Override
    public CPU produceCPU() {
        return new AMD();
    }

    @Override
    public GPU produceGPU() {

        return new NVIDIA();
    }

}
class SAMSUNG extends OEMFactory {

    static {
        System.out.println("SAMSUNG生产...");
    }
    // 不得不实现该方法 这里怎么解决呢？
    @Override
    public CPU produceCPU() {
        return null;
    }

    @Override
    public GPU produceGPU() {
        return new AMD();
    }

}

客户端调用：

// 添加新的产品类别
        System.out.println("---添加新的产品类别----");

        OEMFactory omeFactory1 = new TSMC();

        omeFactory1.produceCPU().print();
        omeFactory1.produceGPU().print();

        OEMFactory omeFactory2 = new SAMSUNG();

        // 三星不制造CPU omeFactory2.produceCPU().print();
        omeFactory2.produceGPU().print();

就如上面谈及到的，根据接口隔离原则，我们可以实现多个接口的方式去解决继承多余的方法的问题。而且如果有新的产品线，我们只需要定义新的接口（抽象工厂）就可以了，不用去修改原来的接口。
把抽象类拆分成接口之后的效果：

// 这样我们如果要添加新的产品类别(接口)，需要修改抽象工厂类，不符合开闭原则
// 我们需要将抽象工厂拆分成多个部分，设计原则里面有个接口隔离原则，将抽象类进行拆分成接口
interface CPUOEMFactory {
    CPU produceCPU();
}
interface GPUOEMFactory {
    GPU produceGPU();
}
class TSMC2 implements CPUOEMFactory,GPUOEMFactory {

    static {
        System.out.println("TSMC生产...");
    }

    @Override
    public GPU produceGPU() {
        return new NVIDIA();
    }

    @Override
    public CPU produceCPU() {
        return new AMD();
    }

}
class SAMSUNG2 implements GPUOEMFactory {

    static {
        System.out.println("SAMSUNG第二个工厂，生产...");
    }

    @Override
    public GPU produceGPU() {
        return new NVIDIA();
    }

}

客户端调用：

// 拆分了接口
        System.out.println("----拆分了接口---");
        CPUOEMFactory cpuOEMFactory = new TSMC2();

        cpuOEMFactory.produceCPU().print();
        // TSMC同时实现了GPU制造
        GPUOEMFactory gpuOEMFactory = new TSMC2();

        gpuOEMFactory.produceGPU().print();

        GPUOEMFactory gpuOEMFactory2 = new SAMSUNG2();

        gpuOEMFactory2.produceGPU().print();

结果：

----拆分了接口---
TSMC生产...
我是AMD，设计出了CPU,GPU
我是nVIdia,设计出GPU
SAMSUNG第二个工厂，生产...
我是nVIdia,设计出GPU

我们只需实现我们需要的抽象类（接口）即可。这样我们保证了多个产品，多个工厂的方式搭建起一个稳定的架构，多扩展开放，对修改关闭。

这里写图片描述
这里写图片描述

如果新增一个产品线：

// 只需要增加抽象工厂类接口,不需要修改现有代码
interface ARMOEMFactory {
    ARM produce();
}
// 具体制造工厂
class TSMC3 implements ARMOEMFactory {
    static {
        System.out.println("TSMC 第三个工厂，制造了...");
    }
    // TSMC既制造高通，也制造苹果ARM，构造方法自己指定
    ARM arm;
    TSMC3(ARM arm) {
        this.arm = arm;
    }

    @Override
    public ARM produce() {
        return arm;
    }

}
class SAMSUNG3 implements ARMOEMFactory {
    static {
        System.out.println("SAMSUNG第三个工厂，制造了...");
    }

    @Override
    public ARM produce() {
        return new Qualcomm();
    }

}

客户端调用：


        // 增加了新的产品类别(接口)ARM
        System.out.println("-----增了新的产品类别-----");
        ARMOEMFactory armFactory = new TSMC3(new Qualcomm());

        armFactory.produce().printARM();

        ARMOEMFactory armFactory2 = new SAMSUNG3();

        armFactory2.produce().printARM();

结果：

-----增了新的产品类别-----
TSMC 第三个工厂，制造了...
我是高通，设计了820 ARM处理器
SAMSUNG第三个工厂，制造了...
我是高通，设计了820 ARM处理器
micro_hz
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java工厂方法模式和抽象工厂模式实例
04-04
用java语言实现工厂方法模式和抽象工厂模式
Java工厂模式：简单工厂、工厂方法模式、抽象工厂模式代码示例
最新发布
08-12
在Java中，工厂模式分为三种：简单工厂、工厂方法模式和抽象工厂模式。 **简单工厂模式** 是最基本的工厂模式，它由一个工厂类根据传入的参数决定创建哪一种产品类的实例。简单工厂容易实现，但违反开闭原则，即...
工厂方法和抽象工厂模式
qq_38515961的博客
09-24 1705
文章目录一、工厂方法1、工厂法法模式结构图：2、工厂方法模式的优缺点二、抽象工厂模式1、抽象工厂模式结构图2、抽象工厂模式的优缺点 一、工厂方法 工厂方法定义：定义一个用于创建对象的接口，让子类决定实例化哪一个类，工厂方法使一个类的实例化延迟到其子类。 1、工厂法法模式结构图： 工厂方法抽象出一个工厂接口，这个接口只有一个方法，就是创建抽象产品的工厂方法，所有要生产具体类的工厂就去实现这个接口。当需要创建新对象的工厂时，就不需要更改原有的工厂类，只需要增加相应的工厂类。 产品抽象类 Product pub
设计模式1---简单工厂模式、工厂方法模式、抽象工厂模式
csdn_csuers的博客
08-01 1004
其中，创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。本文将介绍2 种，其中，工厂方法模式一般可以分为简单工厂模式及工厂模式。
工厂方法模式和抽象工厂模式
qq_33380252的博客
07-15 194
工厂方法模式 定义一个用于创建对象的接口，让子类决定实例化哪一个类。 在工厂里面可以对对象的创建做严格的定义，client端直接通过工厂创建出来就可以使用了。 public abstract class Product { //产品抽象类 public abstract void method(); } public class ConcreteProductA extends Product { //具体A产品 @Override public void method() ...
Java设计模式之工厂模式分析【简单工厂、工厂方法、抽象工厂】
08-27
抽象工厂模式是工厂模式中的一种实现方式，它通过定义一个抽象工厂接口，并让子类来实现该接口，以创建对象实例。例如，在上面的代码中，我们定义了一个AbstractHairFactory抽象工厂接口，并让ConcreteHairFactory类...
C#编程模式之工厂方法模式+抽象工厂模式
04-17
本资源主要介绍工厂方法模式和抽象工厂模式。二者都与工厂相关，，但是其本质又大相径庭。这里先来简单介绍下二者的区别，以免混淆。 抽象工厂模式：提供一个接口，用于创建一系列相关的对象，而无需指定具体的类。...
工厂模式：简单工厂模式、工厂方法模式、抽象工厂模式
12-14
工厂模式分为三种主要类型：简单工厂模式、工厂方法模式和抽象工厂模式。 1. **简单工厂模式** 简单工厂模式是最简单的工厂模式实现，它提供一个静态方法或者类来创建对象，这个类通常被称为“工厂”。用户只需要...
Java设计模式编程中的工厂方法模式和抽象工厂模式
09-02
在Java设计模式编程中，工厂方法模式和抽象工厂模式是两种重要的创建型设计模式，它们主要解决了对象创建过程中的灵活性和可扩展性问题。 工厂方法模式的核心思想是将对象的实例化过程延迟到子类中进行，从而实现对...
工厂方法模式和抽象工厂模式的区别
08-09
工厂方法模式和抽象工厂模式的区别，对工厂方法模式和抽象工厂模式做了简单的比较
工厂方法模式、抽象工厂模式
时光里的博客
06-22 2975
工厂系列 定义: 工厂模式主要是为创建对象提供过渡接口，以便将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的。 分类: 工厂模式在《Java 与模式》中分为三类：这三种模式从上到下逐步抽象，并且更具一般性 简单工厂模式（Simple Factory） 工厂方法模式（Factory Method） 抽象工厂模式（Abstract Factory） GOF 在《设计模式》一书中将工厂模式分为两类：工厂方法模式（Factory Method）与抽象工厂模式（Abstract Factory）。将简
设计模式-工厂方法模式和抽象工厂模式
a410974689的博客
02-08 934
(1) 定义：是一种为访问类提供一个创建一组相关或相互依赖对象的接口，且访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构。抽象工厂模式是工厂方法模式的升级版本，工厂方法模式只生产一个等级的产品，而抽象工厂模式可生产多个等级的产品。抽象工厂需要满足下面条件：A. 系统中有多个产品族，每个具体工厂创建同一族但属于不同等级结构的产品。B. 系统一次只可能消费其中某一族产品，即同族的产品一起使用。(2).优点。
设计模式(二、三)：创建型之工厂方法模式和抽象工厂模式
从基础到源码解析的学习记录
05-30 823
需求：设计一个咖啡店点餐系统设计一个咖啡类（Coffee）并定义其两个子类（美式咖啡【AmericanCoffee】和拿铁咖啡【LatteCoffee】）再设计一个咖啡店类（CoffeeStore），咖啡店具有点咖啡的功能具体类的设计如下：这些对象都需要创建，如果创建的时候直接new该对象，就会对该对象耦合严重假如我们要更换对象，所有new对象的地方都需要修改一遍，这显然违背了软件设计的开闭原则如果我们使用工厂来生产对象，我们就只和工厂打交道就可以了，彻底和对象解耦。
【笔记】 抽象类 和 接口
pirionFordring的博客
11-14 163
抽象类（abstract class） 定义：包含抽象方法的的类是abstract class 用abstract关键字修饰 作用：abstractclass是为了把相同的东西提取出来,即重用 使用abstractclass语法规定 语法 备注 抽象类定义用abstract关键字修饰 要通过子类进行实例化 抽象类是不能被实例化的 ...
简单工厂、工厂方法模式、抽象工厂模式
weixin_33671935的博客
05-11 914
只为每天积累一点点。。。 简单工厂、工厂方法模式、抽象工厂模式的简单原理。   一、引子 话说十年前，有一个爆发户，他家有三辆汽车（Benz（奔驰）、Bmw（宝马）、Audi（奥迪）），还雇了司机为他开车。不过，爆发户坐车时总是这样：上Benz车后跟司机说“开奔驰车！”，坐上Bmw后他说“开宝马车！”，坐上 Audi后他说“开奥迪车！”。你一定说：这人有病！直接说开车不就行了？...
工厂方法与抽象工厂模式解析
在多产品线的场景下，抽象工厂可以帮助我们构建一套完整的对象族，比如不同的披萨店可能有各自的披萨制作流程和材料，抽象工厂模式就能很好地适应这种需求。 总结来说，工厂方法模式关注于单一对象的创建，通过继承...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值