设计模式——行为型设计模式

🚀 优质资源分享 🚀

行为型设计模式

针对对象之间的交互

解释器模式

java中用的很。JVM编译的时候就是对我们写的代码进行了解释操作；数据库SQL语句亦是如此

解释器：对语言进行解释，根据不同语义来做不同的事情。

举例：双栈计算器

copypublic class 双栈实现计算器 {
    //设置两栈
    private static Deque opr = new LinkedList<>();
 private static Deque number = new LinkedList<>();

 public static void main(String[] args) {
 //接收一串字符串并转字符数组
 Scanner scanner = new Scanner(System.in);
 String str = scanner.nextLine();
 char [] arrC = str.toCharArray();

 for (int i = 0; i < arrC.length;) {
 char c = arrC[i];
 //是+-/*字符时
 if (isChar(c)){
 ///如果栈内有字符，则需要判断优先级，入栈字符小于等于栈内字符则需要先计算栈内字符
 Character peek = opr.peek(); //细节！！！ 这里必须先取
 while (peek!=null && isLowIn(c,peek)){
 cal();
 peek=opr.peek(); //细节！！这里也必须更新peek
 }
 //入栈
 opr.push(c);
 i++;
 }
 //字符是数字时
 else {
 double sum=0; //接收整数和
 double sum2=0; //接收小数和
 int times = 1; //记录当前小数位数
 boolean flag=false; //是否开启小数检测模式

 //判断下一个是不是+-*/，不是的话就继续判断直到非数字
 while (i<=arrC.length-1 && !isChar(arrC[i])){ //细节：括号内两者顺序不能改变
 //遇到小数的情况
 if (arrC[i]=='.'){
 flag=true;
 }else {
 //小数情况
 if (flag){
 double val=arrC[i]-'0';
 for (int j = 0; j < times; j++) { //细节！用times缩小值
 val/=10.0;
 }
 times++;
 sum2+=val;
 }
 //正数情况
 else {
 sum=sum*10+arrC[i]-'0'; //获取多位数字的关键！！！
 }
 }
 i++;
 }
 number.push(sum+sum2);
 }
 }
 //字符都获取完了后栈内还有数字和字符的话，就计算完栈内的数据并输出最终结果
 while (!opr.isEmpty()) cal();
 System.out.println(number.peek());
 }

 //判断是否为字符
 public static boolean isChar(char c) {
 return c=='+'||c=='-'||c=='*'||c=='/';
 }

 //判断优先级是否是栈外字符小于等于栈内字符
 public static boolean isLowIn(char out,char in){
 return (out=='+'||out=='-')||(in=='*'||in=='/');
 }

 public static void cal(){
 //从栈内取出两个数组和一个字符
 double a = number.pop();
 double b = number.pop();
 char c = opr.poll();

 //根据字符c进行不同的运算
 switch (c){
 case '+':
 number.push(a+b);
 break;
 case '-':
 number.push(b-a);
 break;
 case '*':
 number.push(b*a);
 break;
 case '/':
 number.push(b/a);
 break;
 default:
 System.out.println("字符输入有误");
 }
 }

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

模板方法模式

在执行一类业务时前面有很多步骤都是相同时，就可以写一个模板抽象类，留出一个方法去给子类定义业务最后的操作。

该模式在源码中大量的被应用。这样写会给后期维护提供非常清晰的思路

举例：去医院看病，挂号和看医生是固定模式，但后面要不要开处方药和拿药是不一定的

copy//模板抽象类
/**
 * 抽象诊断方法，因为现在只知道挂号和看医生是固定模式，剩下的开处方和拿药都是不确定的
 */
public abstract class AbstractDiagnosis {

    public void test(){
        System.out.println("今天头好晕，不想起床，开摆，先跟公司请个假");
        System.out.println("去医院看病了~");
        System.out.println("1 >> 先挂号");
        System.out.println("2 >> 等待叫号");
        //由于现在不知道该开什么处方，所以只能先定义一下行为，然后具体由子类实现
      	//大致的流程先定义好就行
        this.prescribe();
        this.medicine();  //开药同理
    }

    public abstract void prescribe();   //开处方操作根据具体病症决定了

    public abstract void medicine();   //拿药也是根据具体的处方去拿
}

//实现具体业务的子类
/**
 * 感冒相关的具体实现子类
 */
public class ColdDiagnosis extends AbstractDi
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26