liujijiang

23种设计模式-11种行为型模式

2020.05.19

行为型模式:对象之间怎么相互协作完成一个任务

策略模式(Strategy)[常用]

为了达到一个目的可以有很多的手段,比如出行方式可以有汽车,飞机,火车,比如排序有快排,冒泡排序,选择排序等,采用策略模式设计类,可以方便的增加新的方式同时不改变现有代码

实现

  • 方式接口
  • 方式实现
  • 方式工厂

排序策略,如果想要增加一个新的排序方法,只需要实现排序接口即可,不需要改变现有代码

package com.DesignPatterns.behavioral.strategy;

import com.sun.xml.internal.bind.v2.model.annotation.Quick;

/**
 * @Author redarm
 * @Date 2020/5/20 8:05 下午
 * Strategy DesignPatterns
 **/
public class Strategy {

    public static void main(String[] args) {
        SortFactory sortFactory = new SortFactory(new QuickSort());

        sortFactory.showMethodInfo();
    }
}

interface SortMethod{
    void show();
}

class QuickSort implements SortMethod{

    @Override
    public void show() {
        System.out.println("This is quick sort");
    }
}

class BubbleSort implements SortMethod{

    @Override
    public void show() {
        System.out.println("This is bubble sort");
    }
}

class SortFactory{

    private SortMethod sortMethod;

    public SortFactory(SortMethod sortMethod){
        this.sortMethod = sortMethod;
    }

    public void showMethodInfo(){
        sortMethod.show();
    }
}

观察者模式(Observer)[常用]

一个对象改变时,其他的对象也需要改变,比如红灯车会停止,绿灯车会前进,数据变了折线图也跟着变了,一对多的依赖关系,一个对象改变后所有依赖他的对象也需要改变,这种模式又叫做发布-订阅模式

实现

  • 观察者抽象类
  • 观察者实现
  • 被观察对象订阅的接口
  • 被观察对象的实现

例子:老大跑路手下也会跟着全跑路,比如斧头帮老大跑路了,那他手下的所有打手和副手 也都会跑路

package com.DesignPatterns.behavioralModel.observer;

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

/**
 * @Author redarm
 * @Date 2020/5/20 8:27 下午
 * Observer DesignPatterns
 **/
public class Observer {

    public static void main(String[] args) {
        Boss boss = new AxeGang();

        for (int i=0; i<10; i++){
            boss.add(new Thug(i+1));
        }

        boss.add(new Deputy());

        boss.run();
    }
}

// 定义老大接口
abstract class Boss{

    protected List<Men> mens = new ArrayList<>();

    public void add(Men men){
        mens.add(men);
    }

    public void remove(Men men){
        mens.remove(men);
    }

    public abstract void run();
}

// 定义斧头帮老大
class AxeGang extends Boss{

    @Override
    public void run() {
        System.out.println("Boss run");

        ListIterator<Men> iterator = mens.listIterator();

        while (iterator.hasNext()){
            iterator.next().run();
        }
    }
}

// 定义老大的手下接口
interface Men {

    void run();
}

// 老大手下的打手
class Thug implements Men{

    private int num;

    public Thug(int num){
        this.num = num;
    }

    @Override
    public void run() {
        System.out.println("The thug " + num + " of boss also run away");
    }
}

// 老大手下的副手
class Deputy implements Men{

    @Override
    public void run() {
        System.out.println("The deputy of boss also run away");
    }
}

责任链模式(Chain of responsibility)[常用]

一个请求需要多个响应者处理,把响应者排成一个链表,前一个响应者记住下一个响应者的引用,响应者依次处理请求

应用

  • 抽象请求
  • 继承请求的响应者们
  • 组装响应者链

审批土地

package com.DesignPatterns.behavioralModel.chainOfResponsibitily;

/**
 * @Author redarm
 * @Date 2020/5/22 7:33 下午
 * chain of responsibility designpatterns
 **/
public class ChainOfResponsibility {

    public static void main(String[] args) {

        LandCheckHandle landCheckHandle = new LandCheckHandle();

        landCheckHandle.start(6000);
    }
}

abstract class CountryLeader{

    protected CountryLeader next;

    public abstract void checkLand(int size);
}

class Mayor extends CountryLeader{

    @Override
    public void checkLand(int size) {
        if (size <= 1000){
            System.out.println("Passed");
        } else {
            System.out.println("give it to Magistrate to check");
            next.checkLand(size);
        }
    }
}

class Magistrate extends CountryLeader{

    @Override
    public void checkLand(int size) {
        if (size <= 5000){
            System.out.println("Passed");
        } else {
            System.out.println("give it to country to check");
            next.checkLand(size);
        }
    }
}

class CountryBoss extends CountryLeader{

    @Override
    public void checkLand(int size) {
        System.out.println("Passed");
    }
}

class LandCheckHandle {

    public void start(int size){

        Mayor mayor = new Mayor();
        Magistrate magistrate = new Magistrate();
        CountryBoss countryBoss = new CountryBoss();

        mayor.next = magistrate;
        magistrate.next = countryBoss;

        mayor.checkLand(size);
    }
}