设计模式学习笔记4（行为型）

最新推荐文章于 2024-11-06 18:03:50 发布
最新推荐文章于 2024-11-06 18:03:50 发布
阅读量112 收藏
点赞数
分类专栏： 设计模式 文章标签： 设计模式 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37604054/article/details/115727720
版权

行为型

描述多个类或对象之间怎样相互协作共同完成单个对象都无法单独完成的任务，它涉及算法和对象间职责的分配

模板方法模式
概述

定义一个操作中的算法骨架，将算法的一些步骤延迟到子类中，使得子类在可以不改变算法结构的情况下重新定义该算法的某些特定步骤

优缺点

优点：

  • 封装了不变部分，扩展可变部分。即将不变部分分装到父类中，可变部分交由子类实现
  • 提取了父类中公共的代码部分，实现了代码的复用
  • 符合了开闭原则

缺点：

  • 增加了类的个数，使得系统更加庞大
  • 使用继承关系导致无法添加新的方法
实现
public abstract class AbstractTemplate {
    /**
     * 模板方法
     */
    public void templateMethod(){
        calcHeight();
        calcWeight();
    }
    /**
     * 具体方法
     */
    public void calcHeight(){
        System.out.println("计算身高");
    }

    /**
     * 抽象方法，交由子类扩展
     */
    public abstract void calcWeight();
}
/**
 * 具体子类
 */
public class ConcreteTemplate extends AbstractTemplate{
    @Override
    public void calcWeight() {
        System.out.println("子类实现计算体重");
    }
}
/**
 * 客户端
 */
public class Client {
    public static void main(String[] args) {
        AbstractTemplate template = new ConcreteTemplate();
        template.templateMethod();
    }
}
策略模式
概述

将一组算法封装到一系列的策略类里面，作为一个抽象策略类的子类。其重心是组织算法

优缺点

优点：

  • 可以避免使用多重条件语句
  • 可以提供相同行为的不同实现，客户可以根据不同时间或空间要求选择不同的
  • 提供了对开闭原则的完美支持，可以在不修改原代码的情况下，灵活增加新算法
  • 把算法的使用放到环境类中，而算法的实现移到具体策略类中，实现了二者的分离

缺点：

  • 客户端必须理解所有策略算法的区别，以便适时选择恰当的算法类。
  • 造成很多的策略类，增加维护难度。
实现
/**
 * 抽象策略类
 */
public interface Strategy {
    //抽象策略类
    void operate();
}
/**
 * 具体策略1
 */
public class StrategyImp1  implements Strategy {
    @Override
    public void operate() {
        System.out.println("具体策略1");
    }
}
/**
 * 具体策略2
 */
public class StrategyImp2 implements Strategy {
    @Override
    public void operate() {
        System.out.println("具体策略2");
    }
}
/**
 * 环境类，以供客户端使用
 */
public class Environment {

    private Strategy strategy;

    public void setStrategy(Strategy strategy){
        this.strategy = strategy;
    }

    public void operate(){
        strategy.operate();
    }
}
/**
 * 客户端
 */
public class Client {
    public static void main(String[] args) {
        Environment environment = new Environment();
        environment.setStrategy(new StrategyImp1());
        environment.operate();
        environment.setStrategy(new StrategyImp2());
        environment.operate();
    }
}
责任链模式
概述

为避免请求发送者与多个请求处理者耦合在一起，于是将所有请求的处理者通过前一对象记住其下一个对象的引用而连成一条链；当有请求发生时，可将请求沿着这条链传递，直到有对象处理它为止。

优缺点

优点：

  • 降低了对象之间的耦合度
  • 增强了系统的可扩展性
  • 增强了给对象指派职责的灵活性
  • 责任分担。每个类只需要处理自己该处理的工作，不该处理的传递给下一个对象完成，明确各类的责任范围，符合类的单一职责原则。
    缺点：
  • 不能保证每个请求一定被处理
  • 对比较长的职责链，请求的处理可能涉及多个处理对象，系统性能将受到一定影响
  • 职责链建立的合理性要靠客户端来保证，增加了客户端的复杂性，可能会由于职责链的错误设置而导致系统出错，如可能会造成循环调用
实现
/**
 * 抽象日志类
 */
public abstract class AbstractLogger {

    public static final Integer INFO = 1;
    public static final Integer DEBUG = 2;
    public static final Integer ERROR = 3;

    protected Integer level;

    // 下一个责任链地址
    protected AbstractLogger nextLogger;

    public void setNextLogger(AbstractLogger nextLogger){
        this.nextLogger = nextLogger;
    }

    public void logMessage(Integer level,String message){
        //判断当前日志级别是否小于设置的日志级别，小于等于则处理请求，大于则交由下一日志级别处理
        if(this.level <= level){
            write(message);
        }
        //判断是否存在下一日志级别
        if(nextLogger != null){
            nextLogger.logMessage(level,message);
        }
    }
    public abstract void write(String message);
}
/**
 * error级别日志
 */
public class ErrorLogger extends AbstractLogger{

    public ErrorLogger(Integer level){
        this.level = level;
    }

    @Override
    public void write(String message) {
        System.out.println("ErrorLogger:"+message);
    }
}
/**
 * debug级别日志
 */
public class DebugLogger extends AbstractLogger{

    public DebugLogger(Integer level) {
        this.level = level;
    }

    @Override
    public void write(String message) {
        System.out.println("DebugLogger:"+message);
    }
}
/**
 * info级别日志
 */
public class InfoLogger extends AbstractLogger{

    public InfoLogger(Integer level) {
        this.level = level;
    }

    @Override
    public void write(String message) {
        System.out.println("InfoLogger:"+message);
    }
}
/**
 * 日志工厂，这里使用工厂模式来获取日志对象
 */
public class LoggerFactory {

    /**
     * 获取日志
     * @return
     */
    public static AbstractLogger getLogger(){
        ErrorLogger errorLogger = new ErrorLogger(AbstractLogger.ERROR);
        DebugLogger debugLogger = new DebugLogger(AbstractLogger.DEBUG);
        InfoLogger infoLogger = new InfoLogger(AbstractLogger.INFO);
        errorLogger.setNextLogger(debugLogger);
        debugLogger.setNextLogger(infoLogger);
        return errorLogger;
    }
}
/**
 * 客户端
 */
public class Client {
    public static void main(String[] args) {
        AbstractLogger logger = LoggerFactory.getLogger();
        logger.logMessage(AbstractLogger.INFO,"info message");
        //logger.logMessage(AbstractLogger.ERROR,"error message");
        logger.logMessage(AbstractLogger.DEBUG,"debug message");
    }
}
观察者模式
概述

指多个对象间存在一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新

优缺点

优点：

  • 降低了目标与观察者之间的耦合关系，两者之间是抽象耦合关系。符合依赖倒置原则。
  • 目标与观察者之间建立了一套触发机制

缺点：

  • 目标与观察者之间的依赖关系并没有完全解除，而且有可能出现循环引用
  • 当观察者对象很多时，通知的发布会花费很多时间，影响程序的效率。
实现
public class Subject {
    private List<Observer> observers = new ArrayList<>();
    private Integer state;
    public Integer getState(){
        return state;
    }
    public void attach(Observer observer){
        observers.add(observer);
    }
    public void setState(Integer state){
        this.state = state;
        notifyAllObservers();
    }
    public void notifyAllObservers() {
        for (Observer observer : observers) {
            observer.update();
        }
    }
}
/**
 * 观察者抽象类
 */
public abstract class Observer {
    protected Subject subject;
    public abstract void update() ;
}
public class ChildrenObserver extends Observer{

    public ChildrenObserver(Subject subject){
        this.subject = subject;
        this.subject.attach(this);
    }

    @Override
    public void update() {
        System.out.println("ChildrenObserver:"+subject.getState());
    }
}
public class ChildrenObserver2 extends Observer{

    public ChildrenObserver2(Subject subject){
        this.subject = subject;
        this.subject.attach(this);
    }

    @Override
    public void update() {
        System.out.println("Children2Observer:"+subject.getState());
    }
}
public class ChildrenObserver3 extends Observer{

    public ChildrenObserver3(Subject subject){
        this.subject = subject;
        this.subject.attach(this);
    }

    @Override
    public void update() {
        System.out.println("Children2Observer:"+subject.getState());
    }
}
public class Client {
    public static void main(String[] args) {
        Subject subject = new Subject();
        new ChildrenObserver(subject);
        new ChildrenObserver2(subject);
        new ChildrenObserver3(subject);
        subject.setState(12);
        System.out.println("-------------");
        subject.setState(15);
    }
}
迭代器模式
概述

提供一个对象来顺序访问聚合对象中的一系列数据，而不暴露聚合对象的内部表示

优缺点

优点：

  • 无需暴露内部标识就可访问
  • 遍历任务交由迭代器完成，简化了聚合类，且封装性良好

缺点：

  • 增加了类的个数，这在一定程度上增加了系统的复杂性
实现
/**
 * 迭代器接口
 * @param <T>
 */
public interface Iterator<T> {
    boolean hasNext();
    T next();
}
public interface Container {
    Iterator getIterator();
}
public class NameRepository implements Container{
    private String[] names;

    public NameRepository(String[] names){
        this.names = names;
    }

    @Override
    public Iterator getIterator() {
        return new NameIterator();
    }

    /**
     * 内部迭代器实现类
     */
    private class NameIterator implements Iterator<String>{
        int index;
        @Override
        public boolean hasNext() {
            return index < names.length;
        }

        @Override
        public String next() {
            if(this.hasNext()){
                return names[index++];
            }
            return null;
        }
    }
}
public class Client {
    public static void main(String[] args) {
        String[] names = {"Robert" , "John" ,"Julie" , "Lora"};
        NameRepository nameRepository = new NameRepository(names);
        Iterator iterator = nameRepository.getIterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}
G真的很美
关注
专栏目录
设计模式学习笔记
小何才露尖尖角
10-05 5004
又称静态工厂方法模式，它属于类创建模式。在简单工厂模式中，可以根据参数的不同返回不同类的实例。简单工厂模式专门定义一个类来负责创建其他类的实例，被创建的实例通常都有共同的父类（这个父类一般是抽象类）。简单举个例子：我们都直到工厂是根据产品的图纸生产产品的，那简单工厂模式中，工厂类就是负责专门创建其他类实例的类，它称之为工厂类，它直到每一个产品，它决定哪一个产品类应该被实例化。定义一个用于创建对象的接口，让子类决定实例化哪个类，工厂方法使一个类的实例化延迟到其子类。
Java/Android设计模式学习笔记
zj907638274的博客
04-25 1087
Java/Android设计模式学习笔记
设计模式学习笔记 - 设计模式与范式 -行为型：1.观察者模式（上）
chenjian723122704的专栏
03-31 1490
设计模式要干的事情就是解耦，创建型模式是将创建和使用代码解耦，结构性模式是将不同功能代码解耦，行为性模式是将不同行为解耦，具体到观察者模式，它将观察者和被观察者代码解耦。借助设计模式，我们利用更好的代码结构，将一大坨代码拆分成职责更单一的小类，让其满足开闭原则、高内聚低耦合等特性，依此来控制和应对代码的复杂性，提高代码的可扩展性。
李建忠「设计模式」笔记
weixin_46065476的博客
08-14 3485
李建忠C++设计模式学习笔记
黑马程序员java设计模式笔记
Vashon的博客
12-11 1825
分类 创建者模式 结构型模式 行为型模式 2 类图 UML 2.1 类图概述 显示了模型的静态结构 2.2 类图表示法 2.2.1 类的表示方式 Demo + age:int + method(args 1):int +:public -:private #:protected 属性完整表示 可见性 名称：类型 方法完整表示： 可见性 名称（参数列表）[:返回类型] 2.2.2 类与类之间关系的表示方式 2.2.2.1 关联关系 1.单向关联 一个顾客有一个地址 2.双向.
图解java设计模式_学习笔记_java开发
03-09
这份"图解java设计模式_学习笔记"是针对Java开发者深入理解和应用设计模式的重要资源。在这里，我们将深入探讨Java设计模式的核心概念、分类以及它们在实际开发中的应用。 设计模式分为三大类：创建型、结构型和...
设计模式之美—学习笔记
12-07
在这个“设计模式之美”的学习笔记中，我们将探讨一些主要的设计模式，以及它们在实际开发中的应用。 首先，我们从创建型模式开始。这类模式主要用于对象的创建，如单例模式（Singleton）、工厂模式（Factory ...
设计模式笔记（四）：行为型模式
2301_79407929的博客
10-27 80
一般一个请求发送者不止发送一个请求，增加一个CommandQueue类存储多个命令对象(ArrayList)，不同命令对象可对应不同的请求接收者，excute()方法中循环调用每一个Command对象的excute()方法。2）有些情况下，具体观察类的update()方法在执行时需要使用到具体目标类中的状态属性，因此在具体观察类中维护一个指向ConcreteSubject对象的引用（例如调用其attach()方法或detach()方法将自己添加到目标类集合或从其中删除）需要保存内部状态的类。
java设计模式学习笔记，以及各种模式的代码实现
03-07
这种设计模式属于结构型模式。 11. **组合模式**：允许你将对象组织成树形结构来表现“整体-部分”关系，同时可以像单个对象那样操作整个组合。 12. **享元模式**：运用共享技术有效地支持大量细粒度的对象，减少...
设计模式学习笔记（4）——行为型设计模式
小浩的博客
05-12 242
一：策略模式 1. 定义 定义算法族，将每一个算法封装到具有共同接口的独立的类中，让他们之间可以互相替换，让算法的变换独立于使用者。 2. 使用 场景：通过公共接口的一个引用，在具体的场景下可以使用不同的策略 策略：只需要定义公共方法，交给不同的实现类具体实现细节（算法） （1）场景 package StrategyPattern; /* 抽象场景 */ public class Scene...
GoF 23种设计模式学习笔记
02-28
"GoF 23种设计模式学习笔记" 是一个深入探讨这23个经典设计模式的资源，这些模式最初由Erich Gamma、Richard Helm、Ralph Johnson和John Vlissides四位作者在1994年的著作《设计模式：可复用面向对象软件的基础》中...
设计模式学习笔记：行为型模式
luojianbinfen的专栏
11-19 256
结构型设计模式是从程序的结构上解决模块之间的耦合问题（好像是句废话），GoF23种设计模式中结构型设计模式有7种，分别是：Adapter适配器模式、Bridge桥接模式、Composite组合模式、Decorator装饰模式、Facade外观模式、Flyweight享元模式和Proxy代理模式。下面分别总结一下这几种模式： 设计模式 GoF的描述 我的理解
c++设计模式demo
最新发布
jianfeng123123的博客
11-06 637
⾼层模块不应该依赖低层模块，⼆者都应该依赖抽象；抽象不应该依赖具体实现，具体实现应该依赖于抽象；⾃动驾驶系统公司是⾼层，汽⻋⽣产⼚商为低层，它们不应该互相依赖，⼀⽅变动另⼀⽅也会跟着变动；⽽应该 抽象 ⼀个⾃动驾驶⾏业标准，⾼层和低层都依赖它；这样以来就解耦了两⽅的变动；⾃动驾驶系统、汽⻋⽣产⼚商都是具体实现，它们应该都依赖⾃动驾驶⾏业标准（抽象）；⼀个类应该对扩展开放，对修改关闭；不将变量类型声明为某个特定的具体类，⽽是声明为某个接⼝。
JavaScript 23种经典设计模式简介
前端梦工厂
11-06 874
23种JavaScript经典设计模式。
Unity中RTS游戏的设计模式处理： 游戏中的对象选择和命令委托的基本框架
网易搬砖选手
11-06 128
单个集中类（例如，）跟踪当前选择的单元/对象，并处理用于选择游戏中对象的任何光线投射逻辑。可选对象附加了一个组件，其中公开了一个公共函数，该函数返回一个实现该接口的类。类实现特定于控制单个单元的自定义逻辑。这是通过一个公共函数完成的，每次玩家单击一个新对象时都会调用该函数。当玩家单击屏幕时，单个类会进行光线投射，以获取有关单击哪个对象的信息。该类还跟踪当前正在控制的单元，并将新单击的对象提供给该单元的控制逻辑。如果没有选择任何内容，我们将尝试选择接下来单击的对象。
设计模式小结一策略（strategy）模式
sunxingzhesunjinbiao的专栏
11-04 1192
定义一个策略接口，包含一个计算折扣价格的方法。// 折扣策略接口创建类，用于设置折扣策略，并计算折扣后的价格。// 设置折扣策略// 计算折扣价格throw new IllegalStateException("折扣策略未设置");
MVC（Model-View-Controller）模式概述
Joshua的专栏
11-03 610
以下是对 Smalltalk 的 MVC 架构模式的设计思想、采用的重要设计模式以及其后续发展的详细说明。Smalltalk 的 MVC 架构模式不仅是一种设计思想，也是一系列设计模式的集合，旨在实现软件开发中关注点的分离。这种设计模式有效地提高了程序的可维护性和可扩展性，并在后续的编程语言和开发框架中得到了广泛运用和发展。MVC 的演变和适应现代需求的能力，展示了其在软件设计领域的重要性和持久性。MVC 模式在 Smalltalk 的成功应用之后，广泛影响了后续的编程语言和开发框架。
C++设计模式结构型模式———桥接模式
无敌岩雀的博客
10-31 1388
桥接（Bridge）模式也叫桥梁模式，简称桥模式，是一种结构型模式。该模式所解决的问题非常简单，即根据单一职责原则，在一个类中，不要做太多事，如果事情很多，尽量拆分到多个类中去，然后在一个类中包含指向另外一个类对象的指针，当需要执行另外一个类中的动作时，用指针直接去调用另外一个类的成员函数。
GOF的C++软件设计模式的分类和模式名称
Joshua的专栏
11-03 963
根据他们解决问题的性质，设计模式可以分为三大类：创建型模式、结构型模式和行为型模式。设计模式的使用不仅可以提升代码的可读性和可维护性，还能提高代码的复用性和灵活性。理解这些模式及其应用场景将有助于设计出更高质量的软件系统。创建型模式主要关注如何创建对象，目的是通过使用不同的方式来创建对象，从而增强程序的灵活性和可复用性。结构型模式关注类或对象的组合，旨在通过组合现有类或对象来形成更大的结构。行为型模式主要关注对象之间的交互，提供了对象之间的责任分配和通信方式。
7.2 设计模式
QQ657205470的博客
11-05 552
“每一个模式描述了一个在我们周围不断重复发生的问题，以及该问题的解决方案的核心。这样，你就能一次又一次地使用该方案而不必做重复劳动”。设计模式的核心在于提供了相关问题的解决方案，使得人们可以更加简单方便地复用成功的设计和体系结构。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值