步骤1 和步骤2，主要表现接口之间的多态性，指定行为方式。

步骤3：也就是工厂模式的应用，通过类名来确定要实例化的对象。

步骤4：用的是下面的传输对象模式。对实体类集合进行操作，主要是在集合中 获取/添加 实体类对象。

步骤5定位器：使用步骤3来创建实例，使用步骤4来添加到集合，或者从集合中获取。（缓存中没有才会创建） 

步骤6:  调用步骤5得到实体类，并执行实体类的方法

使用 Kotlin 实现 MVC：利用 kotlin 的数据类实现 modal 层，使用标准库函数使结构更加直观。

/**
 * 数据类Modal
 */
data class Student(private var name: String, private var age: Int) {
 
    fun getName(): String = this.name
    fun setName(newName: String) = { name = newName }()
    fun getAge(): Int = this.age
    fun setAge(newAge: Int) = { age = newAge }()
}
 
/**
 * 视图层 View
 */
class View {
 
    fun showView(name: String, age: Int) = println("name:$name,age:$age")
}
 
/**
 * 控制器 Controller
 */
class Controller(private var view: View, private var modal: Student) {
 
    fun setName(newName: String) = modal.setName(newName)
    fun setAge(newAge: Int) = modal.setAge(newAge)
    fun getName(): String = modal.getName()
    fun getAge(): Int = modal.getAge()
    fun updateView() {
        println("更新视图:------------")
        view.showView(modal.getName(), modal.getAge())
    }
 
}
 
/**
 * kotlin MVC模式
 * @author IWH
 * android默认的开发模式就是MVC，activity属于控制器负责XML与Modal的处理
 */
fun main() {
    val view = View()
    val modal = Student("iwh", 20)
    val controller = Controller(view, modal)
    view.showView(controller.getName(), controller.getAge())
    controller.setAge(21)
    controller.setName("jack")
    controller.updateView()
    main2()
 
 
}
 
/**
 * 使用kotlin特性
 */
fun main2() {
    View().apply outer@{
        Student("iwh", 20).apply inner@{
            with(Controller(this@outer, this@inner)) last@{
                this@outer.showView(this.getName(), this.getAge())
                setName("jack")
                setAge(21)
                updateView()
            }
        }
    }
}

状态模式的类图和策略模式类似，并且都是能够动态改变对象的行为。但是状态模式是通过状态转移来改变 Context 所组合的 State 对象，而策略模式是通过 Context 本身的决策来改变组合的 Strategy 对象。所谓的状态转移，是指 Context 在运行过程中由于一些条件发生改变而使得 State 对象发生改变，注意必须要是在运行过程中。

状态模式主要是用来解决状态转移的问题，当状态发生转移了，那么 Context 对象就会改变它的行为；而策略模式主要是用来封装一组可以互相替代的算法族，并且可以根据需要动态地去替换 Context 使用的算法。

观音洒水

public class TortoisObserverDemo {
    public static void main(String[] args){
        GuanYin guanYin = new GuanYin();

        new SmallTortoise(guanYin);
        new BigTortoise(guanYin);

        guanYin.watering();
    }
}



public class GuanYin {
    private List<Observer> observers = new ArrayList<Observer>();

    public void watering(){
        System.out.println("观音洒水");
        notifyAllTortoise();
    }

    private void notifyAllTortoise() {
        int i = 0;
        for (Observer o:observers) {
            o.flyToGuanYin();
            System.out.println(++i);
        }
    }

    public void attach(Observer observer) {
        observers.add(observer);
    }
}


public abstract class Observer {
    protected GuanYin guanYin;
    protected abstract void flyToGuanYin();
}



public class SmallTortoise extends Observer {

    public SmallTortoise(GuanYin guanYin) {
        this.guanYin = guanYin;
        this.guanYin.attach(this);
    }

    @Override
    protected void flyToGuanYin() {
        System.out.println("SmallTortoise fly to guanyin");
    }
}




public class BigTortoise extends Observer {

    public BigTortoise(GuanYin guanYin) {
        this.guanYin = guanYin;
        this.guanYin.attach(this);
    }

    @Override
    protected void flyToGuanYin() {
        System.out.println("BigTortoise fly to guanyin");
    }
}

看了上面的代码，用 kotlin 实现了一下：

/**
 * 观察者
 */
interface Observer {
    fun <T : Any?> update(msg: T)
}
 
/**
 * 观察者1,2,3
 */
class Ob1(private val id: Int = 0) : Observer {
    override fun <T> update(msg: T) {
        println("接收消息，观察者$id:$msg")
    }
}
//这里是kotlin的类委托
class Ob2 : Observer by Ob1(2)
class Ob3 : Observer by Ob1(3)
 
/**
 * 被观察者（订阅者）
 */
class Subject {
 
    //存放观察者
    private  var observers =  ArrayList<Observer>()
    //订阅观察者
    fun attach(ob: Observer) {
        observers.add(ob)
    }
    //设置数据
    fun <T : Any?> setMsg(msg: T) {
        this.notify(msg)
    }
    //更新数据
    private fun <T : Any?> notify(msg: T) {
        for (iOb in this.observers) {
            iOb.update(msg)
        }
    }
}
 
/**
 * Kotlin版 观察者模式
 * @author IWH
 * Des：kotlin1.3支持主函数省略参数
 */
fun main() {
 
    val sub = Subject().apply {
        attach(Ob1())
        attach(Ob2())
        attach(Ob3())
    }
    with(sub){
        setMsg(123)
        setMsg("hello world")
        setMsg('A')
        setMsg(null)
    }
}