//本文参考菜鸟教程
设计模式主要分为三大类创建型模式，结构型模式，行为型模式，本文主要讲行为型模式
行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。
1.策略模式
定义：一个类的行为或其算法可以在运行时更改。这种类型的设计模式属于行为型模式。
interface Strategy{
fun operation(num:Int,num2:Int):Int
}
class AddStrategyImpl:Strategy{
override fun operation(num: Int, num2: Int) = num + num2
}
class RemoveStrategyImpl:Strategy{
override fun operation(num: Int, num2: Int) = num - num2
}
class StrategyImpl(private var strategy: Strategy){
fun doStrategy(num: Int,num2: Int){
strategy.operation(num,num2)
}
}
2.模版模式
定义：一个抽象类公开定义了执行它的方法的方式/模板。它的子类可以按需要重写方法实现
abstract class Temple {
abstract fun one()
abstract fun two()
abstract fun three()
fun dayDo() {
one()
two()
three()
}
}
class TempleTest : Temple() {
override fun one() {
println("1")
}
override fun two() {
println("2")
}
override fun three() {
println("3")
}
}
3.观察者模式
定义：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。
interface Subject{
fun registerObserver(o:Observer)
fun removeObserver(o:Observer)
fun notifyObserver()
}
interface Observer{
fun update(message:String)
}
class WechatServer:Subject{
var list = mutableListOf<Observer>()
var message:String = ""
override fun registerObserver(o: Observer) {
list.add(o)
}
override fun removeObserver(o: Observer) {
if(list.isNotEmpty()){
list.remove(o)
}
}
override fun notifyObserver() {
list.forEach {
it.update(message)
}
}
fun setInfo(){
println("观测者")
message = "粗发事件"
notifyObserver()
}
}
class ObserverUser(val name:String):Observer{
private var message: String = ""
override fun update(message: String) {
this.message = message
readMessage()
}
fun readMessage(){
println("获取到消息")
}
}
fun main() {
val server = WechatServer()
val userLi = ObserverUser("li")
server.registerObserver(userLi)
server.setInfo()
}
4.迭代器模式
定义：提供一种方法顺序访问一个聚合对象中各个元素, 而又无须暴露该对象的内部表示
参考java的iterator
5.责任链模式
定义：如果有多个对象有机会处理请求，责任链可使请求的发送者和接受者解耦，请求沿着责任链传递，直到有一个对象处理了它为止。
abstract class AbstractLogger {
companion object {
val INFO = 1
val DEBUG = 2
val ERROR = 3
}
private var level: Int = 0
var nextLogger: AbstractLogger? = null
fun logMessage(level: Int, message: String) {
if (this.level <= level) {
write(message)
}
nextLogger?.logMessage(level, message)
}
protected abstract fun write(message: String)
}
class ConsoleLogger(level: Int) : AbstractLogger() {
override fun write(message: String) {
println("stand console::logger$message")
}
}
class ErrorLogger(level: Int) : AbstractLogger() {
override fun write(message: String) {
println("error console::logger$message")
}
}
class FileLogger(level: Int) : AbstractLogger() {
override fun write(message: String) {
println("File console::logger$message")
}
}
object ChainTest {
fun getChainOfLoggers(): AbstractLogger {
val errorLogger: AbstractLogger = ErrorLogger(AbstractLogger.ERROR)
val fileLogger: AbstractLogger = FileLogger(AbstractLogger.DEBUG)
val consoleLogger: AbstractLogger = ConsoleLogger(AbstractLogger.INFO)
errorLogger.nextLogger = fileLogger
fileLogger.nextLogger = consoleLogger
return errorLogger
}
}
fun main() {
val loggerChain: AbstractLogger = getChainOfLoggers()
loggerChain.logMessage(AbstractLogger.INFO, "This is an information.")
loggerChain.logMessage(
AbstractLogger.DEBUG,
"This is a debug level information."
)
loggerChain.logMessage(
AbstractLogger.ERROR,
"This is an error information."
)
}
6.命令模式
定义：将一个请求封装为一个对象，使发出请求的责任和执行请求的责任分割开。这样两者之间通过命令对象进行沟通，这样方便将命令对象进行储存、传递、调用、增加与管理。
interface Order{
fun execute()
}
class Stock{
val name = "ABC"
val quantity = 10
fun buy(){
println("bubbly")
}
fun sell(){
println("sell")
}
}
class SellStock(private val stock: Stock):Order{
override fun execute() {
stock.sell()
}
}
class BuyStock(private val stock: Stock):Order{
override fun execute() {
stock.buy()
}
}
class Broker {
private val orderList: MutableList<Order> = ArrayList()
fun takeOrder(order: Order) {
orderList.add(order)
}
fun placeOrders() {
for (order in orderList) {
order.execute()
}
orderList.clear()
}
}
fun main() {
val abcStock = Stock()
val buyStockOrder = BuyStock(abcStock)
val sellStockOrder = SellStock(abcStock)
val broker = Broker()
broker.takeOrder(buyStockOrder)
broker.takeOrder(sellStockOrder)
broker.placeOrders()
}
7.状态模式
定义：在状态模式中，我们创建表示各种状态的对象和一个行为随着状态对象改变而改变的 context 对象。
data class StateContext(var state: State? = null)
interface State{
fun doAction(context: StateContext)
}
class StartState:State{
override fun doAction(context: StateContext) {
println("is start state")
context.state = this
}
override fun toString(): String {
return "Start state"
}
}
class StopState:State{
override fun doAction(context: StateContext) {
println("is stop state")
context.state = this
}
override fun toString(): String {
return "stop state"
}
}
fun main() {
val context = StateContext()
val startState = StartState()
startState.doAction(context)
println(context.state.toString())
val stopState = StopState()
stopState.doAction(context)
println(context.state.toString())
}
8.备忘录模式
定义： 在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，以便以后当需要时能将该对象恢复到原先保存的状态。该模式又叫快照模式
data class MementoTest(var state:String)
class Originator{
var state:String = ""
fun saveStateToMemento():MementoTest = MementoTest(state)
fun getStateFromMemento(mementoTest: MementoTest){
state = mementoTest.state
}
}
class CareTaker {
private val mementoList: MutableList<MementoTest> = ArrayList<MementoTest>()
fun add(state: MementoTest) {
mementoList.add(state)
}
operator fun get(index: Int): MementoTest {
return mementoList[index]
}
}
fun main() {
val originator = Originator()
val careTaker = CareTaker()
originator.state = "State #1"
originator.state = "State #2"
careTaker.add(originator.saveStateToMemento())
originator.state = "State #3"
careTaker.add(originator.saveStateToMemento())
originator.state = "State #4"
println("Current State: " + originator.state)
originator.getStateFromMemento(careTaker[0])
println("First saved State: " + originator.state)
originator.getStateFromMemento(careTaker[1])
println("Second saved State: " + originator.state)
}
9.访问者模式
定义：我们使用了一个访问者类，它改变了元素类的执行算法。通过这种方式，元素的执行算法可以随着访问者改变而改变。这种类型的设计模式属于行为型模式。根据模式，元素对象已接受访问者对象，这样访问者对象就可以处理元素对象上的操作。
class VisitorTest {
interface ComputerPart{
fun accept(computerPartVisitor: ComputerPartVisitor)
}
interface ComputerPartVisitor {
fun visit(computer: Computer?)
fun visit(mouse: Mouse?)
fun visit(keyboard: Keyboard?)
fun visit(monitor: Monitor?)
}
class Keyboard:ComputerPart{
override fun accept(computerPartVisitor: ComputerPartVisitor) {
computerPartVisitor.visit(this)
}
}
class Mouse:ComputerPart{
override fun accept(computerPartVisitor: ComputerPartVisitor) {
computerPartVisitor.visit(this)
}
}
class Monitor:ComputerPart{
override fun accept(computerPartVisitor: ComputerPartVisitor) {
computerPartVisitor.visit(this)
}
}
class Computer : ComputerPart {
private var parts: Array<ComputerPart> = arrayOf(Mouse(), Keyboard(), Monitor())
override fun accept(computerPartVisitor: ComputerPartVisitor) {
for (i in parts.indices) {
parts[i].accept(computerPartVisitor)
}
computerPartVisitor.visit(this)
}
}
class ComputerPartDisplayVisitor : ComputerPartVisitor {
override fun visit(computer: Computer?) {
println("Displaying Computer.")
}
override fun visit(mouse: Mouse?) {
println("Displaying Mouse.")
}
override fun visit(keyboard: Keyboard?) {
println("Displaying Keyboard.")
}
override fun visit(monitor: Monitor?) {
println("Displaying Monitor.")
}
}
}
fun main() {
val computer: ComputerPart = VisitorTest.Computer()
computer.accept(ComputerPartDisplayVisitor())
}
10.中介者模式
定义：是用来降低多个对象和类之间的通信复杂性。这种模式提供了一个中介类，该类通常处理不同类之间的通信，并支持松耦合，使代码易于维护。
class MediatorTest {
object ChatRoom {
fun showMessage(user: User, message: String) {
println(
Date().toString()
.toString() + " [" + user.name + "] : " + message
)
}
}
class User(var name: String) {
fun sendMessage(message: String) {
ChatRoom.showMessage(this, message)
}
}
}
fun main() {
val robert = User("Robert")
val john = User("John")
robert.sendMessage("Hi! John!")
john.sendMessage("Hello! Robert!")
}
