java中的设计模式 - 11个行为型模式（完整代码实现）

最新推荐文章于 2024-06-05 16:10:48 发布

zzqtty

最新推荐文章于 2024-06-05 16:10:48 发布

阅读量578

点赞数

分类专栏：设计模式文章标签：设计模式

本文链接：https://blog.csdn.net/zzqtty/article/details/114858258

版权

设计模式专栏收录该内容

11 篇文章 0 订阅

订阅专栏

职责链模式-Chain of Responsibility Pattern

解释器模式-Interpreter Pattern

迭代器模式-Iterator Pattern

产品遍历代码实现：

中介者模式-Mediator Pattern

客户窗口代码实现：

备忘录模式-Memento Pattern

象棋撤销代码实现：

观察者模式-Observer Pattern

多人战队代码实现：

状态模式-State Pattern

银行账号代码实现：

策略模式-Strategy Pattern

电影票打折代码实现：

模板方法模式-Template Method Pattern

访问者模式-Visitor Pattern

员工代码实现

职责链模式-Chain of Responsibility Pattern

职责链模式 (Chain of Responsibility Pattern) ：避免请求发送者与接收者耦合在一起，让多

个对象都有可能接收请求，将这些对象连接成一条链，并且沿着这条链传递请求，直到有对象处理它

为止。职责链模式是一种对象行为型模式。

采购单代码实现：

package com.yinjun.chainofresponsibilitypattern;

//审批者类：抽象处理者
abstract class Approver {

    //定义后继对象
    protected Approver successor;

    //审批者姓名
    protected String name;

    public Approver(String name) {
        this.name = name;
    }

    //设置后继者
    public void setSuccessor(Approver successor) {
        this.successor = successor;
    }

    //抽象请求处理方法
    public abstract void  processRequest(PurchaseRequest purchaseRequest);
}



package com.yinjun.chainofresponsibilitypattern;

public class Client {

    public static void main(String args[]){
        PurchaseRequest request = new PurchaseRequest(20000,121,"study");

        Approver director,vicePresident;

        director = new Director("wang director");

        vicePresident = new VicePresident("li vicePresident");

        director.setSuccessor(vicePresident);

        director.processRequest(request);
    }
}




package com.yinjun.chainofresponsibilitypattern;

//主任类：具体处理者
public class Director extends Approver {

    public Director(String name) {
        super(name);
    }

    //具体请求处理方法
    @Override
    public void processRequest(PurchaseRequest request) {

        if(request.getAmount() < 50000){
            System.out.println("主任" + this.name + "审批采购单：" + request.getNumber() + "，额：" + request.getAmount() + "元，采购目的：" + request.getPurpose() + "。");
        }else {
            //转发请求
            this.successor.processRequest(request);
        }

    }
}



package com.yinjun.chainofresponsibilitypattern;

//采购单：请求类
public class PurchaseRequest {

    //采购金额
    private double amount;
    //采购单编号
    private int number;
    //采购目的
    private String purpose;

    public PurchaseRequest(double amount, int number, String purpose) {
        this.amount = amount;
        this.number = number;
        this.purpose = purpose;
    }

    public double getAmount() {
        return amount;
    }

    public void setAmount(double amount) {
        this.amount = amount;
    }

    public int getNumber() {
        return number;
    }

    public void setNumber(int number) {
        this.number = number;
    }

    public String getPurpose() {
        return purpose;
    }

    public void setPurpose(String purpose) {
        this.purpose = purpose;
    }
}





package com.yinjun.chainofresponsibilitypattern;
//副董事长类：具体处理者
public class VicePresident extends Approver {

    public VicePresident(String name) {
        super(name);
    }

    //具体请求处理方法
    @Override
    public void processRequest(PurchaseRequest request) {
        if(request.getAmount() < 100000){
            System.out.println("副董事长" + this.name + "审批采购单：" + request.getNumber() + "，额：" + request.getAmount() + "元，采购目的：" + request.getPurpose() + "。");
        }else {
            //转发请求
            this.successor.processRequest(request);
        }
    }
}

命令模式-Command Pattern

在软件开发中，我们经常需要向某些对象发送请求（调用其中的某个或某些方法），但是并不知道请

求的接收者是谁，也不知道被请求的操作是哪个，此时，我们特别希望能够以一种松耦合的方式来设

计软件，使得请求发送者与请求接收者能够消除彼此之间的耦合，让对象之间的调用关系更加灵活，

可以灵活地指定请求接收者以及被请求的操作。命令模式为此类问题提供了一个较为完美的解决方

案。

命令模式 (Command Pattern) ：将一个请求封装为一个对象，从而让我们可用不同的请求对客户进

行参数化；对请求排队或者记录请求日志，以及支持可撤销的操作。命令模式是一种对象行为型模

式，其别名为动作 (Action) 模式或事务 (Transaction) 模式。

自定义功能键代码实现：

package com.yinjun.commandpattern;

public class Client {

    public static void main(String args[]){
        FBSettingWindow fbSettingWindow = new FBSettingWindow("windows window");

        FunctionButton functionButton1 = new FunctionButton("minminze window");

        FunctionButton functionButton2 = new FunctionButton("help window");

        Commond commond1 = new MinimizeCommand(new WindowHandlder());
        //WindowHandlder windowHandlder = new WindowHandlder();
        //commond1.execute();

        Commond commond2 = new HelpCommond(new HelpHandler());
        functionButton1.setCommond(commond1);

        functionButton2.setCommond(commond2);


        fbSettingWindow.addFunctionButton(functionButton1);

        fbSettingWindow.addFunctionButton(functionButton2);

        fbSettingWindow.display();

        //commond1.execute();

        functionButton1.click();


    }
}



package com.yinjun.commandpattern;
//抽象命令类
abstract class Commond {

    public abstract  void execute();
}



package com.yinjun.commandpattern;

import java.util.ArrayList;
import java.util.List;
//功能键设置窗口类
public class FBSettingWindow {
    //窗口标题
    private String title;

    //定义一个ArrayList来存储所有功能键
    private List<FunctionButton> functionButtons = new ArrayList<>();

    public FBSettingWindow(String title) {
        this.title = title;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public void addFunctionButton(FunctionButton button){
        functionButtons.add(button);
    }

    //显示窗口及功能键
    public void display(){
        functionButtons.forEach(f->{
            System.out.println(f.getName());
        });
    }
}




package com.yinjun.commandpattern;

//功能键类：请求发送者
public class FunctionButton {

    //维持一个抽象命令对象的引用
    private Commond commond;
    //功能键名称
    private String name;

    public FunctionButton(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
    //为功能键注入命令
    public void setCommond(Commond commond) {
        this.commond = commond;
    }
    //发送请求的方法
    public void click(){
        System.out.print("点击功能键：");
        commond.execute();
    }
}





package com.yinjun.commandpattern;
//帮助命令类：具体命令类
public class HelpCommond extends Commond {
    //维持对请求接收者的引用
    private HelpHandler helpHandler;

    public HelpCommond(HelpHandler helpHandler) {
        this.helpHandler = helpHandler;
    }

    //命令执行方法，将调用请求接收者的业务方法
    @Override
    public void execute() {
        this.helpHandler.display();
    }

}





package com.yinjun.commandpattern;

public class HelpHandler {

    public void display(){
        System.out.println("display help .....");
    }
}





package com.yinjun.commandpattern;

public class MinimizeCommand extends Commond{


    private WindowHandlder windowHandlder;

    public MinimizeCommand(WindowHandlder windowHandlder) {
        this.windowHandlder = windowHandlder;
    }

    @Override
    public void execute() {
        windowHandlder.minimize();
    }
}






package com.yinjun.commandpattern;

public class WindowHandlder {
    public void minimize(){
        System.out.println("minimize windown.....");
    }
}

网站操作流程代码实现：

解释器模式-Interpreter Pattern

解释器模式是一种使用频率相对较低但学习难度较大的设计模式，它用于描述如何使用面向对象语言

构成一个简单的语言解释器。在某些情况下，为了更好地描述某一些特定类型的问题，我们可以创建

一种新的语言，这种语言拥有自己的表达式和结构，即文法规则，这些问题的实例将对应为该语言中

的句子。此时，可以使用解释器模式来设计这种新的语言。对解释器模式的学习能够加深我们对面向

对象思想的理解，并且掌握编程语言中文法规则的解释过程。

解释器模式定义如下：

解释器模式 (Interpreter Pattern) ：定义一个语言的文法，并且建立一个解释器来解释该语言中

的句子，这里的 “ 语言 ” 是指使用规定格式和语法的代码。解释器模式是一种类行为型模式。

迭代器模式-Iterator Pattern

在软件开发中，我们经常需要使用聚合对象来存储一系列数据。聚合对象拥有两个职责：一是存储数

据；二是遍历数据。从依赖性来看，前者是聚合对象的基本职责；而后者既是可变化的，又是可分离

的。因此，可以将遍历数据的行为从聚合对象中分离出来，封装在一个被称之为 “ 迭代器 ” 的对象中，

由迭代器来提供遍历聚合对象内部数据的行为，这将简化聚合对象的设计，更符合 “ 单一职责原则 ” 的

要求。

迭代器模式 (Iterator Pattern) ：提供一种方法来访问聚合对象，而不用暴露这个对象的内部表

示，其别名为游标 (Cursor) 。迭代器模式是一种对象行为型模式。

产品遍历代码实现：

package com.yinjun.iteratorPattern;

//抽象迭代器
abstract class Abstractiterator {
    public abstract void next();
    public abstract boolean isLast();

    public abstract void previous();

    public abstract boolean isFirst();

    public abstract Object getNextItem();

    public abstract Object getPreviousItem();
}



package com.yinjun.iteratorPattern;

import java.util.ArrayList;
import java.util.List;
//抽象聚合类
abstract class AbstractObjectList {
    protected List<Object> objects = new ArrayList<>();

    public AbstractObjectList(List<Object> objects) {
        this.objects = objects;
    }

    public void addObject(Object o){
        this.objects.add(o);
    }

    public void removeObject(Object o){
        objects.remove(o);
    }

    public List<Object> getObjects() {
        return objects;
    }

    //声明创建迭代器对象的抽象工厂方法
    public abstract Abstractiterator createIterator();

}



package com.yinjun.iteratorPattern;

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

public class Client {

    public static void  main (String args[]){

        List<String> productCollcet = new ArrayList<>();
        productCollcet.add("product A ");

        productCollcet.add("product B ");
        productCollcet.add("product C ");
        productCollcet.add("product D ");

        //创建聚合对象
        AbstractObjectList productList = new ProductList(productCollcet);

        //创建迭代器对象
        Abstractiterator iterator = productList.createIterator();
        //ProductIterator productIterator = new ProductIterator(productList);

        //System.out.println(productIterator.);

        System.out.println("正向遍历：");
        while (!iterator.isLast()){
            System.out.print(iterator.getNextItem() + "，");
            iterator.next();
        }

        System.out.println();
        System.out.println("逆向遍历：");

        while (!iterator.isFirst()){
            System.out.print(iterator.getPreviousItem() + "，");
            iterator.previous();
        }
    }
}




package com.yinjun.iteratorPattern;

import java.util.List;

//商品迭代器：具体迭代器
public class ProductIterator extends Abstractiterator {

    private ProductList productList;

    private List products;

    //定义一个游标，用于记录正向遍历的位置
    private int cursor1;

    //定义一个游标，用于记录逆向遍历的位置
    private int cursor2;

    public ProductIterator(ProductList productList) {
        this.productList = productList;
        //获取集合对象
        this.products = productList.getObjects();
        cursor1 = 0; //设置正向遍历游标的初始值
        cursor2 = products.size() -1; //设置逆向遍历游标的初始值
    }


    @Override
    public void next() {

        if(cursor1 < products.size()){

            cursor1++;
        }
    }


    @Override
    public boolean isLast() {
        return (cursor1 == products.size());
    }

    @Override
    public void previous() {

        if(cursor2 > -1){

            cursor2 -- ;
        }
    }

    @Override
    public boolean isFirst() {
        return (cursor2 == -1);
    }

    @Override
    public Object getNextItem() {
        return products.get(cursor1);
    }

    @Override
    public Object getPreviousItem() {
        return products.get(cursor2);
    }
}



package com.yinjun.iteratorPattern;

import java.util.List;
//商品数据类：具体聚合类
public class ProductList extends AbstractObjectList {

    public ProductList(List objects) {
        super(objects);
    }

    //实现创建迭代器对象的具体工厂方法
    @Override
    public Abstractiterator createIterator() {
        return new ProductIterator(this);
    }
}

中介者模式-Mediator Pattern

如果在一个系统中对象之间存在多对多的相互关系，我们可以将对象之间的一些交互行为从各个对象

中分离出来，并集中封装在一个中介者对象中，并由该中介者进行统一协调，这样对象之间多对多的

复杂关系就转化为相对简单的一对多关系。通过引入中介者来简化对象之间的复杂交互，中介者模式

是 “ 迪米特法则 ” 的一个典型应用。

中介者模式 (Mediator Pattern) ：用一个中介对象（中介者）来封装一系列的对象交互，中介者使各对象不需要显式地相互引用，

从而使其耦合松散，而且可以独立地改变它们之间的交互。中介者模式又称为调停者模式，它是一种对象行为型模式。

客户窗口代码实现：

package com.yinjun.mediatorpattern;

//按钮类：具体同事类
public class Button extends Component {


    @Override
    public void update() {
//按钮不产生交互
    }
}



package com.yinjun.mediatorpattern;

public class Client {

    public static void main(String args[]){
//定义中介者对象
        ConcrereMediator mediator = new ConcrereMediator();

        //定义同事对象
        Button button = new Button();
        List list = new List();
        TextBox textBox = new TextBox();

        button.setMediator(mediator);
        list.setMediator(mediator);
        textBox.setMediator(mediator);

        mediator.addButton = button;
        mediator.list = list;
        mediator.userNameTextBox = textBox;

        button.change();
        System.out.println("-----------------------------");
        list.change();

    }
}



package com.yinjun.mediatorpattern;
//抽象组件类：抽象同事类
abstract class Component {
    protected Mediator mediator;

    public void setMediator(Mediator mediator) {
        this.mediator = mediator;
    }
    //转发调用
     public void change(){
      mediator.componentChanged(this);
     }



    public abstract  void update();
}




package com.yinjun.mediatorpattern;
//具体中介者
public class ConcrereMediator extends Mediator {

    //维持对各个同事对象的引用
    public Button addButton;
    public List list;

    public TextBox userNameTextBox;

    @Override
    public void componentChanged(Component component) {

        //单击按钮
        if(component == addButton){

            System.out.println("--单击增加按钮--");
            list.update();
            userNameTextBox.update();
        }
        //从列表框选择客户
        else if(component == list){
            System.out.println("--从列表框选择客户--");
            userNameTextBox.setText();
        }
    }
}




package com.yinjun.mediatorpattern;

//列表框类：具体同事类
public class List extends Component {

    @Override
    public void update() {

        System.out.println("列表框增加一项：张无忌。");

    }

    public void select(){
        System.out.println("列表框选中项：小龙女。");
    }
}




package com.yinjun.mediatorpattern;
//抽象中介者
abstract class Mediator {

    public abstract  void componentChanged(Component component);
}




package com.yinjun.mediatorpattern;

//文本框类：具体同事类
public class TextBox extends Component {


    @Override
    public void update() {
        System.out.println("客户信息增加成功后文本框清空。");
    }

    public void setText(){
        System.out.println("文本框显示：小龙女。");
    }
}

备忘录模式-Memento Pattern

备忘录模式提供了一种状态恢复的实现机制，使得用户可以方便地回到一个特定的历史步骤，当新的

状态无效或者存在问题时，可以使用暂时存储起来的备忘录将状态复原，当前很多软件都提供了撤销

(Undo) 操作，其中就使用了备忘录模式。

备忘录模式 (Memento Pattern) ：在不破坏封装的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，这样可以在

以后将对象恢复到原先保存的状态。它是一种对象行为型模式，其别名为 Token 。

象棋撤销代码实现：

package com.yinjun.mementopattern;

//象棋棋子类：原发器
public class Chessman {
    private String name;
    private  int x;

    private int y;

    public Chessman(String name, int x, int y) {
        this.name = name;
        this.x = x;
        this.y = y;
    }

    public String getName() {
        return name;
    }

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

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }

    //保存状态
    public ChessmanMemento save(){
        return new ChessmanMemento(name,x,y);
    }

    //恢复状态
    public void restore(ChessmanMemento chessmanMemento){

        this.name = chessmanMemento.getLabel();
        this.x = chessmanMemento.getX();
        this.y = chessmanMemento.getY();
    }
}



package com.yinjun.mementopattern;

//象棋棋子备忘录类：备忘录
public class ChessmanMemento {

    private  String label;
    private int x;
    private int y;

    public ChessmanMemento(String label, int x, int y) {
        this.label = label;
        this.x = x;
        this.y = y;
    }


    public String getLabel() {
        return label;
    }

    public void setLabel(String label) {
        this.label = label;
    }

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }
}




package com.yinjun.mementopattern;

public class Client {


    public static void main(String args[]){

        MementoCareTaker mc = new MementoCareTaker();

        Chessman chessman = new Chessman("车",2,5);

        chessman.setY(4);
        display(chessman);
        mc.setChessmanMemento(chessman.save());
        chessman.setX(5);
        display(chessman);
        System.out.println("******悔棋******");
        //恢复状态
        chessman.restore(mc.getChessmanMemento());
        display(chessman);

    }


    public static  void display(Chessman chess){
        System.out.println("棋子" + chess.getName() + "当前位置为：" + "第" + chess.getX() + "行"
                + "第" + chess.getY() + "列。");
    }

}



package com.yinjun.mementopattern;

public class MementoCareTaker {

    public ChessmanMemento chessmanMemento;

    public ChessmanMemento getChessmanMemento() {
        return chessmanMemento;
    }

    public void setChessmanMemento(ChessmanMemento chessmanMemento) {
        this.chessmanMemento = chessmanMemento;
    }
}

思考多次撤销代码实现

观察者模式-Observer Pattern

观察者模式是使用频率最高的设计模式之一，它用于建立一种对象与对象之间的依赖关系，一个对象

发生改变时将自动通知其他对象，其他对象将相应作出反应。在观察者模式中，发生改变的对象称为

观察目标，而被通知的对象称为观察者，一个观察目标可以对应多个观察者，而且这些观察者之间可

以没有任何相互联系，可以根据需要增加和删除观察者，使得系统更易于扩展。

观察者模式 (Observer Pattern) ：定义对象之间的一种一对多依赖关系，使得每当一个对象状态

发生改变时，其相关依赖对象皆得到通知并被自动更新。观察者模式的别名包括发布 - 订阅

（ Publish/Subscribe ）模式、模型 - 视图（ Model/View ）模式、源 - 监听器

（ Source/Listener ）模式或从属者（ Dependents ）模式。观察者模式是一种对象行为型模式。

多人战队代码实现：

package com.yinjun.observerpattern;

import java.util.ArrayList;
//战队控制中心类：目标类
abstract class AllControlCenter {
    //战队名称
    protected String allyName;
    //定义一个集合用于存储战队成员
    protected ArrayList<Observer> players = new ArrayList<>();

    public String getAllyName() {
        return allyName;
    }

    public void setAllyName(String allyName) {
        this.allyName = allyName;
    }
    //注册方法
    public  void join(Observer obs){
        System.out.println(obs.getName() + "加入" + this.allyName + "战队！");
        players.add(obs);
    }

    //注销方法
    public  void quit(Observer obs){
        System.out.println(obs.getName() + "退出" + this.allyName + "战队！");
        players.remove(obs);
    }

    public abstract void notifyObserver(String name);
}





package com.yinjun.observerpattern;

public class Client {

    public static void main(String args[]){

        AllControlCenter team = new ConcreteAllyControlCenter("win team");

        Observer play1 = new Player("p1");

        Observer play2 = new Player("p2");

        Observer play3 = new Player("p3");

        team.join(play1);
        team.join(play2);
        team.join(play3);

        play1.beAttacked(team);
    }
}






package com.yinjun.observerpattern;

public class ConcreteAllyControlCenter extends AllControlCenter {

    public ConcreteAllyControlCenter(String name) {

        System.out.println(name + "战队组建成功！");
        System.out.println("----------------------------");
        this.allyName = name;
    }

    //实现通知方法
    @Override
    public void notifyObserver(String name) {
        System.out.println(this.allyName + "战队紧急通知，盟友" + name + "遭受敌人攻击！");

        //遍历观察者集合，调用每一个盟友（自己除外）的支援方法
        players.forEach(p->{
            if(name != p.getName()){
                p.help();
            }
        });
    }


}







package com.yinjun.observerpattern;

//抽象观察类
interface  Observer {

    public String getName();

    public void setName(String name);

    //声明支援盟友方法
     void help();
    //声明遭受攻击方法
    public void beAttacked(AllControlCenter acc);

}






package com.yinjun.observerpattern;
//战队成员类：具体观察者类
public class Player implements Observer {

    private String name;

    public Player(String name) {
        this.name = name;
    }

    @Override
    public String getName() {
        return name;
    }

    @Override
    public void setName(String name) {
        this.name = name;
    }

    //支援盟友方法的实现
    @Override
    public void help() {
        System.out.println("hold on " + name + "will help you ");
    }

    //遭受攻击方法的实现，当遭受攻击时将调用战队控制中心类的通知方法notifyObserver()来通知盟友
    @Override
    public void beAttacked(AllControlCenter acc) {
        System.out.println(this.name + "被攻击！");
        acc.notifyObserver(name);
    }
}

状态模式-State Pattern

状态模式用于解决系统中复杂对象的状态转换以及不同状态下行为的封装问题。当系统中某个对象存

在多个状态，这些状态之间可以进行转换，而且对象在不同状态下行为不相同时可以使用状态模式。

状态模式将一个对象的状态从该对象中分离出来，封装到专门的状态类中，使得对象状态可以灵活变

化，对于客户端而言，无须关心对象状态的转换以及对象所处的当前状态，无论对于何种状态的对

象，客户端都可以一致处理

状态模式 (State Pattern) ：允许一个对象在其内部状态改变时改变它的行为，对象看起来似乎修

改了它的类。其别名为状态对象 (Objects for States) ，状态模式是一种对象行为型模式

银行账号代码实现：

package pattern.statepattern;

//银行账户：环境类
public class Account {
    //维持一个对抽象状态对象的引用
    private AccountState accountState;
    //开户名
    private String owner;
    //账户余额
    private double balance = 0;

    public Account(String owner, double balance) {
        this.owner = owner;
        this.balance = balance;
        //设置初始状态
        this.accountState = new NormalState(this);
        System.out.println(this.owner + "开户，初始金额为" + balance);
        System.out.println("---------------------------------------------");
    }

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }


    public void setAccountState(AccountState accountState) {
        this.accountState = accountState;
    }


    public void deposit(double amount){
        System.out.println(this.owner + "存款" + amount);
        //调用状态对象的deposit()方法
        accountState.deposite(amount);
        System.out.println("现在余额为"+ this.balance);
        System.out.println("现在帐户状态为"+ this.accountState.getClass().getName());
        System.out.println("---------------------------------------------");
    }

    public void  withDraw(double amount){
        System.out.println(this.owner + "取钱" + amount);
        //调用状态对象的withdraw()方法
        accountState.withdraw(amount);
        System.out.println("现在余额为"+ this.balance);
        System.out.println("现在帐户状态为"+ this.accountState.getClass().getName());
        System.out.println("---------------------------------------------");
    }

    //调用状态对象的computeInterest()方法
    public  void computeInterest(){
        accountState.computeInterest();
    }

}





package pattern.statepattern;

//抽象状态类
abstract class AccountState {

    protected Account acc;

    public abstract void deposite(double amoutn);

    public abstract void withdraw(double amount);

    public abstract void computeInterest();

    public abstract void stateCheck();

}

package pattern.statepattern;

/**
 * 类说明
 *
 * @author Zeng zhiqiang
 * @version V1.0 创建时间: 2021/3/24 17:09
 * Copyright 2021 by WiteMedia
 */
public class NormalState extends AccountState{


    public NormalState(Account account) {
        this.acc = account;
    }

    public NormalState(AccountState state){
        this.acc = state.acc;
    }

    @Override
    public void deposite(double amount) {
        acc.setBalance(acc.getBalance() + amount);
        stateCheck();
    }

    @Override
    public void withdraw(double amount) {
        acc.setBalance(acc.getBalance() - amount);
        stateCheck();
    }

    @Override
    public void computeInterest() {
        System.out.println("正常状态，无须支付利息！");
    }

    @Override
    public void stateCheck() {

        if(acc.getBalance()> -2000 && acc.getBalance() < 0){
            acc.setAccountState(new OverdraftState(this));
        }else if(acc.getBalance() == -2000){
            acc.setAccountState(new RestrictedState(this));
        }else if(acc.getBalance() < -2000){
            System.out.println("操作受限！");
            //acc.setAccountState(new OverdraftState(this));
        }

    }
}




package pattern.statepattern;

/**
 * 类说明
 *
 * @author Zeng zhiqiang
 * @version V1.0 创建时间: 2021/3/24 18:41
 * Copyright 2021 by WiteMedia
 */
//透支状态：具体状态类
public class OverdraftState extends AccountState {


    public OverdraftState(AccountState state) {
        this.acc = state.acc;
    }

    @Override
    public void deposite(double amount) {
        acc.setBalance(acc.getBalance() + amount);
        stateCheck();
    }

    @Override
    public void withdraw(double amount) {
        acc.setBalance(acc.getBalance() - amount);
        stateCheck();
    }

    @Override
    public void computeInterest() {
        System.out.println("计算利息！");
    }

    @Override
    public void stateCheck() {
        double balance = acc.getBalance();

        if(balance >0){
            acc.setAccountState(new NormalState(this));
        }else if(balance == -2000){
            acc.setAccountState(new RestrictedState(this));
        }else if(balance < -2000){
            System.out.println("操作受限！");
        }

    }
}




package pattern.statepattern;

/**
 * 类说明
 *
 * @author Zeng zhiqiang
 * @version V1.0 创建时间: 2021/3/24 18:42
 * Copyright 2021 by WiteMedia
 */
//受限状态：具体状态类
public class RestrictedState extends AccountState {


    public RestrictedState(AccountState state){
        this.acc = state.acc;
    }


    @Override
    public void deposite(double amount) {
        acc.setBalance(acc.getBalance() + amount);
        stateCheck();
    }

    @Override
    public void withdraw(double amount) {
        System.out.println("帐号受限，取款失败");
    }

    @Override
    public void computeInterest() {
        System.out.println("计算利息！");
    }

    @Override
    public void stateCheck() {

        double balance = acc.getBalance();
        if(balance > 0){
            acc.setAccountState(new NormalState(this));
        }else if(balance < -2000){
            acc.setAccountState(new OverdraftState(this));
        }
    }
}





package pattern.statepattern;

/**
 * 类说明
 *
 * @author Zeng zhiqiang
 * @version V1.0 创建时间: 2021/3/24 18:52
 * Copyright 2021 by WiteMedia
 */
public class Client {

    public static void main(String[] args) {
        Account account = new Account("有钱人",0.0);

        account.deposit(2000);
        account.deposit(2000);
        account.deposit(5000);
        account.withDraw(9000);
        account.withDraw(1000);
        account.withDraw(2000);
        account.withDraw(9000);
        account.computeInterest();
    }
}

策略模式-Strategy Pattern

算法的封装与切换——策略模式

策略模式的主要目的是将算法的定义与使用分开，也就是将算法的行为和环境分开，将算法的定义放

在专门的策略类中，每一个策略类封装了一种实现算法，使用算法的环境类针对抽象策略类进行编

程，符合 “ 依赖倒转原则 ” 。在出现新的算法时，只需要增加一个新的实现了抽象策略类的具体策略类

即可

策略模式 (Strategy Pattern) ：定义一系列算法类，将每一个算法封装起来，并让它们可以相互

替换，策略模式让算法独立于使用它的客户而变化，也称为政策模式 (Policy) 。策略模式是一种对

象行为型模式。

电影票打折代码实现：

package pattern.strategypattern;

/**
 * 类说明
 *
 * @author Zeng zhiqiang
 * @version V1.0 创建时间: 2021/3/25 17:45
 * Copyright 2021 by WiteMedia
 */
public class Client {

    public static void main(String[] args) {
        MovieTicket movieTicket = new MovieTicket();
        movieTicket.setPrice(100);

        Discount discount = new StudentDiscount();
        movieTicket.setDiscount(discount);

        System.out.println(movieTicket.getPrice());
    }
}





package pattern.strategypattern;

/**
 * 类说明
 *
 * @author Zeng zhiqiang
 * @version V1.0 创建时间: 2021/3/25 17:40
 * Copyright 2021 by WiteMedia
 */
//折扣类：抽象策略类
interface  Discount {

      double calculate(double price);
}




package pattern.strategypattern;

/**
 * 类说明
 *
 * @author Zeng zhiqiang
 * @version V1.0 创建时间: 2021/3/25 17:39
 * Copyright 2021 by WiteMedia
 */
//电影票类：环境类
public class MovieTicket {

    private double price;

    //维持一个对抽象折扣类的引用
    private Discount discount;

    public double getPrice() {
        //调用折扣类的折扣价计算方法
        return discount.calculate(price);
    }


    public void setPrice(double price) {
        this.price = price;
    }

    //注入一个折扣类对象
    public void setDiscount(Discount discount) {
        this.discount = discount;
    }
}





package pattern.strategypattern;

/**
 * 类说明
 *
 * @author Zeng zhiqiang
 * @version V1.0 创建时间: 2021/3/25 17:42
 * Copyright 2021 by WiteMedia
 */
//学生票折扣类：具体策略类
public class StudentDiscount implements Discount{

    @Override
    public double calculate(double price) {
        System.out.println("学生票：");
        return price * 0.8;
    }
}





package pattern.strategypattern;

/**
 * 类说明
 *
 * @author Zeng zhiqiang
 * @version V1.0 创建时间: 2021/3/25 17:44
 * Copyright 2021 by WiteMedia
 */
//VIP会员票折扣类：具体策略类
public class VIPDiscount implements Discount {
    @Override
    public double calculate(double price) {
        System.out.println("VIP票：");
        return price * 0.88;
    }
}

模板方法模式-Template Method Pattern

模板方法模式：定义一个操作中算法的框架，而将一些步骤延迟到子类中。模板方法模式使得子类可以不改变一个算法的结构即可重

定义该算法的某些特定步骤。

模板方法模式是结构最简单的行为型设计模式，在其结构中只存在父类与子类之间的继承关系。通过

使用模板方法模式，可以将一些复杂流程的实现步骤封装在一系列基本方法中，在抽象父类中提供一

个称之为模板方法的方法来定义这些基本方法的执行次序，而通过其子类来覆盖某些步骤，从而使得

相同的算法框架可以有不同的执行结果。模板方法模式提供了一个模板方法来定义算法框架，而某些

具体步骤的实现可以在其子类中完成。

访问者模式-Visitor Pattern

操作复杂对象结构——访问者模式

访问者模式是一种较为复杂的行为型设计模式，它包含访问者和被访问元素两个主要组成部分，这些

被访问的元素通常具有不同的类型，且不同的访问者可以对它们进行不同的访问操作。例如处方单中

的各种药品信息就是被访问的元素，而划价人员和药房工作人员就是访问者。访问者模式使得用户可

以在不修改现有系统的情况下扩展系统的功能，为这些不同类型的元素增加新的操作。

访问者模式 (Visitor Pattern): 提供一个作用于某对象结构中的各元素的操作表示，它使我们可

以在不改变各元素的类的前提下定义作用于这些元素的新操作。访问者模式是一种对象行为型模式。

员工代码实现

package com.yinjun.visitPattern;

public class Client {

    public static void main(String args[]){

        FulltimeEmployee  fulltimeEmployee1 = new FulltimeEmployee("coco",200,50);
        FulltimeEmployee fulltimeEmployee2 = new FulltimeEmployee("lala",300,30);


        ParttimeEmployee parttimeEmployee1 = new ParttimeEmployee("joo",600,30);
        ParttimeEmployee parttimeEmployee2 = new ParttimeEmployee("ll",300,50);



        EmployeeList employeeList = new EmployeeList();
        employeeList.addEmployee(fulltimeEmployee1);
        employeeList.addEmployee(parttimeEmployee1);
        employeeList.addEmployee(fulltimeEmployee2);
        employeeList.addEmployee(parttimeEmployee2);
        employeeList.accept(new FADepartment());




     }
}



package com.yinjun.visitPattern;

//部门类：抽象访问者类
abstract class Department {

    //声明一组重载的访问方法，用于访问不同类型的具体元素
    public abstract void visit(FulltimeEmployee employee);

    public abstract void visit(ParttimeEmployee employee);
}



package com.yinjun.visitPattern;

//员工类：抽象元素类
interface Employee {

    //接受一个抽象访问者访问
    public void accept(Department handler);
}




package com.yinjun.visitPattern;

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

//员工列表类：对象结构
public class EmployeeList {

    //定义一个集合用于存储员工对象
    private List<Employee> list = new ArrayList<>();

    public void addEmployee(Employee employee){
        list.add(employee);
    }

    //遍历访问员工集合中的每一个员工对象
    public void accept(Department handler){
        list.forEach(l->{
            l.accept(handler);
        });
    }
}



package com.yinjun.visitPattern;

//财务部类：具体访问者类
public class FADepartment extends Department {


    //实现财务部对全职员工的访问
    @Override
    public void visit(FulltimeEmployee employee) {
        int workTime = employee.getWorkTime();
        double weeklyWage = employee.getWeeklyWage();
        if(workTime > 40){
            weeklyWage = weeklyWage + (workTime - 40) * 100;
        }else if(workTime < 40){
            weeklyWage = weeklyWage - (40 - weeklyWage) * 80;

            if(weeklyWage < 0){
                weeklyWage = 0;
            }
        }
        System.out.println("正式员工" + employee.getName() + "实际工资为：" + weeklyWage + "元。");
    }


    //实现财务部对兼职员工的访问
    @Override
    public void visit(ParttimeEmployee employee) {

        int workTime = employee.getWorkTime();
        double hourWage = employee.getHourWage();
        System.out.println("临时工" + employee.getName() + "实际工资为：" + workTime * hourWage + "元。");
    }
}




package com.yinjun.visitPattern;

//全职员工类：具体元素类
public class FulltimeEmployee implements  Employee{

    private String name;

    private double weeklyWage;

    private int workTime;

    public FulltimeEmployee(String name, double weeklyWage, int workTime) {
        this.name = name;
        this.weeklyWage = weeklyWage;
        this.workTime = workTime;
    }

    public String getName() {
        return name;
    }

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

    public double getWeeklyWage() {
        return weeklyWage;
    }

    public void setWeeklyWage(double weeklyWage) {
        this.weeklyWage = weeklyWage;
    }

    public int getWorkTime() {
        return workTime;
    }

    public void setWorkTime(int workTime) {
        this.workTime = workTime;
    }

    @Override
    public void accept(Department handler) {

        //调用访问者的访问方法
        handler.visit(this);
    }
}






package com.yinjun.visitPattern;


//人力资源部类：具体访问者类
public class HRDepartment extends  Department {

    //实现人力资源部对全职员工的访问
    @Override
    public void visit(FulltimeEmployee employee) {
        int workTime = employee.getWorkTime();
        if(workTime > 40 ){
            System.out.println("正式员工" + employee.getName() + "加班时间为：" + (workTime - 40) + "小时。");
        }else {
            System.out.println("正式员工" + employee.getName() + "请假时间为：" + (40 - workTime) + "小时。");
        }
    }


    //实现人力资源部对兼职员工的访问
    @Override
    public void visit(ParttimeEmployee employee) {
        int workTime = employee.getWorkTime();
        System.out.println("临时工" + employee.getName() + "实际工作时间为：" + workTime + "小时。");
    }
}




package com.yinjun.visitPattern;


//兼职员工类：具体元素类
public class ParttimeEmployee implements Employee {


    private String name;

    private double hourWage;

    private int workTime;

    public ParttimeEmployee(String name, double hourWage, int workTime) {
        this.name = name;
        this.hourWage = hourWage;
        this.workTime = workTime;
    }

    public String getName() {
        return name;
    }

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

    public double getHourWage() {
        return hourWage;
    }

    public void setHourWage(double hourWage) {
        this.hourWage = hourWage;
    }

    public int getWorkTime() {
        return workTime;
    }

    public void setWorkTime(int workTime) {
        this.workTime = workTime;
    }

    @Override
    public void accept(Department handler) {
        handler.visit(this);
    }
}

zzqtty

关注

0
点赞
踩
7

收藏

觉得还不错? 一键收藏
2
评论
java中的设计模式 - 11个行为型模式（完整代码实现）

职责链模式-Chain of Responsibility Pattern 职责链模式(Chain of Responsibility Pattern)：避免请求发送者与接收者耦合在一起，让多个对象都有可能接收请求，将这些对象连接成一条链，并且沿着这条链传递请求，直到有对象处理它为止。职责链模式是一种对象行为型模式。命令模式-Command Pattern 解释器模式-Interpreter Pattern 迭代器模式-Iterator Pa...
复制链接

扫一扫