static 关键字 乱用的后果

static 关键字，一般用来减少对象的实例化，减少内存空间，因为，它不需要new一个对象即可以直接使用…有时候，我们为了方便外部调用内部类以及成员变量，所以将相应的方法和字段声明为static，这在外部库中使用较多，以及一些公共接口中使用较多.
在前面的android开发中，由于乱用static关键字，导致了未知的后果，页面效果和功能一直没有出来，所以，做个笔记，告诫自己…
功能实例如下：

 class MyTaskShowAdapter extends FragmentStatePagerAdapter{

        MyTaskShowAdapter(FragmentManager fm){
            super(fm);
        }

        @Override
        public Fragment getItem(int position)
        {
            TaskShowFragment fragment = TaskShowFragment.newInstance(taskList.get(position).getTaskID());
            return fragment;
        }

        @Override
        public int getCount() {
            return taskList.size();
        }

        @Override
        public int getItemPosition(Object object) {
           // return super.getItemPosition(object);
            return POSITION_NONE;
        }
    }

由一个FragmentStatePagerAdapter，实例化多个碎片布局，然后，进入某一个碎片中进行操作，我这里主要是进行更新适配器操作：
声明一些变量（当时设成static了，主要是预防内存泄露【使用了Handler来更新..】）
如：

private  static MessageAdapter adapter;
public  static int task_id;
private static int sTask_id;

TaskShowFragment中有一个更新适配器的操作：

public void updateFragmentAdapter(final int flag, final Task_Message message,int taskID)
    {
       // LogUtil.info("after==task_id=="+taskID+"==="+taskinfo.getTaskID());
        if(taskID == taskinfo.getTaskID())
        {
            static class MyHandler extends Handler
            {
                WeakReference<TaskShowFragment> taskShowFragment;
                public MyHandler(TaskShowFragment task){
                    taskShowFragment = new WeakReference<>(task);
                }
                @Override
                public void handleMessage(Message msg)
                {
                    switch (msg.what) {
                        case 1001: // 发送消息
                            Task_Message smessage = (Task_Message) msg.obj;
                            adapter.addOneMessage(smessage);
                            break;
                        case 2001: // 接收消息
                            Task_Message rmessage = (Task_Message) msg.obj;
                            adapter.addOneMessage(rmessage);
                            break;
                    }
                }
            }
            MyHandler myHandler = new MyHandler(TaskShowFragment.this);
            Message msg = Message.obtain();
            msg.what = flag;
            msg.obj = message;
            myHandler.sendMessage(msg);
        }
    }

这样的处理造成的后果是：
1 在特定的碎片中进行更新适配器操作，会造成适配器不是当前碎片中的适配器更新
分析原因： 将MessageAdapter声明成了静态，所以，每次都只实例化一次对象，所以，每次的更新都是在第一个实例化的adapter中去了….
2 更新的内容没有插入到当前任务中的数据库中
分析原因：同上…

修改后：

private MessageAdapter adapter;
public int task_id;
private int sTask_id;
public void updateFragmentAdapter(final int flag, final Task_Message message,int taskID)
    {
       // LogUtil.info("after==task_id=="+taskID+"==="+taskinfo.getTaskID());
        if(taskID == taskinfo.getTaskID())
        {
             class MyHandler extends Handler
            {
                WeakReference<TaskShowFragment> taskShowFragment;
                public MyHandler(TaskShowFragment task){
                    taskShowFragment = new WeakReference<>(task);
                }
                @Override
                public void handleMessage(Message msg)
                {
                    switch (msg.what) {
                        case 1001: // 发送消息
                            Task_Message smessage = (Task_Message) msg.obj;
                            adapter.addOneMessage(smessage);
                            break;
                        case 2001: // 接收消息
                            Task_Message rmessage = (Task_Message) msg.obj;
                            adapter.addOneMessage(rmessage);
                            break;
                    }
                }
            }
            MyHandler myHandler = new MyHandler(TaskShowFragment.this);
            Message msg = Message.obtain();
            msg.what = flag;
            msg.obj = message;
            myHandler.sendMessage(msg);
        }
    }

总结：
static 关键字，虽然我们都知道它的书面定义，平时也有实践，但是由于没有真正的理解或者是没有应用到适应的场景，反而会造成适得其反的效果… 编码其实有时候，就在一些小点上出问题了，所以，告诫自己…下次别犯这么低级的错误，找到问题，解决问题….别急躁，加油！！