设计模式简析

最新推荐文章于 2024-07-12 17:30:22 发布
最新推荐文章于 2024-07-12 17:30:22 发布
阅读量576 收藏 9
点赞数 22
文章标签： 设计模式 java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_28036897/article/details/140135442
版权

文章目录

单例模式

  • 饿汉式单例

    在类加载时就创建实例，简单方便，但是会多耗资源

    public class Hunger {

    //类加载的时候就创建了实例
    private static Hunger instance = new Hunger();

    //私有构造方法，防止外部创建实例
    private Hunger(){};

    //对外提供获取实例的方法
    public static Hunger getInstance(){
        return instance;
    }
}

  • 懒汉式单例

    只在需要实例时创建，第一次创建，之后获取唯一的实例。减少资源消耗，但是多线程时如果两个线程一前一后进入获取实例的逻辑，a线程进入逻辑但是还没有实例化时，b线程也同是进去就会破坏单例

    /**
 * Created with IntelliJ IDEA.
 *
 * @Author:Grant
 * @Description:懒汉式创建，但是多线程会在判断实例为null后创建多个实例，a线程判断null后初始化实例同时b线程也判断了null，所以会创建多个实例
 * @Date: 2024/06/17/14:42
 */
public class Lazy {

    //创建实例但是不初始化
    private static Lazy instance;

    //私有构造器
    private Lazy() {
    }

    //获取实例
    public static Lazy getInstance() {
        //只有实例不存在时创建
        if (instance == null) {
            instance = new Lazy();
        }
        return instance;
    }
}

  • 双重检查锁

    通过锁住代码块并再次判断实例是否为空可以避免懒汉式的问题，通过volatile声明实例的可见性。

    /**
 * Created with IntelliJ IDEA.
 *
 * @Author:Grant
 * @Description:
 * @Date: 2024/06/17/14:48
 */
public class DoubleCheck {

    private  static volatile DoubleCheck instance;

    private DoubleCheck() {
    }

    public static DoubleCheck getInstance() {
        if (instance == null) {
            synchronized (DoubleCheck.class) {
                if (instance == null) {
                    instance = new DoubleCheck();
                }
            }
        }
        return instance;
    }
}

观察者模式

​ 行为型模式，针对被观察者的变动，所有观察者都会检测到并作出对应动作。也叫订阅-发布模式。

优点：

​ 1、通过接口进行解耦

​ 2、可动态对观察者对象增加删减，灵活性提高

​ 3、符合开闭原则

缺点：

​ 1、观察者的增加删减需要小心，不当删除会导致内存泄漏

​ 2、多个接口会复杂化程序

组成：

​ 抽象被观察者：定义了一个接口，包含了注册观察者、删除观察者、通知观察者等方法。

​ 具体被观察者：实现了抽象被观察者接口，维护了一个观察者列表，并在状态发生改变时通知所有注册的观察者。

​ 抽象观察者：定义了一个接口，包含了更新状态的方法。

​ 具体观察者：实现了抽象观察者接口，存储了需要观察的被观察者对象，并在被观察者状态发生改变时进行相应的处理。

一般来说被观察者会保存观察者的信息，通过观察者的接口完成事件的发布和对应的业务处理。

示例：

package com.grant.design.observer;

/**
 * Created with IntelliJ IDEA.
 *
 * @Author:Grant
 * @Description:生产者即被观察者
 * @Date: 2024/06/19/14:24
 */
public interface Provider {

    //添加观察者
    void addConusmer(Consumer conusmer);

    //移除观察者
    void removeConusmer(Consumer conusmer);

    //通知观察者
    void notifyConusmer();
}


package com.grant.design.observer;

/**
 * Created with IntelliJ IDEA.
 *
 * @Author:Grant
 * @Description:
 * @Date: 2024/06/19/14:25
 */
public interface Consumer {

    void handle();
}



package com.grant.design.observer.impl;

import com.grant.design.observer.Consumer;
import com.grant.design.observer.Provider;

import java.util.ArrayList;
import java.util.List;

/**
 * Created with IntelliJ IDEA.
 *
 * @Author:Grant
 * @Description:
 * @Date: 2024/06/19/14:26
 */
public class ProviderImpl implements Provider {

    List<Consumer> consumers = new ArrayList<>();

    @Override
    public void addConusmer(Consumer conusmer) {
        consumers.add(conusmer);
        System.out.println("添加消费者,当前观察者数量:"+this.consumers.size());
    }

    @Override
    public void removeConusmer(Consumer conusmer) {
        consumers.remove(conusmer);
        System.out.println("去除消费者,当前观察者数量:"+this.consumers.size());

    }

    @Override
    public void notifyConusmer() {
        consumers.forEach( item -> {
                item.handle();
        });
    }
}


package com.grant.design.observer.impl;

import com.grant.design.observer.Consumer;

/**
 * Created with IntelliJ IDEA.
 *
 * @Author:Grant
 * @Description:
 * @Date: 2024/06/19/14:34
 */
public class ConsumerImpl implements Consumer {

    @Override
    public void handle() {
        System.out.println("消费者消费了");
    }
}



package com.grant.design.observer.test;

import com.grant.design.observer.Provider;
import com.grant.design.observer.impl.ConsumerImpl;
import com.grant.design.observer.impl.ProviderImpl;

/**
 * Created with IntelliJ IDEA.
 *
 * @Author:Grant
 * @Description:
 * @Date: 2024/06/19/14:37
 */
public class TestMain {

    public static void main(String[] args) {
        Provider provider = new ProviderImpl();
        provider.addConusmer(new ConsumerImpl());

        provider.notifyConusmer();
    }
}

装饰器模式

​ 简单来说装饰器模式就是有一个最基本的接口，基于这个接口对应的某个方面需要拓展的地方实现一个基本类，然后基于这个基本类可以拓展别的操作，如在原有的方法中需要做别的处理，类似于一个迭代链，在这个链中可以随意选取不同的装饰器组装，而且对原有的功能没有影响。

package com.grant.design.decorator.entity;

import lombok.Data;

import java.math.BigDecimal;

/**
 * Created with IntelliJ IDEA.
 *
 * @Author:Grant
 * @Description:
 * @Date: 2024/07/01/16:16
 */
@Data
public class Obj1 {

    private String id;

    private BigDecimal price;

    private Favorable favorable;

}


package com.grant.design.decorator.entity;

import lombok.Data;

import java.math.BigDecimal;

/**
 * Created with IntelliJ IDEA.
 *
 * @Author:Grant
 * @Description:
 * @Date: 2024/07/01/16:19
 */
@Data
public class Favorable {

    private int id;
    
    private BigDecimal couponPrice;

}



package com.grant.design.decorator;

import com.grant.design.decorator.entity.Order;

import java.math.BigDecimal;

/**
 * Created with IntelliJ IDEA.
 *
 * @Author:Grant
 * @Description:
 * @Date: 2024/07/01/16:20
 */
public interface OrderInterface {

    public BigDecimal calculateOrderPrice(Order order);
}


package com.grant.design.decorator;

import com.grant.design.decorator.entity.Order;

import java.math.BigDecimal;

/**
 * Created with IntelliJ IDEA.
 *
 * @Author:Grant
 * @Description:
 * @Date: 2024/07/01/16:29
 */
public class BaseOrder implements OrderInterface {

    @Override
    public BigDecimal calculateOrderPrice(Order order) {
        return order.getPrice() - order.getFavorable().getCouponPrice;
    }
}

package com.grant.design.decorator;

import com.grant.design.decorator.entity.Order;

import java.math.BigDecimal;

/**
 * Created with IntelliJ IDEA.
 *
 * @Author:Grant
 * @Description:
 * @Date: 2024/07/01/16:31
 */
public abstract class BaseOrderDecorator implements OrderInterface {

    private OrderInterface orderInterface;

    public BaseOrderDecorator(OrderInterface orderInterface){
        this.orderInterface = orderInterface;
    }

    @Override
    public BigDecimal calculateOrderPrice(Order order) {
        return orderInterface.calculateOrderPrice(order);
    }
}


package com.grant.design.decorator;

import com.grant.design.decorator.entity.Order;

import java.math.BigDecimal;

/**
 * Created with IntelliJ IDEA.
 *
 * @Author:Grant
 * @Description:
 * @Date: 2024/07/01/16:41
 */
public class FullReductionDecorator extends BaseOrderDecorator{

    public FullReductionDecorator(OrderInterface orderInterface) {
        super(orderInterface);
    }

    @Override
    public BigDecimal calculateOrderPrice(Order order) {
        order.setPrice(super.calculateOrderPrice(order));
        return calculateFullReductionPrice(order);
    }

    private BigDecimal calculateFullReductionPrice(Order order){
        return order.price.subtract(order.getFavorable().getCouponPrice);
    }
}




//使用方式
OrderInterface orderInterface = new BaseOrder();
BaseOrderDecorator redPacketDecorator = new RedPacketDecorator(orderInterface);
BaseOrderDecorator fullReductionDecorator = new FullReductionDecorator(redPacketDecorator);

工厂模式

​ 工厂模式，这里介绍简单工厂，方法工厂。工厂模式的使用时用于简化代码，减少重复的代码。

简单工厂

​ 简单工厂提供了不需要知道具体类名的就可获取所需类的接口，简化了部分代码，但是可拓展性差，每当有新的类需要添加时就要对工厂类做修改，违反了开闭原则-对修改关闭，对拓展开放。

package com.grant.design.factory.SimpleFactory;

/**
 * Created with IntelliJ IDEA.
 *
 * @Author:Grant
 * @Description:
 * @Date: 2024/06/19/14:57
 */
public class SimpleFactory {

    public static Father getObject(String type)
    {
        switch (type){
            case "son1":
                return new Son1();
            case "son2":
                return new Son2();
            default:
                return null;
        }
    }
}

这就是一个简单工厂的例子，对于工厂类来说，通过基类和参数可以返回不同类，使用者也不需要知道具体类名。

方法工厂

​ 区别于简单工厂的拓展性差，产品种类少的缺点，方法工厂在原有的工厂类上又抽象出一个工厂接口，可自行选择不同的工厂类，再将具体的实例获取推迟到各个子工厂中。这种方式耦合性低，拓展性强，针对复杂产品可有条理的解决。

//三个基类

package com.grant.design.factory.methodFactory;

import lombok.Data;

/**
 * Created with IntelliJ IDEA.
 *
 * @Author:Grant
 * @Description:
 * @Date: 2024/07/01/15:27
 */
@Data
public class Product {

    private String name;

    private Long id;
}


package com.grant.design.factory.methodFactory;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * Created with IntelliJ IDEA.
 *
 * @Author:Grant
 * @Description:
 * @Date: 2024/07/01/15:28
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Product1 extends Product{

    private String name = "Product1";

    private String description;
}


package com.grant.design.factory.methodFactory;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * Created with IntelliJ IDEA.
 *
 * @Author:Grant
 * @Description:
 * @Date: 2024/07/01/15:28
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Product2 extends Product{

    private String name = "Product2";

    private String date;
}



package com.grant.design.factory.methodFactory;

/**
 * Created with IntelliJ IDEA.
 *
 * @Author:Grant
 * @Description:
 * @Date: 2024/06/19/15:20
 */
public interface AbstractFactory {

    Product getObject();
}


package com.grant.design.factory.methodFactory;

/**
 * Created with IntelliJ IDEA.
 *
 * @Author:Grant
 * @Description:
 * @Date: 2024/07/01/15:25
 */
public class Product1Factory implements AbstractFactory{

    @Override
    public Product getObject() {
        return new Product1();
    }
}


package com.grant.design.factory.methodFactory;

/**
 * Created with IntelliJ IDEA.
 *
 * @Author:Grant
 * @Description:
 * @Date: 2024/07/01/15:25
 */
public class Product2Factory implements AbstractFactory{

    @Override
    public Product getObject() {
        return new Product2();
    }
}



package com.grant.design.factory.methodFactory;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.RequiredArgsConstructor;

/**
 * Created with IntelliJ IDEA.
 *
 * @Author:Grant
 * @Description:
 * @Date: 2024/07/01/15:34
 */
@Data
@AllArgsConstructor
public class ClientStore {

    private AbstractFactory factory;

    public void setFactory(AbstractFactory factory) {
        this.factory = factory;
    }

    public void getProduct() {
        Product product = factory.getObject();
        System.out.println(product.getName());
    }
}



package com.grant.design.factory;

import com.grant.design.factory.SimpleFactory.Father;
import com.grant.design.factory.SimpleFactory.SimpleFactory;
import com.grant.design.factory.methodFactory.ClientStore;
import com.grant.design.factory.methodFactory.Product1Factory;
import com.grant.design.factory.methodFactory.Product2Factory;

/**
 * Created with IntelliJ IDEA.
 *
 * @Author:Grant
 * @Description:
 * @Date: 2024/06/19/15:02
 */
public class TestMain {
    public static void main(String[] args) {

        //methodFactory
        ClientStore clientStore = new ClientStore(new Product1Factory());
        clientStore.getProduct();
        clientStore.setFactory(new Product2Factory());
        clientStore.getProduct();
    }
}

建造者模式

​ 当一个类在构造时有很多的参数并且这些参数都是可选时就可以使用建造者模式。

​ 通过在类内部构造静态builder类并在其中构造源类的实例返回。静态类中的参数需要和源类一致。

package com.grant.design.builder;

import lombok.Data;
import lombok.ToString;

/**
 * Created with IntelliJ IDEA.
 *
 * @Author:Grant
 * @Description:
 * @Date: 2024/07/02/11:23
 */
@Data
@ToString
public class Product {

    String id;

    String name;

    String description;

    public Product(Builder builder) {
        this.id = builder.id;
        this.name = builder.name;
        this.description = builder.description;
    }


    public static class Builder {

        String id;

        String name;

        String description;

        public Builder setId(String id) {
            this.id = id;
            return this;
        }

        public Builder setName(String name) {
            this.name = name;
            return this;
        }

        public Builder setDescription(String description) {
            this.description = description;
            return this;
        }

        public Product build() {
            return new Product(this);
        }
    }
}
worm-debug
关注
  • 22
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
设计模式简析与汇总
东晨雨的博客
05-16 147
预计阅读时间：10 分钟 1、设计模式的种类 设计模式分为三大类： 创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。 结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。 行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式...
Java设计模式之工厂方法模式实例简析
09-03
工厂方法模式是面向对象设计模式中的一种，它属于创建型模式，主要解决的是当系统中类的实例化过程比较复杂，或者需要根据不同的条件或策略创建不同类型的对象时的问题。在Java编程中，工厂方法模式被广泛应用于各种...
23种设计模式简析
zwwws的博客
11-20 147
创建型模式：关注对象的创建过程 • 单例模式：保证一个类只有一个实例，并且提供一个访问该实例的全局访问点 主要： 饿汉式（线程安全，调用效率高，但是不能延时加载） 懒汉式（线程安全，调用效率不高，但是可以延时加载） 其他： 双重检测锁式（由于JVM底层内部模型原因，偶尔会出问题。不建议使用） 静态内部类式（线程安全，调用效率高。但是可以延时加载） 枚举单例（线程安全，调用效率高，不能延时加载） •...
VCL之设计模式简析
不以物喜，不以己悲
09-05 507
说到设计模式，这个是我一直有种冲动想要写点什么的，但不知如何下笔，其实今天写这篇文章也是硬着头皮写的，因为我说要写的，不能再耽搁了。 为什么拖了这么长时间，是因为不知道从设计模式，还是从具体的代码开始。为了集中精力深入研究,我还是要选择从具体代码开始。 这里我只捡几个常见的VCL类做讲。1.TControl  2.TStrings  3.TObject  4.TStream  5.TDockTre...
设计模式 简析
china1000的专栏
05-29 481
学习中，将会记录每种设计模式的应用和UML类图。 （1）  工厂模式      提供创建对象的接口. 为所实例化的多个类定义一个公共接口，并由服务提供者而不是客户端代码，来确定要实例化上述类中的哪一个类。       工厂模式 工厂设计模式是面向对象编程中最常用的设计模式之一。它又被称为创建性模式，因为它被用来创建其他类。在应用程序预见不到自己要创建的对象类型
.NET设计模式简析
weixin_30787531的博客
07-07 83
首先，是设计模式的分类，我们知道，常用的设计模式共23种。但总体来说，设计模式氛围三大类： 创建型模式，共五种：工厂方法模式、抽象工厂模式、单列模式、建造者模式、原型模式。 结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。 行为型模式，共十一种：策略模式、模版方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、转改模式、访问者模式...
单例设计模式简析（java语言实现）
FBB360JAVA的博客
08-04 298
单例设计模式 单例设计模式是指：该类只有一个实例，也就是说在整个程序的运行过程中，就只有一个它。
装饰设计模式简析
Brighten的的博客
04-06 152
装饰设计模式使用场景：当想要对已有的对象进行功能增强时，可以定义类，将已有对象传入，基于已有功能，并提供加强功能，那么自定义的该类称为装饰类。装饰类通常会通过构造方法接受被装饰的对象，并基于被装饰对象的功能，提供更强的功能。装饰类因为增强已有对象，具备的功能和已有的是相同类型的，只不过要更强。所以装饰类和被装饰类通常是属于同一个体系之中的。 装饰设计模式与继承装饰模式比继承要灵活，避免了继承体系的
iOS-设计模式简析
weixin_34128237的博客
06-11 255
参考:《Objective-C编程之道》 前言 这边文章是在学习了《Objective-C编程之道》后的做的一些笔记,在其中参考了其他相关书籍或者其他前辈的例子以及一些文章内容,有引用到的地方我已经尽量添加原文链接或者引用了,如果发现本文侵权可联系删除. 此篇文章主要是对各个模式对介绍,此处引用对例子是我认为比较合适比较容易理解对例子,不过也会有一些片面,无法完全解决各个模式.这篇文章总的来说适合...
JAVA单例设计模式简析
Flossy
08-19 255
一.设计模式是什么？ 设计模式的概念起源于建筑行业，其实生活中的方方面面都有其模式，从衣食到住行，用最近比较流行的话来说就是套路。软件开发设计模式的概念简单说就是前人总结的经验，运用这些经验针对某一问题研究出的行之有效的解决方案。在现在公司的开发中最为常见，例如：java ee中的框架就可以说是设计模式的一种体现。         java的设计模式有23种，也就是我们常说的GOF 23，在这
轿车营销模式简析
12-12
《轿车营销模式简析》这份文档是针对汽车行业营销策略的一份深入研究，旨在规范营销管理，提高企业经营绩效。在当今竞争激烈的汽车市场中，有效的营销模式是企业获得竞争优势的关键。下面将对其中的主要知识点进行...
区域奖励模式简析.doc
09-29
综上所述，区域奖励模式的构建需要综合考虑企业战略、地区差异、行业特性以及员工激励等多个因素，通过科学的考核体系和合理的薪酬设计，确保各个区域的分公司能够在公平的环境中高效运作，同时激发员工的积极性和...
简析J2EE应用程序中数据库类的设计模式
03-04
【简析J2EE应用程序中数据库类的设计模式】 在J2EE应用程序的开发过程中，数据库类的设计至关重要，它直接影响到系统的可维护性、扩展性和性能。本文主要探讨在不使用EJB技术的情况下，如何设计数据库类，特别是...
Discuz!NT 缓存设计简析
08-19
NT 缓存设计简析】 Discuz!NT 是一款基于.NET平台的社区论坛软件，其缓存设计是提高系统性能的关键部分。在本文中，我们将深入探讨Discuz!NT的缓存架构，了解它如何利用策略模式来优化数据访问，并探讨其中涉及到的...
常用设计模式
最新发布
u010992421的专栏
07-12 938
设计模式是在软件开发中经过验证的、用于解决常见问题的最佳实践。它们可以帮助开发者设计出更加灵活、可维护和可扩展的软件系统。这些设计模式通常被分为三大类：创建型模式、结构型模式和行为型模式。
GPT带我学-设计模式13-策略模式
qq_37398465的博客
07-09 488
策略模式。
Java学习笔记整理: 关于设计模式解析和设计原则 2024/7/10；
gzx233的博客
07-10 596
Java设计模式设计原则
JavaScript设计模式 -- 代理模式
m0_73280507的博客
07-10 970
@FilePath: \设计模式\代理模式.md* @Description: 这是默认设置,请设置`customMade`, 打开koroFileHeader查看配置 进行设置: https://github.com/OBKoro1/koro1FileHeader/wiki/%E9%85%8D%E7%BD%AE。
factory模式.doc
12-21
工厂模式是一种创建型设计模式，它提供了一种创建对象的最佳方式，而不需要程序员显式地指定具体类的实例化过程。工厂模式根据不同的需求和条件，使用不同的工厂来创建产品。其中，简单工厂模式和抽象工厂模式是比较...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值