行為型設計模式
針對物件之間的互動
解釋器模式
java中用的很，JVM編譯的時候就是對我們寫的代碼進行了解釋操作；資料庫SQL陳述句亦是如此
解釋器：對語言進行解釋，根據不同語意來做不同的事情，
舉例：雙堆疊計算器
public class 雙堆疊實作計算器 {
//設定兩堆疊
private static Deque<Character> opr = new LinkedList<>();
private static Deque<Double> 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("字符輸入有誤");
}
}
}
模板方法模式
在執行一類業務時前面有很多步驟都是相同時，就可以寫一個模板抽象類，留出一個方法去給子類定義業務最后的操作，
該模式在原始碼中大量的被應用，這樣寫會給后期維護提供非常清晰的思路
舉例：去醫院看病，掛號和看醫生是固定模式，但后面要不要開處方藥和拿藥是不一定的
//模板抽象類
/**
* 抽象診斷方法，因為現在只知道掛號和看醫生是固定模式，剩下的開處方和拿藥都是不確定的
*/
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 AbstractDiagnosis{
@Override
public void prescribe() {
System.out.println("3 >> 一眼丁真，鑒定為假，你這不是感冒，純粹是想擺爛");
}
@Override
public void medicine() {
System.out.println("4 >> 開點頭孢回去吃吧");
}
}
//主方法
public static void main(String[] args) {
AbstractDiagnosis diagnosis = new ColdDiagnosis();
diagnosis.test();
}
責任鏈模式
就像闖關，一層接一層的往下進行，可以理解為報銷的時候需要一層一層審批
比如JavaWeb中學習的Filter過濾器，正是采用的責任鏈模式，通過將請求一級一級不斷向下傳遞，來對我們所需要的請求進行過濾和處理，
舉例：這里就使用責任鏈模式來模擬一個簡單的面試程序，面試也是一面二面三面這樣走的流程，這里先設計一下責任鏈上的各個處理器
//設計模板抽象方法，并在此基礎上寫層層往下的責任鏈
public abstract class Handler {
protected Handler successor; //這里我們就設計責任鏈以單鏈表形式存在，這里存放后繼節點
public Handler connect(Handler successor){ //拼接后續節點
this.successor = successor;
return successor; //這里回傳后繼節點，方便我們一會鏈式呼叫
}
public void handle(){
this.doHandle(); //由不同的子類實作具體處理程序
Optional
.ofNullable(successor) //設定可以為null
.ifPresent(Handler::handle); //責任鏈上如果還有后繼節點，就繼續向下傳遞
}
public abstract void doHandle(); //結合上節課學習的模板方法，交給子類實作
}
//一面子類
public class FirstHandler extends Handler{ //用于一面的處理器
@Override
public void doHandle() {
System.out.println("============= 白馬程式員一面 ==========");
System.out.println("1. 談談你對static關鍵字的理解？");
System.out.println("2. 內部類可以呼叫外部的資料嗎？如果是靜態的呢？");
System.out.println("3. hashCode()方法是所有的類都有嗎？默認回傳的是什么呢？");
System.out.println("以上問題會的，可以依次打在評論區");
}
}
//二面子類
public class SecondHandler extends Handler{ //二面
@Override
public void doHandle() {
System.out.println("============= 白馬程式員二面 ==========");
System.out.println("1. 如果我們自己創建一個java.lang包并且撰寫一個String類，能否實作覆寫JDK默認的？");
System.out.println("2. HashMap的負載因子有什么作用？變化規律是什么？");
System.out.println("3. 執行緒池的運作機制是什么？");
System.out.println("4. ReentrantLock公平鎖和非公平鎖的區別是什么？");
System.out.println("以上問題會的，可以依次打在評論區");
}
}
//三面子類
public class ThirdHandler extends Handler{
@Override
public void doHandle() {
System.out.println("============= 白馬程式員三面 ==========");
System.out.println("1. synchronized關鍵字了解嗎？如何使用？底層是如何實作的？");
System.out.println("2. IO和NIO的區別在哪里？NIO三大核心組件？");
System.out.println("3. TCP握手和揮手流程？少一次握手可以嗎？為什么？");
System.out.println("4. 作業系統中PCB是做什么的？運行機制是什么？");
System.out.println("以上問題會的，可以依次打在評論區");
}
}
//主方法
public static void main(String[] args) {
Handler handler = new FirstHandler(); //一面首當其沖
handler
.connect(new SecondHandler()) //繼續連接二面和三面
.connect(new ThirdHandler());
handler.handle(); //開始面試
}
命令模式
命令模式，此時會有三個頂層行為：遙控器、命令、接收器，
話不多說，直接搬例，小米家具就是典型的命令模式，只需要在手機（遙控器）上通過紅外線、藍牙等按下一些命令，家中的家具（接收器）就會執行命令，
舉例：設定三個頂層的 介面/抽象類 ，遙控器、命令、接收器
//遙控器
public class Controller { //遙控器只需要把我們的指令發出去就行了
public static void call(Command command){
command.execute();
}
}
//命令
public abstract class Command { //指令抽象，不同的電器有指令
private final Receiver receiver;
protected Command(Receiver receiver){ //指定此命令對應的電器（接受者）
this.receiver = receiver;
}
public void execute() {
receiver.action(); //執行命令，實際上就是讓接收者開始干活
}
}
//接收器
public interface Receiver {
void action(); //具體行為，這里就寫一個算了
}
//具體接收器
public class AirConditioner implements Receiver{
@Override
public void action() {
System.out.println("空調已開啟，呼呼呼");
}
}
//具體命令
public class OpenCommand extends Command {
public OpenCommand(AirConditioner airConditioner) {
super(airConditioner);
}
}
//可以創建具體控制器（手機），也可以不創建直接遙控，因為控制器一般只有一個，所以這里就不創建了
//主方法
public static void main(String[] args) {
AirConditioner airConditioner = new AirConditioner(); //先創建一個空調
Controller.call(new OpenCommand(airConditioner)); //直接通過遙控器來發送空調開啟命令
}
迭代器模式
每個集合類都有相應的迭代器，很少自定義，大都是用jdk定義好的迭代器
迭代器最直接的例子就是foreach語法糖，
public static void main(String[] args) {
List<String> list = Arrays.asList("AAA", "BBB", "CCC");
for (String s : list) { //使用foreach語法糖進行迭代，依次獲取每一個元素
System.out.println(s); //列印一下
}
}
上述代碼編譯后的樣子：
public static void main(String[] args) {
List<String> list = Arrays.asList("AAA", "BBB", "CCC");
Iterator var2 = list.iterator(); //實際上這里本質是通過List生成的迭代器來遍歷我們每個元素的
while(var2.hasNext()) { //判斷是否還有元素可以迭代，沒有就false
String s = (String)var2.next(); //通過next方法得到下一個元素，每呼叫一次，迭代器會向后移動一位
System.out.println(s); //列印一下
}
}
由此可知迭代器原理：使用迭代器對List進行遍歷時，實際上就像一個指向串列頭部的指標，我們通過不斷向后移動指標來依次獲取所指向的元素：
拓展：自定義迭代器，
（由于每個迭代器需要根據不同的集合類特點來設計，所以自定義迭代器前需要自定義一個集合類）
//自定義集合類
public class ArrayCollection<T> { //首先設計一個簡單的陣列集合，一會我們就迭代此集合內的元素
private final T[] array; //底層使用一個陣列來存放資料
private ArrayCollection(T[] array){ //private掉，自己用
this.array = array;
}
public static <T> ArrayCollection<T> of(T[] array){ //開個靜態方法直接吧陣列轉換成ArrayCollection，其實和直接new一樣，但是這樣寫好看一點
return new ArrayCollection<>(array);
}
}
//自定義迭代器
public class ArrayCollection<T> implements Iterable<T>{ //實作Iterable介面表示此類是支持迭代的
...
@Override
public Iterator<T> iterator() { //需要實作iterator方法，此方法會回傳一個迭代器，用于迭代我們集合中的元素
return new ArrayIterator();
}
public class ArrayIterator implements Iterator<T> { //這里實作一個，注意別用靜態，需要使用物件中存放的陣列
private int cur = 0; //這里我們通過一個指標表示當前的迭代位置
@Override
public boolean hasNext() { //判斷是否還有下一個元素
return cur < array.length; //如果指標大于或等于陣列最大長度，就不能再繼續了
}
@Override
public T next() { //回傳當前指標位置的元素并向后移動一位
return array[cur++]; //正常回傳對應位置的元素，并將指標自增
}
}
}
//主方法
public static void main(String[] args) {
String[] arr = new String[]{"AAA", "BBB", "CCC", "DDD"};
ArrayCollection<String> collection = ArrayCollection.of(arr);
for (String s : collection) { //可以直接使用foreach語法糖，當然最后還是會變成迭代器呼叫
System.out.println(s);
}
}
//編譯主方法后的樣子
public static void main(String[] args) {
String[] arr = new String[]{"AAA", "BBB", "CCC", "DDD"};
ArrayCollection<String> collection = ArrayCollection.of(arr);
Iterator var3 = collection.iterator(); //首先獲取迭代器，實際上就是呼叫我們實作的iterator方法
while(var3.hasNext()) {
String s = (String)var3.next(); //直接使用next()方法不斷向下獲取
System.out.println(s);
}
}
中介者模式
將多對多的復雜關系，變成一對多的簡單明了關系
話不多說，直接上例子，中介，第一個想到的就是房子的中介，當一堆人需要出租房屋、另一堆人又需要租房，如果沒有中介，那再好的房子很難遇上租客也租不出去，此時就需要一個中介將雙方的需要進行匹配從而實作房子出租的目的，
不找中介：很亂，還不一定能夠遇上需求相同的對方
找中介：中介將雙方整理好，進行需求匹配
舉例：中介、出租者、租房者
//中介
public class Mediator { //房產中介
private final Map<String, User> userMap = new HashMap<>(); //在出售的房子需要存盤一下
public void register(String address, User user){ //出售房屋的人，需要告訴中介他的房屋在哪里
userMap.put(address, user);
}
public User find(String address){ //通過此方法來看看有沒有對應的房源
return userMap.get(address);
}
}
//出租者和租房者（這里偷懶就寫在一起了）
public class User { //用戶可以是出售房屋的一方，也可以是尋找房屋的一方
String name;
String tel;
public User(String name, String tel) {
this.name = name;
this.tel = tel;
}
public User find(String address, Mediator mediator){ //找房子的話，需要一個中介和你具體想找的地方
return mediator.find(address);
}
@Override
public String toString() {
return name+" (電話："+tel+")";
}
}
//主方法
public static void main(String[] args) {
User user0 = new User("劉女士", "10086"); //出租者
User user1 = new User("李先生", "10010"); //租房者
Mediator mediator = new Mediator(); //我是中介
mediator.register("廣州市天河區白馬程式員", user0); //出租人先把房子給中介掛上去
User user = user1.find("廣州市天河區非馬程式員", mediator); //租房者向指定中介找房子
if(user == null) System.out.println("沒有找到對應的房源");
System.out.println(user); //成功找到對應房源
}
備忘錄模式
我也稱其為
時光回溯模式，比較少用，大都是底層代碼才用
這個備忘錄不是我們平時用于記錄容易忘記的ddl，而是保存曾經某個時刻的狀態，后面有需要就恢復到該時刻的狀態
舉例：保存物件的狀態
//物件物體
public class Student {
private String currentWork; //當前正在做的事情
private int percentage; //當前的作業完成百分比
public void work(String currentWork) {
this.currentWork = currentWork;
this.percentage = new Random().nextInt(100);
}
@Override
public String toString() {
return "我現在正在做："+currentWork+" (進度："+percentage+"%)";
}
public State save(){
return new State(currentWork, percentage);
}
public void restore(State state){
this.currentWork = state.currentWork;
this.percentage = state.percentage;
}
}
//狀態保存類
public class State {
final String currentWork;
final int percentage;
State(String currentWork, int percentage) { //僅開放給同一個包下的Student類使用
this.currentWork = currentWork;
this.percentage = percentage;
}
}
//主方法
public static void main(String[] args) {
Student student = new Student();
student.work("學Java"); //開始學Java
System.out.println(student);
State savedState = student.save(); //保存一下當前的狀態
student.work("打電動"); //剛打開B站播放視頻，學一半開始擺爛了
System.out.println(student);
student.restore(savedState); //后悔浪費時間，回到上一個保存的狀態
System.out.println(student); //回到學Java的狀態
}
觀察者模式
觀察者模式可以實作監聽器機制，當物件發生改變時，觀察者能夠立即察覺到并進行一些聯動操作，很少用，大都是直接用監聽器
舉例：自定義觀察者
//觀察者介面
public interface Observer { //觀察者介面
void update(); //當物件有更新時，會回呼此方法
}
//支持觀察者的物體
public class Subject {
private final Set<Observer> observerSet = new HashSet<>();
public void observe(Observer observer) { //添加觀察者
observerSet.add(observer);
}
public void modify() { //模擬物件進行修改
observerSet.forEach(Observer::update); //當物件發生修改時，會通知所有的觀察者，并進行方法回呼
}
}
//主方法
public static void main(String[] args) {
Subject subject = new Subject();
subject.observe(() -> System.out.println("我是一號觀察者！"));
subject.observe(() -> System.out.println("我是二號觀察者！"));
subject.modify();
}
JDK也提供了是實作觀察者模式的相關介面：
//繼承介面表示支持觀察者
import java.util.Observable; //java.util包下提供的觀察者抽象類
public class Subject extends Observable { //繼承此抽象類表示支持觀察者
public void modify(){
System.out.println("對物件進行修改！");
this.setChanged(); //當對物件修改后，需要setChanged來設定為已修改狀態
this.notifyObservers(new Date()); //使用notifyObservers方法來通知所有的觀察者
//注意只有已修改狀態下通知觀察者才會有效，并且可以給觀察者傳遞引數，這里傳遞了一個時間物件
}
}
//主方法
public static void main(String[] args) {
Subject subject = new Subject();
subject.addObserver((o, arg) -> System.out.println("監聽到變化，并得到引數："+arg));
//注意這里的Observer是java.util包下提供的
subject.modify(); //進行修改操作
}
狀態模式
根據不同的狀態執行不同的行為
水在不同的溫度狀態會隨之改變，程式也可以達到某種狀態后就執行不同的行為
//列舉狀態
public enum State { //狀態直接使用列舉定義
NORMAL, LAZY
}
//物體類
public class Student {
private State state; //使用一個成員來存盤狀態
public void setState(State state) {
this.state = state;
}
public void study(){
switch (state) { //根據不同的狀態，學習方法會有不同的結果
case LAZY:
System.out.println("只要我不努力，老板就別想過上想要的生活，開擺！");
break;
case NORMAL:
System.out.println("拼搏百天，我要上清華大學！");
break;
}
}
}
//主方法
public static void main(String[] args) {
Student student = new Student();
student.setState(State.NORMAL); //先正常模式
student.study();
student.setState(State.LAZY); //開啟擺爛模式
student.study();
}
策略模式
和狀態模式代碼一樣，但狀態模式思想是：狀態是先天的設定，就像水不同溫度狀態不同，而策略模式思想是：策略需要根據不同情況制定的，
舉例：簡單的陣列排列
//策略介面（模板方法模式）
public interface Strategy { //策略介面，不同的策略實作也不同
Strategy SINGLE = Arrays::sort; //單執行緒排序方案
Strategy PARALLEL = Arrays::parallelSort; //并行排序方案
void sort(int[] array);
}
//排序類
public class Sorter {
private Strategy strategy; //策略
public void setStrategy(Strategy strategy) {
this.strategy = strategy;
}
public void sort(int[] array){
strategy.sort(array);
}
}
//主方法
public static void main(String[] args) {
Sorter sorter = new Sorter();
sorter.setStrategy(Strategy.PARALLEL); //指定為并行排序方案
sorter.sort(new int[]{9, 2, 4, 5, 1, 0, 3, 7});
}
訪問者模式
一件事情，一個訪問介面，訪問者實作該介面，但不同訪問者關心的事情著重點不同
舉例：假如你獲獎了還是國家級一等獎
//獎物體類
public class Prize { //獎
String name; //比賽名稱
String level; //等級
public Prize(String name, String level) {
this.name = name;
this.level = level;
}
public String getName() {
return name;
}
public String getLevel() {
return level;
}
}
//訪問者介面
public interface Visitor {
void visit(Prize prize); //visit方法來訪問我們的獎項
}
//不同訪問者
public class Teacher implements Visitor { //指導老師作為一個訪問者
@Override
public void visit(Prize prize) { //它只關心你得了什么獎以及是幾等獎，這也關乎老師的榮譽
System.out.println("你得獎是什么獎？"+prize.name);
System.out.println("你得了幾等獎？"+prize.level);
}
}
public class Boss implements Visitor{ //你的公司老板作為一個訪問者
@Override
public void visit(Prize prize) { //你的老板只關心這些能不能為公司帶來什么效益，獎本身并不重要
System.out.println("你的獎項大么，能夠為公司帶來什么效益么？");
System.out.println("還不如老老實實加班給我多干干，別去搞這些沒用的");
}
}
//主方法
public static void main(String[] args) {
Prize prize = new Prize("ACM國際大學生程式設計競賽","一等價");
Teacher teacher = new Teacher();
Boss boss = new Boss();
teacher.visit(prize);
boss.visit(prize);
}
轉載請註明出處，本文鏈接：https://www.uj5u.com/ruanti/502162.html
標籤：設計模式
上一篇：訊息佇列基本原理和選型對比
下一篇：設計模式——行為型設計模式