行为型模式：对象之间怎么相互协作完成一个任务
策略模式（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);
}
}