最近在学安卓的过程中发现了这么一个业务场景，现有一抽象类BaseFragment与三个子类（BluetoothManage、ControlCentral、WifiManage）。

public abstract class BaseFragment extends Fragment {
    private Context mContext;

    protected Handler wifiManageHandler = new Handler(){
        @Override
        public void handleMessage(@NonNull Message msg) {
            super.handleMessage(msg);
            handleMsg(msg);
        }
    };
    protected Handler controlCentralHandler = new Handler(){
        @Override
        public void handleMessage(@NonNull Message msg) {
            super.handleMessage(msg);
            handleMsg(msg);
        }
    };

    //消息处理
    abstract void handleMsg(@Nullable Message msg);

    @Override
    public void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mContext = getContext();
    }
}

        需要使用Handler进行子类之间的消息传递，由各个子类分别重写handleMsg方法，即各自实现消息处理，比如在WifiManage类中调用父类的controlCentralHandler 发送消息时，实际处理消息的并非ControlCentral 类重写的handleMsg方法，而是指向父类的handleMsg方法，造成一种重写方法失效的假象，这是因为每个子类在初始化时都会对父类进行初始化，即WifiManage类与ControlCentral类所持有的父类对象并非同一实例，因而各自重写的handleMsg方法并不互通。

public class WifiManage extends BaseFragment {
    public WifiManage() {
        // Required empty public constructor
    }
    public static WifiManage newInstance() {
        WifiManage fragment = new WifiManage();
        return fragment;
    }

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


    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
                             Bundle savedInstanceState) {
        View v = inflater.inflate(R.layout.fragment_wifi_manage, container, false);
        return v;
    }

    @Override
    public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
        super.onViewCreated(view, savedInstanceState);
        super.controlCentralHandler.sendEmptyMessage(9);
    }

    @Override
    public void onActivityResult(int requestCode, int resultCode, @Nullable Intent data)         
    {
        super.onActivityResult(requestCode, resultCode, data);
    }

    @Override
    public void onDestroy() {
        super.onDestroy(); 

    }

    @Override
    void handleMsg(@Nullable Message msg) {
        
    }
}

public class ControlCentral extends BaseFragment {
    public ControlCentral() {
    }

    public static ControlCentral newInstance() {
        ControlCentral fragment = new ControlCentral();
        return fragment;
    }

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

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
                             Bundle savedInstanceState) {
        View v = inflater.inflate(R.layout.fragment_control_central, container, false);
        return v;
    }

    @Override
    public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
        super.onViewCreated(view, savedInstanceState);
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
     
    }

    @Override
    void handleMsg(@Nullable Message msg) {
        if (msg.what == 9 ){
            Log.e("TAG","收到消息了");
        }
    }
}

        我采用的解决办法是使用单例模式，因为这里不能使不同的子类在实例化时拿到的是同一个父类实例（至少我没有想到解决方法），因而可以将所有handler共同放在一个工具类中，该工具类的设计采用单例模式，即可解决该问题。

public class HandlerUtils{
    private static HandlerUtils handlerUtils;
    private HandlerCallBack handlerCallBack,wifiManageHandlerCallBack,controlCentralHandlerCallBack,bluetoothManageHandlerCallBack;//处理回调
    private Handler mHandler = new Handler(Looper.getMainLooper()) {
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            handlerCallBack.handleMessage(msg);
        }
    };
    protected Handler wifiManageHandler = new Handler(Looper.getMainLooper()){
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            wifiManageHandlerCallBack.handleMessage(msg);
        }
    };


    protected Handler controlCentralHandler = new Handler(Looper.getMainLooper()){
        @Override
        public void handleMessage(@NonNull Message msg) {
            super.handleMessage(msg);
            controlCentralHandlerCallBack.handleMessage(msg);
        }
    };

    protected Handler bluetoothManageHandler = new Handler(Looper.getMainLooper()){
        @Override
        public void handleMessage(@NonNull Message msg) {
            super.handleMessage(msg);
            bluetoothManageHandlerCallBack.handleMessage(msg);
        }
    };


    public static synchronized HandlerUtils getInstance(){
        if (handlerUtils == null){
            handlerUtils = new HandlerUtils();
        }
        return handlerUtils;
    }

    public HandlerCallBack getHandlerCallBack() {
        return handlerCallBack;
    }

    public void setHandlerCallBack(HandlerCallBack handlerCallBack) {
        this.handlerCallBack = handlerCallBack;
    }

    public HandlerCallBack getWifiManageHandlerCallBack() {
        return wifiManageHandlerCallBack;
    }

    public void setWifiManageHandlerCallBack(HandlerCallBack wifiManageHandlerCallBack) {
        this.wifiManageHandlerCallBack = wifiManageHandlerCallBack;
    }

    public HandlerCallBack getControlCentralHandlerCallBack() {
        return controlCentralHandlerCallBack;
    }

    public void setControlCentralHandlerCallBack(HandlerCallBack controlCentralHandlerCallBack) {
        this.controlCentralHandlerCallBack = controlCentralHandlerCallBack;
    }

    public HandlerCallBack getBluetoothManageHandlerCallBack() {
        return bluetoothManageHandlerCallBack;
    }

    public void setBluetoothManageHandlerCallBack(HandlerCallBack bluetoothManageHandlerCallBack) {
        this.bluetoothManageHandlerCallBack = bluetoothManageHandlerCallBack;
    }

    public Handler getHandler() {
        return mHandler;
    }

    public Handler getWifiManageHandler() {
        return wifiManageHandler;
    }

    public Handler getControlCentralHandler() {
        return controlCentralHandler;
    }

    public Handler getBluetoothManageHandler() {
        return bluetoothManageHandler;
    }
}

版权声明：博主原创/资料整理，转载请注明出处！！

写一个父类，里面有两个方法，doing ()和talking()，并在doing ()方法中调用talking()方法。代码如下：

public class Father {
    public void doing (){
        talking();
    }
    public void talking(){
        System.out.println("father is watching TV!");
    }
}

写一个子类来继承父类，重写doing ()和talking()方法。代码如下：

public class Son extends Father {
    public static void main(String[] args) {
        Father father = new Father();
        father.doing();
        Son son = new Son();
        son.doing();
    }
    @Override
    public void doing(){
        talking();
    }
    @Override
    public void talking(){
        System.out.println("Son is watching TV!");
    }
}

此时结果是：

father is watching TV!
Son is watching TV!

若子类代码改动如下所示：

public class Son extends Father {
    public static void main(String[] args) {
        Father father = new Son();
        father.doing();
        Son son = new Son();
        son.doing();
    }
    @Override
    public void doing(){
        talking();
    }
    @Override
    public void talking(){
        System.out.println("Son is watching TV!");
    }
}

此时结果是：

Son is watching TV!
Son is watching TV!

因此可见：
1. 子类中，父类实例化父类对象，调用父类中的方法。
2. 子类中，子类实例化父类对象，调用子类中的方法。
3. 子类中，子类实例化子类对象，调用子类中的方法。