设计模式2 工厂模式 推荐使用工厂方法模式和抽象工厂模式

最新推荐文章于 2024-05-22 09:17:25 发布
最新推荐文章于 2024-05-22 09:17:25 发布
阅读量125 收藏
点赞数
文章标签： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AdamCafe/article/details/119443988
版权

1、工厂模式

工厂模式详细介绍：

工厂模式主要是为创建对象提供了接口。工厂模式按照《Java与模式》中的提法分为三类：
1.简单工厂模式(Simple Factory)
在这里插入图片描述

2.工厂方法模式(Factory Method)
在这里插入图片描述

3.抽象工厂模式(Abstract Factory)
在这里插入图片描述

在什么样的情况下我们应该记得使用工厂模式呢？大体有两点：
1.在编码时不能预见需要创建哪种类的实例。
2.系统不应依赖于产品类实例如何被创建、组合和表达的细节
换言之：就要有一个工厂，能够生产各种各样的车，我不关注于生产车辆的细节。只关注怎么掉工厂方法产生车。

原生：

package test1;


public class FactoryMethod {
    public static void main(String[] args) {
        Application application = new Application();
        ProductA productA = application.getObject();
        productA.method1();

    }
}

class ProductA{
    public void method1(){
        System.out.println("ProductA。method1 executed");
    }
}

class Application {
    private ProductA creatProduct(){
        // ...
        return new ProductA();
    }

    public ProductA getObject(){
        ProductA product = creatProduct();
        //  ...
        return product;
    }

}

改造后： 简单工厂模式
在这里插入图片描述
优点：新增一个商品，若商品符合工厂商品合同，适当修改后就能供客户使用
缺点：每增加一个商品，需要在工厂中增加相应的商业逻辑和判断逻辑，违背了开闭原则

package test1;


public class testFactoryMethod {
    public static void main(String[] args) {
        Application1 application = new Application1();
        Product product = application.getObject("1");
        product.method();
    }
}


class SimpleFactory{
    public static Product createProduct(String type){
        if(type.equals("0")){
            return new ProductA1();
        }else if(type.equals("1")){
            return new ProductA2();
        }else{
            throw new RuntimeException("输入参数有误");
        }
    }
}
interface Product{
    public void method();
}

class ProductA1 implements Product{
    public void method(){
        System.out.println("ProductA1.method executed");
    }
}

class ProductA2 implements Product{
    public void method(){
        System.out.println("ProductA2.method executed");
    }
}


class Application1 {
    private Product creatProduct(String type){
        // ...
        return SimpleFactory.createProduct(type);
    }
    public Product getObject(String type){
        Product product = creatProduct(type);
        //  ...
        return product;
    }

}

工厂方法模式：
模式定义：定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method 使得一个类的实例化延迟到子类
在这里插入图片描述

//抽象产品  
abstract class Car{  
    private String name;  
      
    public abstract void drive();  
      
    public String getName() {  
        return name;  
    }  
    public void setName(String name) {  
        this.name = name;  
    }  
}  
//具体产品  
class Benz extends Car{  
    public void drive(){  
        System.out.println(this.getName()+"----go-----------------------");  
    }  
}  
class Bmw extends Car{  
    public void drive(){  
        System.out.println(this.getName()+"----go-----------------------");  
    }  
}  
  
  
//抽象工厂  
abstract class Driver{  
    public abstract Car createCar(String car) throws Exception;  
}  
//具体工厂（每个具体工厂负责一个具体产品）  
class BenzDriver extends Driver{  
    public Car createCar(String car) throws Exception {  
        return new Benz();  
    }  
}  
class BmwDriver extends Driver{  
    public Car createCar(String car) throws Exception {  
        return new Bmw();  
    }  
}  
  
//老板  
public class Boss{  
  
    public static void main(String[] args) throws Exception {  
        Driver d = new BenzDriver();  
        Car c = d.createCar("benz");   
        c.setName("benz");  
        c.drive();  
    }  
}  

package test2;


public class testFactoryMethod1 {
    public static void main(String[] args) {
        Application application = new ConcreateProductB();
        Product product = application.getObject();
        product.method();
    }
}

interface Product{
    public void method();
}

class ProductA1 implements Product{
    public void method(){
        System.out.println("ProductA1.method executed");
    }
}

class ProductA2 implements Product{
    public void method(){
        System.out.println("ProductA2.method executed");
    }
}


abstract class Application {
    // 工厂方法：
    abstract Product creatProduct();
    Product getObject(){
        Product product = creatProduct();
        //  ...
        return product;
    }
}

class ConcreateProductA extends Application{
     // 让对应的Product延迟到子类
    @Override
    Product creatProduct() {
        //.. 具体实现逻辑
        return new ProductA1();
    }
}
class ConcreateProductB extends Application{

    @Override
    Product creatProduct() {
        //.. 具体实现逻辑
        return new ProductA2();
    }
}

优点：符合开闭原则
缺点：产品种类非常多时，就会出现大量的与之对应的工厂类，这不应该是我们所希望的

抽象工厂模式： 开闭原则 推荐使用
模式定义：提供一个创建一系列相关或互相依赖对象的接口，而无需指定它们具体的类
它和工厂方法模式的区别就在于需要创建对象的复杂程度上。
抽象工厂模式的用意为：给客户端提供一个接口，可以创建多个产品族中的产品对象。
在这里插入图片描述
在这里插入图片描述

//抽象产品（Bmw和Audi同理）  
abstract class BenzCar{  
    private String name;  
      
    public abstract void drive();  
      
    public String getName() {  
        return name;  
    }  
    public void setName(String name) {  
        this.name = name;  
    }  
}  
//具体产品（Bmw和Audi同理）  
class BenzSportCar extends BenzCar{  
    public void drive(){  
        System.out.println(this.getName()+"----BenzSportCar-----------------------");  
    }  
}  
class BenzBusinessCar extends BenzCar{  
    public void drive(){  
        System.out.println(this.getName()+"----BenzBusinessCar-----------------------");  
    }  
}  
  
abstract class BmwCar{  
    private String name;  
      
    public abstract void drive();  
      
    public String getName() {  
        return name;  
    }  
    public void setName(String name) {  
        this.name = name;  
    }  
}  
class BmwSportCar extends BmwCar{  
    public void drive(){  
        System.out.println(this.getName()+"----BmwSportCar-----------------------");  
    }  
}  
class BmwBusinessCar extends BmwCar{  
    public void drive(){  
        System.out.println(this.getName()+"----BmwBusinessCar-----------------------");  
    }  
}  
  
abstract class AudiCar{  
    private String name;  
      
    public abstract void drive();  
      
    public String getName() {  
        return name;  
    }  
    public void setName(String name) {  
        this.name = name;  
    }  
}  
class AudiSportCar extends AudiCar{  
    public void drive(){  
        System.out.println(this.getName()+"----AudiSportCar-----------------------");  
    }  
}  
class AudiBusinessCar extends AudiCar{  
    public void drive(){  
        System.out.println(this.getName()+"----AudiBusinessCar-----------------------");  
    }  
}  
  
  
//抽象工厂  
abstract class Driver3{  
    public abstract BenzCar createBenzCar(String car) throws Exception;  
      
    public abstract BmwCar createBmwCar(String car) throws Exception;  
      
    public abstract AudiCar createAudiCar(String car) throws Exception;  
}  
//具体工厂  
class SportDriver extends Driver3{  
    public BenzCar createBenzCar(String car) throws Exception {  
        return new BenzSportCar();  
    }  
    public BmwCar createBmwCar(String car) throws Exception {  
        return new BmwSportCar();  
    }  
    public AudiCar createAudiCar(String car) throws Exception {  
        return new AudiSportCar();  
    }  
}  
class BusinessDriver extends Driver3{  
    public BenzCar createBenzCar(String car) throws Exception {  
        return new BenzBusinessCar();  
    }  
    public BmwCar createBmwCar(String car) throws Exception {  
        return new BmwBusinessCar();  
    }  
    public AudiCar createAudiCar(String car) throws Exception {  
        return new AudiBusinessCar();  
    }  
}  
  
//老板  
public class BossAbstractFactory {  
  
    public static void main(String[] args) throws Exception {  
          
        Driver3 d = new BusinessDriver();  
        AudiCar car = d.createAudiCar("");  
        car.drive();  
    }  
}

改进后：

/** 
 * 简单工厂通过反射改进抽象工厂及其子工厂 
 * @author Administrator 
 * 
 */  
class Driver3{  
    public static BenzCar createBenzCar(String car) throws Exception {  
        return (BenzCar) Class.forName(car).newInstance();  
    }  
      
    public static BmwCar createBmwCar(String car) throws Exception {  
        return (BmwCar) Class.forName(car).newInstance();  
    }  
      
    public static AudiCar createAudiCar(String car) throws Exception {  
        return (AudiCar) Class.forName(car).newInstance();  
    }  
}  
//客户端  
public class SimpleAndAbstractFactory {  
  
    public static void main(String[] args) throws Exception {  
  
        AudiCar car = Driver3.createAudiCar("com.java.pattendesign.factory.AudiSportCar");  
        car.drive();  
    }  
}

另一个例子：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
oracle同理：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

2、应用场景

在这里插入图片描述

详细介绍见：
https://www.cnblogs.com/deityjian/p/10908739.html

AdamCafe
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
简单工厂、工厂方法和抽象工厂
weixin_43217564的博客
08-19 309
前言 在学习设计模式之前，可以先学习面向对象设计原则之六原则一法则，他们与设计模式互为表里，一脉相承 简单工厂 适用范围：当多个地方需要创建 “有共同特征的” 实例的时候 具体实现：把一类对象的实例化放到一个工厂中，当工厂持有者需要创建实例时，只要向工厂对象中拿就可以了，具体工厂对象能够提供多少种实例、实例的创建过程需要什么繁杂操作，工厂持有者并不需要关心。 举例： 有三种产品，用户从控制台输入产品类型，然后系统返回对应型号的产品。 使用简单工厂模式的代码如下： package com.zenghui.fa
抽象工厂模式（优缺点、使用场景、具体实现）
cxy_zxl的博客
05-12 2万+
抽象工厂模式1、优缺点2、使用场景3、具体实现 抽象工厂模式提供了一个创建一系列相关或者相互依赖对象的接口，无需指定他们具体的类 1、优缺点 优点： 1.具体产品在应用层的代码隔离，无需关系创建的细节 2.将一个系列的产品统一到一起创建 缺点： 1.规定了所有可能被创建的产品集合，产品族中扩展新的产品困难； 2.增加了系统的抽象性和理解难度 2、使用场景 1.客户端（应用层）不依赖与产品类示例如何被创建、实现等细节 2.强调一系列相关的产品对象（数据同一产品族）一起使用创建对象需要大量的重复代码 3.提供一
设计模式之抽象工厂模式+原型模式+适配器模式+建造者模式结合使用与总结
阿宁的博客
02-28 1637
在原抽象工厂模式+建造者模式中添加了原型模式和适配器模式 抽象工厂模式和建造者模式结合链接：https://blog.csdn.net/qq_18625571/article/details/104416504 一、模式解析 1、原型模式 (1)概述 用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型相同或相似的新对象。在这里，原型实例指定了要创建的对象的种类。用这种方式创建对象非常...
设计模式（二）工厂模式
Snowing1234_5的博客
06-26 126
**工厂模式：**主要是为创建对象提供了接口，主要分为三类：简单工厂模式(Simple Factory) 、工厂方法模式(Factory Method) 、抽象工厂模式(Abstract Factory) 使用工厂模式的两种情况： （1）在编码时不能预见需要创建哪种类的实例。 （2）系统不应依赖于产品类实例如何被创建、组合和表达的细节 一、简单工厂模式 简单工厂模式又叫静态工厂方法模式（Stati...
设计模式深度解析：工厂方法模式与抽象工厂模式的深度对比
制定明确可量化的目标，坚持默默的做事。
03-11 8276
本文旨在深入对比软件设计模式中的工厂方法模式和抽象工厂模式。工厂方法模式侧重于定义一个用于创建对象的接口，让子类决定实例化哪一个类。它提供了一种封装机制，将对象的创建与使用分离，降低了耦合度。而抽象工厂模式则提供了一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。这种模式具有更强的扩展性，能够适应更为复杂的产品结构。通过对比分析，我们发现，两种模式各有优势，工厂方法模式更适用于单一产品的创建，而抽象工厂模式在处理产品族问题时更为得力。在选择使用哪种模式时，需根据具体的应用场景和需求进行综合考量
Java设计模式之创建型：工厂模式详解（简单工厂+工厂方法+抽象工厂）
热门推荐
张维鹏的博客
09-13 7万+
工厂模式将目的将创建对象的具体过程屏蔽隔离起来，从而达到更高的灵活性，工厂模式可以分为三类：简单工厂模式、工厂方法模式、抽象工厂模式；简单工厂模式的核心是定义一个创建对象的接口，将对象的创建和本身的业务逻辑分离。工厂方法模式将工厂抽象化，并定义一个创建对象的接口。每增加新产品，只需增加该产品以及对应的具体实现工厂类，由具体工厂类决定要实例化的产品是哪个，将对象的创建与实例化延迟到子类。抽象工厂模式用于创建相关对象的家族。当一个产品族中需要被设计在一起工作时，通过抽象工厂模式，保证客户端始终只使用同一个产品族
设计模式-工厂方法模式和抽象工厂模式
a410974689的博客
02-08 859
(1) 定义：是一种为访问类提供一个创建一组相关或相互依赖对象的接口，且访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构。抽象工厂模式是工厂方法模式的升级版本，工厂方法模式只生产一个等级的产品，而抽象工厂模式可生产多个等级的产品。抽象工厂需要满足下面条件：A. 系统中有多个产品族，每个具体工厂创建同一族但属于不同等级结构的产品。B. 系统一次只可能消费其中某一族产品，即同族的产品一起使用。(2).优点。
23种设计模式之抽象工厂模式（Abstract Factory Pattern）
小威的博客
05-10 2万+
本篇文章将23种设计模式中的抽象工厂模式，此篇文章为一天学习一个设计模式系列文章，后面会分享其他模式知识。
设计模式：简单工厂模式、工厂方法模式、抽象工厂模式
李白
01-02 1202
简单工厂模式适用于创建对象较少且变化不频繁的情况，工厂方法模式适用于创建对象较多且需要灵活扩展的情况，而抽象工厂模式适用于创建一组相关对象的情况。 所有的工厂模式都强调一点：两个类A和B之间的关系应该仅仅是A创建B或是A使用B，而不能两种关系都有。将对象的创建和使用分离，也使得系统更加符合单一职责原则，有利于对功能的复用和系统的维护。此外，将对象的创建和使用分离还有一个好处：防止用来实例化一个类的数据和代码在多个类中到处都是，可以将有关创建的知识搬移到一个工厂类中。
设计模式——简单工厂、工厂方法和抽象工厂的区别与联系
weixin_42785235的博客
06-02 1602
创建型模式中，常用的有工厂方法模式和抽象工厂模式，平时实践还包括简单工厂模式，虽然简单工厂模式不在23种设计模式中。 为了区分以上几种设计模式的差别，通过以下几个例子介绍这几种模式的使用场景以及优缺点。当然，由于本人接触设计模式时间还不长，难免有疏漏之处，欢迎各位提出意见。考虑如今有一个产品，比如椅子，该椅子可以有多种风格，比如中式的，或者美式的。如果我们不想通过设计模式，想要什么类型的椅子，就可以直接实例化某个实体类获得。“ChineseChair.java”——实体类 “Client.java”——用户
Java设计模式之工厂模式分析【简单工厂、工厂方法、抽象工厂】
08-27
主要介绍了Java设计模式之工厂模式,结合实例形式分析了简单工厂、工厂方法、抽象工厂等相关功能、实现与使用方法,需要的朋友可以参考下
Java设计模式编程中的工厂方法模式和抽象工厂模式
09-02
主要介绍了Java设计模式编程中的工厂方法模式和抽象工厂模式,设计模式的建立有利于团队协作时代码的共同维护,需要的朋友可以参考下
C# 设计模式系列教程-抽象工厂模式
12-26
2.　抽象工厂模式中的角色  2.1 抽象工厂（AbstractFactory）：担任这个角色的是工厂方法模式的核心，它是与应用系统商业逻辑无关的。  2.2 具体工厂（ConcreteFactory）：这个角色直接在客户端的调用下创建产品的...
设计模式：单例设计模式（全部实现方式）工厂设计模式，抽象工厂模式
10-18
单例设计模式、工厂设计模式和抽象工厂模式是常见的软件开发设计模式。这些设计模式提供了一些有用的思想和实现方式，可以帮助开发人员在设计和实现复杂的软件系统时，更加灵活和高效地进行编程。 单例设计模式是一...
c++设计模式-抽象工厂方法
06-04
c++设计模式-创建型-抽象工厂方法-最简单源码-qt工程
Java设计模式-备忘录模式（23）
艾利克斯冰的博客
05-17 22
备忘录模式
如何彻底搞懂迭代器（Iterator）设计模式？
最新发布
2401_83062316的博客
05-22 685
在Mybatis中，存在一个非常常用的工具类PropertyTokenizer，该类主要用于解析诸如“order[0].address.contactinfo.name”类型的属性表达式，在这个例子中，我们可以看到系统是在处理订单实体的地址信息，Mybatis支持使用这种形式的表达式来获取最终的“name”属性。答案是肯定的，让我们来看一下。在今天的内容中，我们通过详细的示例代码对这一设计模式的基本结构进行了展开，并分析了它在Mybatis框架中的两处具有代表性的应用场景以及实现方式。
Java设计模式-责任链模式（17）
艾利克斯冰的博客
05-16 15
责任链模式提供了一种优雅的方式来组织和管理请求的处理流程，它不仅降低了请求发送者与接收者之间的耦合度，还为系统的扩展和维护创造了良好基础。通过灵活的设计，可以适应多种复杂的业务场景，是解决请求处理问题的有效手段之一。然而，其使用也需注意平衡系统复杂度与性能需求，确保模式的应用既满足功能需求，又保持了系统的高效与简洁。
【Python设计模式05】装饰模式
weixin_55252589的博客
05-20 388
pass)"装饰模式是一种结构型设计模式，通过创建装饰类来包裹原始类，实现动态地给对象添加新功能。装饰模式遵循开闭原则，使得系统更具灵活性和可扩展性。尽管装饰模式会增加系统的复杂性，但在需要动态扩展对象功能的场景中，装饰模式是一种非常有用的设计模式。合理应用装饰模式，可以显著提高代码的可维护性和可复用性。
设计模式抽象工厂模式
09-27
抽象工厂模式是一种创建型设计模式，它通过一个超级工厂来创建其他工厂。它适用于创建一组相关或相互依赖的对象。与工厂方法模式不同的是，工厂方法模式针对的是一个产品等级结构，而抽象工厂模式针对的是多个产品...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值