這個是用戶端真正觸發指令并要求指令執行相應操作的地方，也就是說相當于使用指令對象的入口。
*
* 3.5 用戶端（Client）：指令由用戶端來建立，并設定指令的接收者。
*/
//TODO
//将請求封裝為對象
//接收者 ：真正執行指令的對象
class Adder {
//電腦初始值
private var num: Int = 0
def add(value: Int): Int = {
num += value
num
}
}
//抽象指令
abstract class AbstractCommand {
def execute(value: Int): Int
def undo(): Int //撤銷操作
def redo(): Int //二次撤銷
}
//具體指令
class AddCommand extends AbstractCommand {
private var add = new Adder //指令接受者
private var values = new ArrayBuffer[Int]() //記錄value的棧
private var redovalue = new ArrayBuffer[Int]() //記錄redo數值
override def execute(value: Int): Int = {
values += value
add.add(value)
}
override def undo(): Int = {
values.length match {
case 0 =>
println("cannot undo"); add.add(0)
case _ =>
val temp = values.remove(values.length - 1)
redovalue += temp
add.add(-temp)
}
}
override def redo(): Int = {
redovalue.length match {
case 0 =>
println("cannot redo"); add.add(0)
case _ =>
val temp = redovalue.remove(redovalue.length - 1)
values += temp
add.add(temp)
}
}
}
//調用者
class InvokeCalculatorForm(command: AbstractCommand) {
def compute(value: Int): Unit = {
val i = command.execute(value)
println(s"執行運算，運算結果為: $i")
}
def undo(): Unit = {
val i = command.undo()
println(s"執行undo，運算結果為: $i")
}
def redo(): Unit = {
val i = command.redo()
println(s"執行redo，運算結果為: $i")
}
}
object md15Command extends App {
val command: AbstractCommand = new AddCommand
val form = new InvokeCalculatorForm(command)
form.compute(10)
form.compute(5)
form.undo()
form.undo()
form.redo()
form.redo()
form.redo()
form.undo()
form.undo()
form.undo()
form.redo()
form.compute(100)
}
7.備忘錄模式、
/**
* 備忘錄模式
* 定義：在不破壞封裝性的前提下，捕獲一個對象的内部狀态，并在該對象之外儲存這個狀态。這樣就可以将該對象恢複到原先儲存的狀态
*
* 備忘錄模式的結構
*
* 發起人：記錄目前時刻的内部狀态，負責定義哪些屬于備份範圍的狀态，負責建立和恢複備忘錄資料。 Chessman
* 備忘錄：負責存儲發起人對象的内部狀态，在需要的時候提供發起人需要的内部狀态。 ChessMemeto
* 管理角色：對備忘錄進行管理，儲存和提供備忘錄。
*/
/**
* 下棋方法特質
*/
trait ChessmanFunction {
/**
* 存放多個備忘錄
*/
private var mementoArrayBuffer = new ArrayBuffer[ChessMemento]()
/**
* 定義初始位置索引
*/
private var index = -1
/**
* 設定備忘錄
* @param memento 備忘錄
*/
def setMemento(memento: ChessMemento): Unit = mementoArrayBuffer += memento
/**
* 下棋
* @param chessman 棋子
*/
def play(chessman: Chessman): Unit = {
setMemento(chessman.save)
index += 1
println(s"棋子${chessman.label} 目前位置為第${chessman.x}行，第${chessman.y}列")
}
/**
* 悔棋
* @param chessman 棋子
*/
def undo(chessman: Chessman): Unit = {
println("******悔棋******")
index match {
case -1 => println("已經在最初位置，無法撤銷")
case 0 => index -= 1
println("已經在最初位置，無法撤銷")
case length: Int if length > 0 => index -= 1
chessman.restore(mementoArrayBuffer(index))
println(s"棋子${chessman.label} 目前位置為第${chessman.x}行，第${chessman.y}列")
case _ => println("出現異常")
}
}
/**
* 撤銷悔棋
* @param chessman 棋子
*/
def redo(chessman: Chessman): Unit = {
println("******撤銷悔棋******")
index match {
case -1 => index = 1
chessman.restore(mementoArrayBuffer(index))
println(s"棋子${chessman.label} 目前位置為第${chessman.x}行，第${chessman.y}列")
case length: Int if -1 < length && length < mementoArrayBuffer.length - 1 => index += 1
chessman.restore(mementoArrayBuffer(index))
println(s"棋子${chessman.label} 目前位置為第${chessman.x}行，第${chessman.y}列")
case length: Int if length >= mementoArrayBuffer.length - 1 => println("已經在最終位置，無法恢複")
case _ => println(s"異常$index")
}
}
}
case class Chessman(var label: String, var x: Int, var y: Int) extends ChessmanFunction {
/**
* 儲存狀态
* @return 備忘錄
*/
def save: ChessMemento = ChessMemento(this.label, this.x, this.y)
/**
* 恢複狀态
* @param chessMemento 備忘錄
*/
def restore(chessMemento: ChessMemento): Unit = {
label = chessMemento.label
x = chessMemento.x
y = chessMemento.y
}
}
/**
* 備忘錄樣例類
* @param label 标簽
* @param x x坐标
* @param y y坐标
*/
case class ChessMemento( label: String, x: Int, y: Int)
object memento extends App{
val chess = new Chessman("馬",1,1)
chess.undo(chess)
chess.play(chess)
chess.y = 4
chess.play(chess)
chess.x = 5
chess.play(chess)
chess.undo(chess)
chess.undo(chess)
chess.undo(chess)
chess.redo(chess)
chess.redo(chess)
chess.redo(chess)
chess.redo(chess)
chess.undo(chess)
chess.undo(chess)
chess.undo(chess)
chess.undo(chess)
chess.undo(chess)
chess.redo(chess)
}
8.狀态模式、
/**
* 狀态模式
*
* 當一個對象的内在狀态改變時允許改變其行為，這個對象看起來像是改變了其類。
*
* 2. 解決的問題
*
* 主要解決的是當控制一個對象狀态轉換的條件表達式過于複雜時的情況。把狀态的判斷邏輯轉移到表示不同的一系列類當中，可以把複雜的邏輯判斷簡單化。
*
* 3. 模式中的角色
*
* 3.1 上下文環境（Context）：它定義了客戶程式需要的接口并維護一個具體狀态角色的執行個體，将與狀态相關的操作委托給目前的Concrete State對象來處理。
*
* 3.2 抽象狀态（State）：定義一個接口以封裝使用上下文環境的的一個特定狀态相關的行為。
*
* 3.3 具體狀态（Concrete State）：實作抽象狀态定義的接口。
*/
/**
* 抽象狀态
* sealed關鍵字可以修飾類和特質（特質）。密封類提供了一種限制：不能在類定義的檔案之外定義任何新的子類
*/
sealed abstract class ScreenState {
def display(): Unit = {}
}
//具體狀态
case class NormalScreenState(screen: Screen) extends ScreenState {
override def display(): Unit = {
println(s"正常大小,長:${screen.wide},寬:${screen.long}")
}
}
/**
* 放大兩倍狀态
* @param screen 螢幕
*/
case class LargerScreenState(screen: Screen) extends ScreenState {
override def display(): Unit = {
println(s"兩倍大小,長:${screen.wide},寬:${screen.long}")
}
}
/**
* 放大四倍狀态
* @param screen 螢幕
*/
case class LargestScreenState(screen: Screen) extends ScreenState {
override def display(): Unit = {
println(s"四倍大小,長:${screen.wide},寬:${screen.long}")
}
}
class Screen(var long: Int = 1, var wide: Int = 1) {
/**
* 初始化螢幕狀态
*/
private var screenState: ScreenState = NormalScreenState(this)
/**
* 顯示長寬
*/
show()
/**
* 點選事件，點選觸發狀态的改變
*/
def onClick(): Unit = screenState match {
case NormalScreenState(_) =>
this.wide += this.wide
this.long += this.long
screenState = LargerScreenState(this)
print("點選：")
screenState.display()
case LargerScreenState(_) =>
this.wide += this.wide
this.long += this.long
screenState = LargestScreenState(this)
print("點選：")
screenState.display()
case LargestScreenState(_) =>
this.wide = this.wide / 4
this.long = this.long / 4
screenState = NormalScreenState(this)
print("點選：")
screenState.display()
}
/**
* 展示
*/
def show(): Unit = {
print("顯示：")
screenState.display()
}
}
object md20State extends App{
val screen = new Screen
screen.show()
screen.onClick()
screen.show()
screen.onClick()
screen.onClick()
screen.onClick()
}
9.通路者模式、
/**
* 定義：封裝某些作用于某種資料結構中各元素的操作，它可以在不改變資料結構的前提下定義作用于這些元素的新的操作
*
* 1.抽象通路者：抽象類或者接口，聲明通路者可以通路哪些元素，具體到程式中就是visit方法中的參數定義哪些對象是可以被通路的。
* 2. 通路者：實作抽象通路者所聲明的方法，它影響到通路者通路到一個類後該幹什麼，要做什麼事情。
* 3.抽象元素類：接口或者抽象類，聲明接受哪一類通路者通路，程式上是通過accept方法中的參數來定義的。抽象元素一般有兩類方法，一部分是本身的業務邏輯，另外就是允許接收哪類通路者來通路。
* 4. 元素類：實作抽象元素類所聲明的accept方法，通常都是visitor.visit(this)，基本上已經形成一種定式了。
* 結構對象：一個元素的容器，一般包含一個容納多個不同類、不同接口的容器，如List、Set、Map等，在項目中一般很少抽象出這個角色。
*
*
*
* 通路者模式可能是行為類模式中最複雜的一種模式了，但是這不能成為我們不去掌握它的理由。我們首先來看一個簡單的例子，代碼如下：
* [java] view plain copy
*
* class A {
* public void method1(){
* System.out.println("我是A");
* }
*
* public void method2(B b){
* b.showA(this);
* }
* }
*
* class B {
* public void showA(A a){
* a.method1();
* }
* }
*
* 我們主要來看一下在類A中，方法method1和方法method2的差別在哪裡，方法method1很簡單，就是列印出一句“我是A”；
* 方法method2稍微複雜一點，使用類B作為參數，并調用類B的showA方法。再來看一下類B的showA方法，showA方法使用類A作為參數，
* 然後調用類A的method1方法，可以看到，method2方法繞來繞去，無非就是調用了一下自己的method1方法而已，它的運作結果應該也是“我是A”，
* 分析完之後，我們來運作一下這兩個方法，并看一下運作結果：
* [java] view plain copy
*
* public class Test {
* public static void main(String[] args){
* A a = new A();
* a.method1();
* a.method2(new B());
* }
* }
*
* 運作結果為：
*
* 我是A
* 我是A
*
* 看懂了這個例子，就了解了通路者模式的90%，在例子中，對于類A來說，類B就是一個通路者。但是這個例子并不是通路者模式的全部，
* 雖然直覺，但是它的可擴充性比較差，下面我們就來說一下通路者模式的通用實作，通過類圖可以看到，在通路者模式中
*/
/**
* 通路者模式
* 員工特質:抽象元素類
* Created by ctao on 2015/9/2.
*/
trait Employee {
/**
* 接受一個抽象的通路者
* @param handler 抽象通路者
*/
def accept(handler: Department)
}
/**
* 正式員工：具體元素類
* @param name 姓名
* @param weeklyWage 周薪
* @param workTime 工作時間
*/
case class FullTimeEmployee(name: String, weeklyWage: Double, workTime: Int) extends Employee {
override def accept(handler: Department): Unit = handler.visit(this)
}
/**
* 兼職員工：具體元素類
* @param name 姓名
* @param hourWage 時薪
* @param workTime 工作時間
*/
case class PartTimeEmployee(name: String, hourWage: Double, workTime: Int) extends Employee {
override def accept(handler: Department): Unit = handler.visit(this)
}
/**
* 部門特質，抽象通路者特質
*/
trait Department {
/**
* 通路正式員工
* @param employee 正式員工
*/
def visit(employee: FullTimeEmployee): Unit
/**
* 通路兼職員工
* @param employee 兼職員工
*/
def visit(employee: PartTimeEmployee): Unit
}
/**
* 财務部，具體通路者類
*/
class FADepartment extends Department {
override def visit(employee: FullTimeEmployee): Unit = {
var weekWage = employee.weeklyWage
val workTime = employee.workTime
workTime match {
case x if x >= 40 => weekWage = weekWage + (workTime - 40) * 100
case x if x < 40 => weekWage = weekWage - (40 - workTime) * 80
if (weekWage < 0) {
weekWage = 0
}
}
println(s"正式員工${employee.name}實際工資為${weekWage}元")
}
override def visit(employee: PartTimeEmployee): Unit = {
val workTime = employee.workTime
println(s"兼職員工${employee.name}實際工資為${employee.hourWage * workTime}元")
}
}
/**
* 人力資源部，具體通路者
*/
class HRDepartment extends Department {
override def visit(employee: FullTimeEmployee): Unit = {
val workTime = employee.workTime
println(s"正式員工${employee.name}實際上班時間為${workTime}小時")
workTime match {
case x if x >= 40 => println(s"正式員工${employee.name}加班時間為${workTime - 40}")
case x if x < 40 => println(s"正式員工${employee.name}請假時間為${40 - workTime}")
}
}
override def visit(employee: PartTimeEmployee): Unit =
println(s"兼職員工${employee.name}實際上班時間為${employee.workTime}")
}
/**
* 員工清單類，對象結構
*/
class EmployeeArray {
private var employees = new ArrayBuffer[Employee]()
/**
* 添加員工
* @param employee 員工
*/
def addEmployee(employee: Employee) = employee match {
case e if employees.exists(e.eq(_)) => println("已經添加")
case _ => employees += employee
}
/**
* 通路
* @param department 部門
*/
def accept(department: Department) = employees.foreach(_.accept(department))
}
object md23Visitor extends App{
val fte1: Employee = FullTimeEmployee("a", 500, 40)
val fte2: Employee = FullTimeEmployee("b", 600, 38)
val fte3: Employee = FullTimeEmployee("c", 550, 44)
val fte4: Employee = PartTimeEmployee("d", 15, 33)
val fte5: Employee = PartTimeEmployee("e", 17, 20)
val employeeBuffer = new EmployeeArray
/**
* 添加員工
*/
employeeBuffer.addEmployee(fte1)
employeeBuffer.addEmployee(fte1)
employeeBuffer.addEmployee(fte2)
employeeBuffer.addEmployee(fte3)
employeeBuffer.addEmployee(fte4)
employeeBuffer.addEmployee(fte5)
/**
* 部門
*/
val dep: Department = new HRDepartment
/**
* 通路
*/
employeeBuffer.accept(dep)
}
![Android config.gradle[圖]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)