Java设计模式之初识行为型模式

一、行为型模式

  • 行为型模式关注点在于"如何运行对象/类";
  • 行为型模式用来描述程序在运行时复杂的流程控制;
  • 描述多个类或对象之间怎样互相协作共同完成单个对象都无法单独完成的任务,设计算法与对象间职责的分配;
  • 行为型模式分为类行为模式和对象行为模式,前者采用继承机制来在类间分派行为,后者采用组合或聚合在对象间分配行为。

二、模板方法模式

在模板模式中,一个抽象类公开定义了执行它的方法的方式模板。它的子类可以按需重写方法实现,但调用将以抽象类中定义的方式进行;

2.1 例子

以做饭举例

模板类

package com.vleus.design.behavioral.template;

/**
 * @author vleus
 * @date 2021年06月06日 15:49
 */
public abstract class CookieTemplate {

    /**
     * 定义算法:定义好的模板,关键性步骤留给子类实现
     */
    public void cook() {
        //定义算法步骤
        heating();
        addFood();
        addSalt();
        stirfry();
        end();
    }

    //加热方法
    public void heating() {
        System.out.println("准备开火。。。");
    }

    //添加食物
    public abstract void addFood();

    //加盐
    public abstract void addSalt();

    //翻炒
    public void stirfry() {
        System.out.println("翻炒中。。。");
    }

    //出锅
    public void end() {
        System.out.println("出锅。。。。");
    }

}

子类实现模板类

package com.vleus.design.behavioral.template;

/**
 * @author vleus
 * @date 2021年06月06日 15:53
 */
public class AutoCookMachine extends CookieTemplate{

    @Override
    public void addFood() {
        System.out.println("放了三根娃娃菜。。。");
    }

    @Override
    public void addSalt() {
        System.out.println("放了一勺盐。。。");
    }
}

测试类

package com.vleus.design.behavioral.template;

/**
 * @author vleus
 * @date 2021年06月06日 15:54
 */
public class MainTest {

    public static void main(String[] args) {

        AutoCookMachine autoCookMachine = new AutoCookMachine();

        autoCookMachine.cook();

    }
}

运行结果

2.2 模板方法使用场景

  • Spring的整个继承体系都基本用到模板方法:
  • BeanFactory:getBean-A-B-C-D;
  • JdbcTemplate、RedisTemplate都允许再扩展

三、策略模式

概念:策略(Strategy)模式定义了一系列算法,并将每个算法封装起来,使得它们可以相互替换,且算法的变化不会影响使用算法的客户。属于对象行为模式

  • 抽象策略类(Strategy);
  • 具体策略(Concrete Strategy);
  • 环境类:持有一个策略类的引用,最终给客户端调用;

3.1 例子

以RNG的打游戏的策略为例
环境类,持有策略引用

package com.vleus.design.behavioral.strategy;

/**
 * @author vleus
 * @date 2021年06月06日 16:04
 */
public class TeamRNG {

    //抽取游戏策略算法,并进行引用
    private GameStrategy gameStrategy;

    public void setGameStrategy(GameStrategy gameStrategy) {
        this.gameStrategy = gameStrategy;
    }

    public void startGame() {

        System.out.println("全军出击。。。");

        //使用游戏套路
        gameStrategy.warStrategy();

        System.out.println("Victory。。。。。");
    }
}

抽象策略类,定义相关策略方法

package com.vleus.design.behavioral.strategy;

public interface GameStrategy {

    //游戏策略方法
    void warStrategy();
}

抽象策略类的实现1

package com.vleus.design.behavioral.strategy;

/**
 * @author vleus
 * @date 2021年06月06日 16:07
 */
public class UziStrategy implements GameStrategy{
    @Override
    public void warStrategy() {
        System.out.println("uzi莽夫式打法获取胜利。。。。");
    }
}

抽象策略类的实现2

package com.vleus.design.behavioral.strategy;

/**
 * @author vleus
 * @date 2021年06月06日 16:07
 */
public class SteadyGameStrategy implements GameStrategy{

    @Override
    public void warStrategy() {
        System.out.println("稳健运营,蚕食对手获取胜利。。。");
    }
}

测试类

package com.vleus.design.behavioral.strategy;

/**
 * @author vleus
 * @date 2021年06月06日 16:08
 */
public class MainTest {

    public static void main(String[] args) {
        TeamRNG teamRNG = new TeamRNG();

        teamRNG.setGameStrategy(new UziStrategy());

        teamRNG.startGame();

        System.out.println("----------------------");

        teamRNG.setGameStrategy(new SteadyGameStrategy());
        teamRNG.startGame();
    }
}

3.2 使用场景

  • Spring的InstantiationStrategy;
  • 线程池拒绝策略;

四、状态模式

概念:状态模式,对有状态的对象,把负责的"判断逻辑"提取到不同的状态对象中,允许状态对象在其内部状态发生改变的时候改变其行为;

  • 环境类角色;
  • 抽象状态角色;
  • 具体状态角色

抽象状态类

package com.vleus.design.behavioral.state;

public interface TeamState {

    //玩游戏的状态
    void playGame();

    //切换到下一个状态
    TeamState next();
}

状态实现类1

package com.vleus.design.behavioral.state;

/**
 * @author vleus
 * @date 2021年06月06日 16:19
 */
public class VocationState implements TeamState{

    @Override
    public void playGame() {
        System.out.println("在三亚度假,真舒服,不想打游戏。。。");
    }

    //切换到下一个状态
    @Override
    public TeamState next() {
        return new EatBeefNoodlesState();
    }
}

状态实现类2

package com.vleus.design.behavioral.state;

/**
 * @author vleus
 * @date 2021年06月06日 16:20
 */
public class EatBeefNoodlesState implements TeamState{

    @Override
    public void playGame() {
        System.out.println("恰牛肉面恰饱饱。。。。");
    }

    @Override
    public TeamState next() {
        return new MatchState();
    }
}

状态实现类3

package com.vleus.design.behavioral.state;

/**
 * @author vleus
 * @date 2021年06月06日 16:18
 */
public class MatchState implements TeamState{

    @Override
    public void playGame() {
        System.out.println("全力以赴打比赛...");
    }

    @Override
    public TeamState next() {
        return new VocationState();
    }
}

环境类调用

package com.vleus.design.behavioral.state;

/**
 * @author vleus
 * @date 2021年06月06日 16:17
 * @desc 环境类
 */
public class SktTeam {

    private TeamState teamState;

    public void setTeamState(TeamState teamState) {
        this.teamState = teamState;
    }

    void startGame() {
        //状态不同可能会导致不同的游戏结果
        teamState.playGame();
    }

    //下一个状态
    void nextState() {
        teamState = teamState.next();
    }
}

测试类

package com.vleus.design.behavioral.state;

/**
 * @author vleus
 * @date 2021年06月06日 16:20
 */
public class MainTest {

    public static void main(String[] args) {

        SktTeam sktTeam = new SktTeam();
        VocationState state = new VocationState();
        sktTeam.setTeamState(state);

        sktTeam.startGame();
        sktTeam.nextState();
        sktTeam.startGame();
        sktTeam.nextState();
        sktTeam.startGame();
    }
}

五、中介者模式

网状变星状

概念:用一个中介对象来封装一系列的对象交互,中介者使得各个对象之间不需要显式地互相调用,减少对象间混乱的依赖关系,从而使其耦合松散,而且可以独立地改变他们之间的交互。属于对象行为模式。

六、观察者模式

概念:定义对象间的一种一对多依赖关系,使得当一个对象状态发生改变时,其相关依赖对象皆得到通知并被自动更新。观察者模式又被成为发布-订阅模式。
核心:被观察对象维护观察对象的引用集合,发生变化的时候通知每一个观察对象即可,就拿tiktok的关注主播为例

抽象主播类:

package com.vleus.design.behavioral.observer;

/**
 * @author vleus
 * @date 2021年06月06日 17:50
 */
public abstract class AbstractTikToker {

    //添加粉丝
    abstract void addFans(AbstractFans abstractFans);

    //通知粉丝
    abstract void notifyFans(String msg);
}

美女主播实现类

package com.vleus.design.behavioral.observer;

import com.vleus.design.structural.flyweight.AbstractWaitressFlyweight;

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

/**
 * @author vleus
 * @date 2021年06月06日 17:52
 */
public class MMTikToker extends AbstractTikToker {

    List<AbstractFans> fansList = new ArrayList<>();

    void startSell() {
        System.out.println("主播开始卖货了。。。");
        notifyFans("我开始卖货了,卖茅台。。。");
    }

    void enbSell() {

        System.out.println("主播货卖完了。。。");
        notifyFans("茅台已经卖完了");
    }

    @Override
    void addFans(AbstractFans abstractFans) {
        fansList.add(abstractFans);
    }

    /**
     * 通知粉丝
     */
    @Override
    void notifyFans(String msg) {
        //遍历粉丝
        for (AbstractFans abstractFans : fansList) {
            abstractFans.acceptMsg(msg);
        }
    }
}

抽象粉丝类

package com.vleus.design.behavioral.observer;

/**
 * @author vleus
 * @date 2021年06月06日 17:52
 */
public abstract class AbstractFans {

    abstract void acceptMsg(String msg);

    void follow(AbstractTikToker tikToker) {
        //主播增加粉丝
        tikToker.addFans(this);
    }
}

粉丝实现类

package com.vleus.design.behavioral.observer;

/**
 * @author vleus
 * @date 2021年06月06日 17:57
 */
public class HumanFans extends AbstractFans{

    @Override
    void acceptMsg(String msg) {
        System.out.println("粉丝说主播说:" +msg);
    }
}

测试类

package com.vleus.design.behavioral.observer;

/**
 * @author vleus
 * @date 2021年06月06日 17:56
 */
public class MainTest {

    public static void main(String[] args) {

        MMTikToker mmTikToker = new MMTikToker();

        mmTikToker.startSell();

        HumanFans humanFans1 = new HumanFans();
        HumanFans humanFans2 = new HumanFans();
        HumanFans humanFans3 = new HumanFans();

        humanFans1.follow(mmTikToker);
        humanFans2.follow(mmTikToker);
        humanFans3.follow(mmTikToker);

        System.out.println("---------------------------");

        mmTikToker.enbSell();
    }
}

6.1 使用场景

  • Spring事件通知机制;
  • 响应式编程;
  • Vue的双向绑定核心

到此这篇关于Java设计模式之初识行为型模式的文章就介绍到这了,更多相关Java行为型模式内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • Java设计模式之命令模式详解

    命令模式 定义:将请求封装成对象,这可以让你使用不同的请求.队列.或者日志来参数化其他对象. 何时使用命令模式?当需要将发出请求的对象和执行请求的对象解耦的时候,使用命令模式. 在被解耦的两者之间是通过命令对象进行沟通的.命令对象封装了接收者和一个或一组动作. 调用者通过调用命令对象的execute()方法发出请求,这会使接收者的动作被调用. 调用者可以接收命令当作参数,甚至在运行时动态地进行. 优点: 1.降低了系统耦合度. 2.新的命令可以很容易添加到系统中去. 缺点:使用命令模式可能会导致

  • JAVA初探设计模式的六大原则

    前言 我想用贴近生活的语句描述一下自己对六种原则的理解.也就是不做专业性的阐述,而是描述一种自己学习后的理解和感受,因为能力一般而且水平有限,也许举的例子不尽妥当,还请谅解原本我是想用JavaScript编写的,但是JavaScript到现在还没有提出接口的概念,而用TypeScript写又感觉普及度还不算特别高,所以还是决定用Java语言编写 首先要提的是:六大原则的灵魂是面向接口,以及如何合理地运用接口 P1.单一职责原则(Single Responsibility Principle) 应

  • Java通俗易懂系列设计模式之建造者模式

    介绍 今天我们将研究java中的Builder模式.Builder 设计模式是一种创造性的设计模式,如工厂模式和抽象工厂模式. 当Object包含许多属性时,引入了Builder模式来解决Factory和Abstract Factory设计模式的一些问题. 当Object包含许多属性时,Factory和Abstract Factory设计模式存在三个主要问题. 从客户端程序传递到Factory类的参数太多,可能容易出错,因为大多数情况下,参数的类型是相同的,而从客户端来说,很难维护参数的顺序.

  • Java设计模式之单例模式简介

    一.饿汉式(静态常量) public class Face { private static final Face instance = new Face(); static Face getInstance() { return instance; } private Face() { } } 优点:这种写法比较简单,就是在类装载的时候就完成实例化.避免了线程同步问题. 缺点:在类装载的时候就完成实例化,没有懒加载的效果.如果从始至终从未使用过这个实例,则会造成内存的浪费. 二.饿汉式(静态代

  • java设计模式之浅谈适配器模式

    一.结构型模式 结构型模式有什么好处? 从程序的结构上实现松耦合,从而可以扩大整体的类结构,用来解决更大的问题 二.适配器模式 USB网线转换器 三.什么是适配器模式? 将一个类的接口转换成客户希望的另外一个接口.Adapter模式使得原本接口不兼容而不能一起工作的那些类能够变得在一起工作! 四.角色分析 目标接口:客户所期待的接口,目标可以是具体的或抽象的类,也可以是接口 需要适配的类:需要适配的类或适配者类 适配器:通过包装一个需要适配的对象,把原接口转换成目标对象! 例子: 适配的类:网线

  • 浅谈Java设计模式之七大设计原则

    前言 学习设计模式的方法:掌握理解七大原则以及其目的,学习相应的设计模式(带着设计目的,应用场景(解决什么样的问题),如何实现(编码实现一个小例子),优缺点是什么?等等) 一.单一职责原则(SingleResponsibilityPrinciple,SRP) 定义:一个类只负责一个功能领域中的相应职责 理解:该设计模式很好理解,就是一个类只实现某个领域的相应职责,这样有利于进行调用.就比如在Java开发时,设计controller.service.manager.dao层一样的道理,进行分层分工

  • Java设计模式之代理模式详解

    一.代理模式 代理模式就是有一个张三,别人都没有办法找到他,只有他的秘书可以找到他.那其他人想和张三交互,只能通过他的秘书来进行转达交互.这个秘书就是代理者,他代理张三. 再看看另一个例子:卖房子 卖房子的步骤: 1.找买家 2.谈价钱 3.签合同 4.和房产局签订一些乱七八糟转让协议 一般卖家只在签合同的时候可能出面一下,其他的1,2,4都由中介去做.那你问这样有什么用呢? 首先,一个中介可以代理多个卖房子的卖家,其次,我们可以在不修改卖家的代码的情况下,给他实现房子加价.打广告等等夹带私货的

  • Java设计模式之初识行为型模式

    一.行为型模式 行为型模式关注点在于"如何运行对象/类": 行为型模式用来描述程序在运行时复杂的流程控制: 描述多个类或对象之间怎样互相协作共同完成单个对象都无法单独完成的任务,设计算法与对象间职责的分配: 行为型模式分为类行为模式和对象行为模式,前者采用继承机制来在类间分派行为,后者采用组合或聚合在对象间分配行为. 二.模板方法模式 在模板模式中,一个抽象类公开定义了执行它的方法的方式模板.它的子类可以按需重写方法实现,但调用将以抽象类中定义的方式进行: 2.1 例子 以做饭举例 模

  • Java设计模式之观察者模式(Observer模式)

    一.观察者模式是什么? 当对象间存在一对多关系时,则使用观察者模式(Observer Pattern).当一个对象被修改时,则会自动通知依赖它的对象.观察者模式属于行为型模式. 人话: 就像微信公众号推送消息,订阅的人能收到,没订阅的收不到,还可以取消/添加订阅 二.模式分析 2.1 四个角色 抽象主题(抽象被观察者角色):也就是一个抽象主题,它把所有对观察者对象的引用保存在一个集合中,每个主题都可以有任意数量的观察者.抽象主题提供一个接口,可以增加和删除观察者角色.一般用一个抽象类和接口来实现

  • Java设计模式之浅谈模板方法模式

    一. 什么是模板方法设计模式 从字面意义上理解, 模板方法就是定义出来一套方法, 作为模板, 也就是基础. 在这个基础上, 我们可以进行加工,实现个性化的实现.比如:一日餐三. 早餐, 中餐, 晚餐. 每个人都要吃三餐, 但每个人的三餐吃的可能都不一样. 一日三餐定义了模板--早中晚, 每个人的三餐就是模板的具体实现. 1.1 模板方法的用途 将不变的行为从子类搬到超类,去除了子类中的重复代码.规范子类的结构 1.2 模板方法的定义 定义一个操作中的算法骨架,而将算法的一些步骤延迟到子类中,使得

  • Java设计模式详解之门面模式(外观模式)

    门面模式(Facade Pattern)也叫外观模式,它隐藏系统的复杂性,并向客户端提供一个可以访问系统的接口.这种类型的设计模式属于结构型模式,它向现有的系统添加一个接口,来隐藏系统的复杂性,为子系统中的一组接口提供了一个统一的高层访问接口,这个接口使得子系统更容易被访问或使用.这种模式涉及到一个单一的类,该类提供了客户端请求的简化方法和对现有系统类方法的委托调用. 简而言之,就是把一堆复杂的流程封装成一个接口供给用户更简单的使用,这个设计模式里有三个角色: 1)门面角色( facade ):

  • Java设计模式中的装饰者模式

    目录 模式介绍 UML类图 装饰者模式案例 装饰者模式优点 装饰者模式缺点 模式介绍 23种设计模式之一,英文叫Decorator Pattern,又叫装饰者模式.装饰模式是在不必改变原类文件和使用继承的情况下,动态地扩展一个对象的功能.它是通过创建一个包装对象,也就是装饰来包裹真实的对象. UML类图 类图解析: Componet:主体 ConcreateComponent:主体具体实现类 Decorator:装饰者 ConcreteDecorate:装饰者具体实现类 装饰者模式案例 背景介绍

  • 对比Java设计模式编程中的状态模式和策略模式

    为了能在Java应用程序中正确的使用状态模式和策略模式,开发人员需要清楚地知道这两种模式之间的区别.尽管状态模式和策略模式的结构非常相似,它们又同样遵循开闭原则,都代表着SOLID设计原则的'O',但它们的意图是完全不同的.Java中的策略模式是对一组相关的算法进行封装,给调用方提供了运行时的灵活性.调用方可以在运行时选择不同的算法,而不用修改使用策略的那个Context类.使用策略模式的经典例子包括实现加密算法,压缩算法,以及排序算法.另一方面,状态模式使用一个对象可以在不同的状态下表现出不同

  • java设计模式学习之简单工厂模式

    简单工厂模式 简单工厂模式是属于创建型模式,又叫做静态工厂方法(Static Factory Method)模式,但不属于23种GOF设计模式之一.简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例.简单工厂模式是工厂模式家族中最简单实用的模式,可以理解为是不同工厂模式的一个特殊实现. 利用简单工厂模式设计一个计算器. 1:创建一个运算的类 package EasyFactoryModel; abstract class Operation { public double num1=0;

  • 讲解Java设计模式编程中的建造者模式与原型模式

    建造者模式 定义 又叫生成器模式,它可以将复杂对象的建造过程抽象出来(抽象类别),使这个抽象过程的不同实现方法可以构造出不同表现(属性)的对象. 当创建复杂对象的算法应该独立于该对象的组成部分时,而且构造过程必须允许被构造的对象有不同的表示时.我们可以考虑使用建造者模式. 实现 1. Builder为创建一个Product对象的各个部件指定抽象接口.通常包含创建产品和返回产品的抽象方法,也可以是具体方法,把创建过程放到ConcreteBuilder类中. 2. ConcreteBuilder 实

  • Java设计模式之浅谈外观模式

    目录 简介 外观模式之理解 实例 ①.定义子系统 ②.外观类 ③.测试 好文推荐 简介 外观模式(Facade Pattern)隐藏系统的复杂性,并向客户端提供了一个客户端可以访问系统的接口.这种类型的设计模式属于结构型模式,它向现有的系统添加一个接口,来隐藏系统的复杂性. 这种模式涉及到一个单一的类,该类提供了客户端请求的简化方法和对现有系统类方法的委托调用. 外观模式之理解 对于外观模式,我们可以理解为他是将一些复杂的接口或类进行隐藏,自己暴露出更为简单的操作方法,使得以我们不需要去对复杂方

  • Java设计模式之观察者模式(Observer模式)介绍

    Java深入到一定程度,就不可避免的碰到设计模式(design pattern)这一概念,了解设计模式,将使自己对java中的接口或抽象类应用有更深的理解.设计模式在java的中型系统中应用广泛,遵循一定的编程模式,才能使自己的代码便于理解,易于交流,Observer(观察者)模式是比较常用的一个模式,尤其在界面设计中应用广泛,而本教程所关注的是Java在电子商务系统中应用,因此想从电子商务实例中分析Observer的应用. 虽然网上商店形式多样,每个站点有自己的特色,但也有其一般的共性,单就"

随机推荐