回调与观察者模式的实现原理

回调与观察者模式的实现原理：

• 废话不多说，直接上Demo回调的原理：

• 观察者模式：

A类中定义一个被观察者画家

package com.example.view;

import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.view.View;

import java.util.ArrayList;

/**
 * user: uidq0530 ,date: 2017-03-29.
 * description：
 *
 * @author xhunmon
 */
public class A extends View {

    private Paint mPaint;

    public A(Context context) {
        super(context);
        mPaint = new Paint();
    }

    //1.进来的人给了一张座子
    public interface OnAListener{
        //可以看画家绘制
        void look();
    }

    //2.一个房间
    private ArrayList<OnAListener> lists = new ArrayList<>();

    //3.进入房间的通道
    public void register(OnAListener listener){
        lists.add(listener);
    }

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        canvas.drawText("画家画画", 50, 50, mPaint);

        //4.只有房间的人能看画家绘制
        for(int i=0 ;i<lists.size(); i++){
            lists.get(i).look();
        }
    }

    //5.出去房间的通道
    public void unregister(OnAListener listener){
        if(lists.contains(listener))
            lists.remove(listener);
    }
}

B类中是观察者人，人可以有很多个，但是画家只能有一个

package com.example.test3;

import android.app.Activity;
import android.os.Bundle;
import android.widget.Toast;

import com.example.view.A;
/**
 * user: uidq0530 ,date: 2017-03-29.
 * description：
 *
 * @author xhunmon
 */
public class B extends Activity {

    private A.OnAListener mListener;
    private A mA;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        mA = new A(this);
        //1.创建一个人
        mListener = new A.OnAListener() {

            //3.当进入房间之后，人才能看到画家绘制
            @Override
            public void look() {
                Toast.makeText(B.this, "我注册了，就可以监听A中画家是否在绘制了", Toast.LENGTH_SHORT).show();
            }
        };
        //2.进入房间
        mA.register(mListener);

        setContentView(mA);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        //4.出去房间
        if(mListener != null)
            mA.unregister(mListener);
    }
}

总结：最常见的观察者是广播，而观察者的本质就是回调，所以实现观察者的其实就是一堆回调。