设计模式-简单工厂模式，工厂方法模式，抽象工厂模式

最新推荐文章于 2022-11-01 08:30:00 发布
最新推荐文章于 2022-11-01 08:30:00 发布
阅读量125 收藏
点赞数
分类专栏： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44251749/article/details/107423874
版权
  1. 简单工厂模式

简单工厂模式不是23种设计模式之一！它只是日常编程中一种常用的方法或者说是这是一种习惯。

（1）简单工厂模式又称静态工厂模式（因为，它属工厂角色中定义的方法是静态方法），属于类创建模式，根据需求，我们可以根据传入的参数来返回不同子类的实例（其中用到了多态—继承，重写，向上转型）。简单工厂模式专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。

在这里插入图片描述
（2）简单工厂模式最大的优点在于实现对象的创建和对象的使用分离，将对象的创建交给专门的工厂类负责，但是其最大的缺点在于工厂类不够灵活，增加新的具体产品需要修改工厂类的判断逻辑代码，这样就违背了开闭原则（对于扩展是开放的，对于修改是封闭的），而且产品较多时，工厂方法代码逻辑将会非常复杂。

在这里插入图片描述

案例代码如下
抽象产品角色：

package com.shuyu.operation;
 
import lombok.Data;
 

@Data
public class Operation {
    private double numberA=0;
    private double numberB=0;
 
    public  double getResult(){
        double result=0;
        return result;
    }
 
}

实例产品角色：


 
public class OperationAdd  extends Operation{
    @Override
    public double getResult() {
        double result=0;
        result=getNumberA()+getNumberB();
        return result;
    }
}
 
 
 

 
public class OperationSub extends Operation {
    @Override
    public double getResult() {
        double result=0;
        result=getNumberA()-getNumberB();
        return result;
    }
}
 
 
 
 

 
public class OperationMul extends Operation{
 
    @Override
    public double getResult() {
        double result=0;
        result=getNumberA()*getNumberB();
        return result;
    }
}
 
 
 

 
public class OperationDiv extends Operation {
 
    @Override
    public double getResult() {
        double result=0;
        if (getNumberB()==0){
            try {
                throw new Exception("除数不能为0");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }else {
            result=getNumberA()/getNumberB();
        }
        return result;
    }
}

工厂角色：


 
public class OpreationFactory {
 
    public static Operation createOperate(String operate){
        Operation operation=null;
        switch (operate){
            case "+":
                operation=new OperationAdd();
                break;
            case "-":
                operation=new OperationSub();
                break;
            case "*":
                operation=new OperationMul();
                break;
            case "/":
                operation=new OperationDiv();
                break;
 
        }
        return operation;
    }
}

测试类：

@RunWith(SpringRunner.class)
@SpringBootTest
@Slf4j
public class SimplefactoryApplicationTests {
 

	@Test
	public void contextLoads() {
		Operation operation= OpreationFactory.createOperate("+");
		operation.setNumberA(1);
		operation.setNumberB(4);
		log.info("执行结果"+operation.getResult());
	}
 
}

输出结果：5.0
  1. 工厂方法模式

（1）工厂方法模式与简单工厂模式类似，区别在于使用不同的工厂类创建不同的具体产品对象，各个不同功能的实例对象的创建代码，没有耦合在同一个工厂类里，这也是工厂方法模式对简单工厂模式解耦的一个体现。工厂方法模式克服了简单工厂会违背开闭原则的缺点，又保持了封装对象创建过程的优点。

但工厂方法模式的缺点是每增加一个产品类，就需要增加一个对应的工厂类，增加了额外的开发量。

（2）抽象工厂：工厂模式的核心，提供一个创建对象的接口，任何需要创建对象的具体工厂都要实现这个接口。
具体工厂：实现抽象工厂接口的类，受到调用者的调用从而创建对象。
抽象产品：工厂方法模式所创建的对象的超类。也就是所有具体产品的共同父类。
具体产品：实现抽象工厂接口的类。工厂模式中所有创建的对象都是具体产品的实例。

在这里插入图片描述

代码实现如下：

抽象产品和具体产品：

import lombok.Data;
 
/**
 * @author Shuyu.Wang
 * @package:com.shuyu.operation
 * @className:
 * @description:基本运算接口
 * @date 2018-11-07 13:11
 **/
public interface Operation {
    public  double getResult(double numberA,double numberB);
 
}
 
 
 
 
 
/**
 * @author Shuyu.Wang
 * @package:com.shuyu.operation
 * @description:加法类
 * @date 2018-11-07 13:32
 **/
public class OperationAdd  implements Operation{
    @Override
    public double getResult(double numberA,double numberB) {
        double result=0;
        result=numberA+numberB;
        return result;
    }
}
 
 
 
 
 
/**
 * @author Shuyu.Wang
 * @package:com.shuyu.operation
 * @description:除法
 * @date 2018-11-07 13:42
 **/
 
public class OperationDiv implements Operation {
 
    @Override
    public double getResult(double numberA,double numberB) {
        double result=0;
        if (numberB==0){
            try {
                throw new Exception("除数不能为0");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }else {
            result=numberA/numberB;
        }
        return result;
    }
}
 
 
 
 
 
/**
 * @author Shuyu.Wang
 * @package:com.shuyu.operation
 * @description:乘法
 * @date 2018-11-07 13:39
 **/
 
public class OperationMul implements Operation{
 
    @Override
    public double getResult(double numberA,double numberB) {
        double result=0;
        result=numberA*numberB;
        return result;
    }
}
 
 
 
 
 
/**
 * @author Shuyu.Wang
 * @package:com.shuyu.operation
 * @description:减法类
 * @date 2018-11-07 13:35
 **/
 
public class OperationSub implements Operation {
    @Override
    public double getResult(double numberA,double numberB) {
        double result=0;
        result=numberA-numberB;
        return result;
    }
}

抽象工厂和具体工厂：

import lombok.Data;
 
/**
 * @author Shuyu.Wang
 * @package:com.shuyu.operation
 * @className:
 * @description:基本运算接口
 * @date 2018-11-07 13:11
 **/
public interface Operation {
    public  double getResult(double numberA,double numberB);
 
}
 
 
 
 
 
/**
 * @author Shuyu.Wang
 * @package:com.shuyu.operation
 * @description:加法类
 * @date 2018-11-07 13:32
 **/
public class OperationAdd  implements Operation{
    @Override
    public double getResult(double numberA,double numberB) {
        double result=0;
        result=numberA+numberB;
        return result;
    }
}
 
 
 
 
 
/**
 * @author Shuyu.Wang
 * @package:com.shuyu.operation
 * @description:除法
 * @date 2018-11-07 13:42
 **/
 
public class OperationDiv implements Operation {
 
    @Override
    public double getResult(double numberA,double numberB) {
        double result=0;
        if (numberB==0){
            try {
                throw new Exception("除数不能为0");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }else {
            result=numberA/numberB;
        }
        return result;
    }
}
 
 
 
 
 
/**
 * @author Shuyu.Wang
 * @package:com.shuyu.operation
 * @description:乘法
 * @date 2018-11-07 13:39
 **/
 
public class OperationMul implements Operation{
 
    @Override
    public double getResult(double numberA,double numberB) {
        double result=0;
        result=numberA*numberB;
        return result;
    }
}
 
 
 
 
 
/**
 * @author Shuyu.Wang
 * @package:com.shuyu.operation
 * @description:减法类
 * @date 2018-11-07 13:35
 **/
 
public class OperationSub implements Operation {
    @Override
    public double getResult(double numberA,double numberB) {
        double result=0;
        result=numberA-numberB;
        return result;
    }
}
  1. 抽象工厂方法

抽象工厂方法中一个工厂可以生产同一产品族的多中具体产品。

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
举例：
问题：现有电脑产品配件厂商基于windows和apple生产不同类型的CPU和RAM，请试用抽象工厂模式描述该场景。

问题分析：
Windows产品包含WindowsCPU和WindowsRAM，（WindowsCPU和WindowsRAM属于一个产品族）
Apple产品包含AppleCPU和AppleRAM，（AppleCPU和AppleRAM属于一个产品族）
或者说是CPU包含Windows型和Apple型，RAM包含Windows型和Apple型。

下面说的可以结合后面的例子代码自己试一下，
试下增加一个新的LinuxCPU和LinuxRAM以及新增一个GPU产品是不是符合开闭原则。
①符合开闭原则情况

增加产品族：对于增加新的产品族，抽象工厂模式很好地支持了开闭原则，
只需要增加具体产品并对应增加一个新的具体工厂，对已有代码无须做任何修改。
如LinuxCPU和LinuxRAM,这种只需要新增一个工厂就行，属于扩展，不是修改，所以符合开闭原则情况。
②不符合开闭原则情况

增加新的产品等级结构：增加新的产品等级结构：对于增加新的产品等级结构 ，
需要修改所有的工厂角色，包括抽象工厂类，
在所有的工厂类中都需要增加生产新产品的方法，违背了开闭原则。
如新增一个GPU产品，这属于新增一个新的产品等级结构。

如果是工厂模式，则会创建四个工厂类，分别生产四个产品：WindowsCPU，AppleCPU，WindowsRAM，AppleRAM。

如果是抽象工厂模式，则只需要创建两个工厂类,将这四个产品两两组合（即一个工厂生产多种产品）：
工厂1：WindowsCPU，WindowsRAM。工厂2：AppleCPU，AppleRAM
工厂1：WindowsCPU，AppleCPU。工厂2：WindowsRAM，AppleRAM
（上面是两种不同的分产品族的方法）

思路：

  1. 我选择创建两个接口CPU，RAM，分别创建WindowsCPU，WindowsRAM，AppleCPU，AppleRAM四个类来分别实现对应接口。
public interface CPU {
	public void CPURun();
}

public interface RAM {
	public void RAMRun();
}
public class WindowsCPU implements CPU{
	@Override
	public void CPURun() {
		System.out.println("windows cpu run!");
	}	
}
public class WindowsRAM implements RAM{
	public void RAMRun() {
		System.out.println("windows RAM run!");
	}
}
public class AppleCPU implements CPU{
	@Override
	public void CPURun() {
		System.out.println("apple CPU run!");
	}
}
public class AppleRAM implements RAM{
	@Override
	public void RAMRun() {
		System.out.println("apple RAM run!");
	}
}

3.接下来就是创建工厂类了，抽象工厂顾名思义就是抽象工厂类，所以先创建一个抽象接口再来创建两个工厂实现接口。

public interface interfaceFactory {//抽象工厂
	public CPU createCPU();
	public RAM createRAM();
}
public class WindowsFactory implements interfaceFactory{
	@Override
	public CPU createCPU() {
		return new WindowsCPU();
	}
	@Override
	public RAM createRAM() {
		return new WindowsRAM();
	}
}
public class AppleFactory implements interfaceFactory{
	@Override
	public CPU createCPU() {
		return new AppleCPU();
	}
	@Override
	public RAM createRAM() {
		return new AppleRAM();
	}
}

4.到Test类测试一下

public class Test {
	public static void main(String[] args) {
//		WindowsCPU  windowsCPU = new WindowsCPU();
//		windowsCPU.CPURun();

//		WindowsRAM windowsRAM = new WindowsRAM();
//		windowsRAM.RAMRun();

//		AppleCPU appleCPU = new AppleCPU();
//		appleCPU.CPURun();

//		AppleRAM appleRAM = new AppleRAM();
//		appleRAM.RAMRun();

		WindowsFactory  windowsFactory= new WindowsFactory();
		CPU windowsCPU = windowsFactory.createCPU();
		RAM windowsRAM = windowsFactory.createRAM();
		windowsCPU.CPURun();
		windowsRAM.RAMRun();
		
		AppleFactory appleFactory = new AppleFactory();
		CPU appleCPU = new AppleFactory().createCPU();
		RAM appleRAM = new AppleFactory().createRAM();
		appleCPU.CPURun();
		appleRAM.RAMRun();
	}
}

这只是其中一种方式，还可以创建Windows，Apple抽象类，创建CPU工厂和RAM工厂，CPU工厂生产Windows型和Apple型，RAM工厂同理。方式不唯一。

总结：工厂模式乃是一一对应的关系，一个工厂生产一种产品；抽象工厂模式乃是一个工厂生产多种产品。

阿东今天去健身吗
关注
专栏目录
c++设计模式-抽象工厂方法
06-04
在描述中提到的"最简单源码-qt工程"可能是指使用Qt库作为示例来实现抽象工厂模式。Qt是一个跨平台的C++图形用户界面应用程序开发框架，其中包含了各种组件，如窗口、按钮、文本编辑器等，这些组件可以看作是抽象工厂...
java常用设计模式-抽象工厂模式
08-26
* 抽象工厂模式可以与其他设计模式结合使用，例如工厂方法模式、单例模式等。 抽象工厂模式是一种非常有用的设计模式，它可以帮助我们降低耦合度、提高灵活性和可扩展性。但是，需要注意抽象工厂模式的缺点，并适当...
简单工厂模式、工厂方法模式、抽象工厂模式这三种工厂模式的实例及其闭合原则。
u010439954的专栏
11-02 1117
这是本人学习多天后的个人总结。
工厂模式
Li_Nn_偏头痛
08-07 259
1、简单工厂模式 public class Factory{ 　　public static Sample creator(int which){ 　//getClass 产生Sample 一般可使用动态类装载装入类。　　 　if (which==1) 　 return new SampleA();　　 　else if (which==2) 　 return new Sam...
简单工厂模式，工厂模式，抽象工厂模式的简单实现例子
could9的博客
05-10 893
一. 模拟女娲（Nvwa）造人（Person），如果传入参数M，则返回一个Man对象，如果传入参数W，则返回一个Woman对象，请实现该场景。现需要增加一个新的Robot类，如果传入参数R，则返回一个Robot对象，对代码进行修改并注意女娲的变化。 设计模式：在这个例题中，采用的是简单工厂模式。简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类（这些产品类继承自一个父类或...
抽象工厂模式
J2EE&forever
05-18 115
抽象工厂模式是所有形态的工厂模式中最为抽象和最具一般性的一种形态。 　　抽象工厂模式是指当有多个抽象角色时，使用的一种工厂模式。 　　抽象工厂模式可以向客户端提供一个接口，使客户端在不必指定产品的具体的情况下，创建多个产品族中的产品对象。 　　当有多个抽象产品角色时，工厂方法模式已经不能满足要求。 　　根据LSP原则，任何接受父类型的地方，都应当能够接受子类型。因此，实际上系统所需要的，仅...
设计模式（一）简单工厂、工厂方法、抽象工厂模式
sinat_37623490的博客
08-27 224
工厂 “工厂”主要是用于解决对象的创建的方法。在一般的工程代码中，如果要创建一个类的对象，往往会这样写： ClassA a = new ClassA(); 对于简单的类来说，上面的方法并无不妥，但在比较复杂的项目中，有可能会出现下面几种情况： 1、进行类的改动时，比如修改了类名ClassA为ClassAB，那么在引用该类的地方就要进行修改为 classAB a = new ClassAB() 如果项目中依赖该类的地方较多，那么这个改动则需要耗费许多开发测试成本。 2、该类的构建过程复杂，每次新增引用
创建型设计模式----抽象工厂模式
08-13
抽象工厂模式是创建型设计模式的一种，它提供了一种创建对象族（一组具有相互依赖关系的对象）的方法，而无需指定具体类。这种模式的核心在于它允许客户端代码与具体实现细节解耦，使得更换一个产品族变得更为容易。...
设计模式-简单工厂模式-例题
最新发布
03-13
为了解决这个问题，可以考虑使用其他更高级的设计模式，比如工厂方法模式或抽象工厂模式等。 总之，在实际开发过程中，选择合适的设计模式是非常重要的，简单工厂模式适用于产品种类较少且未来可能不会频繁发生变化...
3.设计模式-抽象工厂模式1
08-03
抽象工厂模式是一种设计模式，属于创建型模式，它提供了一个创建一系列相关或相互依赖对象的接口，而无需指定它们的具体类。在Java编程中，这种模式可以帮助我们隔离具体类和抽象类之间的耦合，使得系统对扩展友好，...
工厂模式，抽象工厂模式
yszbrzdd的博客
06-24 1368
实验目的与任务 目的：熟悉UML的使用,熟悉工厂方法模式、抽象工厂模式。 任务：按照实验内容要求，完成使用UML和java实现实验内容。 预习内容 复习课程的内容，熟悉工厂方法模式、抽象工厂模式的使用。 实验内容及要求 使用工厂模式： 现有电脑产品，windows和apple，请试用工厂模式描述该场景，要求绘...
抽象工厂模式（Abstract Factory Pattern）
mango_love的专栏
05-26 524
小明的水果店生意特别好又得去批发市场进货，这里有好几家批发商，有卖青苹果、红苹果的，有的卖贡梨、雪梨的，但是顾客一般比较喜欢红苹果和雪梨。如果我们在设计使用工厂方法的时候，需要增加4*2个产品等级结构的类，如果我们使用抽象工厂模式来解决这个 问题那么我们只需要2*2个类就搞定。当系统所提供的工厂的具体产品并不是一个简单的对象，而是多个位于不同产品等级结构属于不同类型的具体产品的时候就可以使用抽象工...
设计模式 抽象工厂模式
往事随风的博客
09-13 353
1 场景问题 1.1 选择组装电脑的配件 举个生活中常见的例子——组装电脑，我们在组装电脑的时候，通常需要选择一系列的配件，比如：CPU、硬盘、内存、主板、电源、机箱等等。为了使讨论简单点，只考虑选择CPU和主板的问题。 事实上，我们在选择CPU的时候，面临一系列的问题，比如：品牌、型号、针脚数目、主频等问题，只有把这些都确定下来，才能确定具体的CPU。同样，在选择主板的时候，也有一系列
简单工厂模式，工厂方法模式，抽象工厂模式总结-java版
海旋风的博客
03-29 3707
关于简单工厂模式，工厂方法模式，抽象工厂模式的一次总结 模式 定义 简单工厂模式 定义一个工厂类，它可以根据参数的不同返回不同类的实例，被创建的实例通常都具有共同的父类。 工厂方法模式 定义一个用于创建对象的接口，但是让子类决定将哪一个类实例化。工厂方法模式让一个类的实例化延迟到其子类 抽象工厂模式 提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类 P...
java实现工厂模式与抽象工厂模式
海旋风的博客
03-21 707
java—实现工厂模式与抽象工厂模式 1.使用工厂模式 问题：现有电脑产品windows和apple，请试用工厂模式描述该场景。 思路： 1. 根据描述，我们可以先创建两个产品类：Windows类和Apple类，然后定义一个产品接口，让这两个类实现接口方法表示类已经创建。 public interface Product { public void run(); } public class ...
一天一模式之7抽象工厂模式
天空鸟的博客
05-25 250
初识抽象工厂模式 定义 提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。 结构和说明 AbstractFactory： 抽象工厂，定义创建一系列产品对象的操作接口。 ConcreteFactory： 具体的工厂，实现抽象工厂定义的方法，具体实现一系列产品对象的创建。 AbstractProduct： 定义一类产品对象的接口。 Co...
「设计模式」抽象工厂模式
frozenpenguin的博客
11-01 2497
抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。抽象工厂模式又称为Kit模式，属于对象创建型模式。抽象工厂模式是所有形式的工厂模式中最为抽象和最具一般性的一种形态。抽象工厂模式的主要优点是隔离了具体类的生成，使得客户并不需要知道什么被创建，而且每次可以通过具体工厂类创建一个产品族中的多个对象，增加或者替换产品族比较方便，增加新的具体工厂和产品族很方便；主要缺点在于增加新的产品等级结构很复杂，需要修改抽象工厂和所有的具体工厂类，对“开闭原则”的支持呈现倾斜性。
C语言和设计模式（抽象工厂模式）
热门推荐
嵌入式-老费，一个分享专业嵌入式知识的blog
12-20 1万+
【 声明：版权所有，欢迎转载，请勿用于商业用途。  联系信箱：feixiaoxing @163.com】     前面我们写过的工厂模式实际上是对产品的抽象。对于不同的用户需求，我们可以给予不同的产品，而且这些产品的接口都是一致的。而抽象工厂呢？顾名思义，就是说我们的工厂是不一定的。怎么理解呢，举个例子。     假设有两个水果店都在卖水果，都卖苹果和葡萄。其中一个水果店买白苹果和白葡
请MM吃饭之抽象工厂模式实现
weixin_34138521的博客
05-24 141
原创作品，允许转载，转载时请务必以超链接形式标明文章原始出处、作者信息和本声明。否则将追究法律责任。http://dba10g.blog.51cto.com/764602/228956 MM 答应和我交往了，这对我是莫大的鼓励啊，ME决定再接再厉，一鼓作气，以迅雷不及掩耳盗铃之势夺取她的芳心。请客吃饭，不管饭店多高档繁华，都不及自己亲手做的表真心...
Java设计模式：简单工厂与抽象工厂模式实战解析
"本文主要探讨了Java编程中的两种设计模式——简单工厂模式和抽象工厂模式，它们都属于创建型设计模式。文章通过实例代码详细解释了这两种模式的应用，并指出了简单工厂模式的一些潜在问题以及可能的改进方式。" 在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值