保存对象Android不工作

onRestoreInstanceState（捆绑包savedInstanceState）

没有调用geting，我正在将代码粘贴到下面。实际上，我想重新绘制在后台进行活动时保存的所有点

    package com.geniteam.mytest;

import java.util.ArrayList;

import android.app.Activity;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Color;
import android.os.Bundle;
import android.view.MotionEvent;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
import android.view.Window;

public class Tutorial2D extends Activity {
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        requestWindowFeature(Window.FEATURE_NO_TITLE);
        setContentView(new Panel(this));
    }
    @Override
    protected void onSaveInstanceState(Bundle outState) {     
     super.onSaveInstanceState(outState);
     Panel panel = new Panel(this);
     outState.putSerializable("test", panel._graphics);     

    }
    @Override
    protected void onRestoreInstanceState(Bundle savedInstanceState) {     
     super.onRestoreInstanceState(savedInstanceState);
     Panel panel = new Panel(this);
     panel.set_graphics((ArrayList<GraphicObject>) savedInstanceState.getSerializable("test"));     
    }

    class Panel extends SurfaceView implements SurfaceHolder.Callback {
        private TutorialThread _thread;        
        private ArrayList<GraphicObject> _graphics = new ArrayList<GraphicObject>();

        public ArrayList<GraphicObject> get_graphics() {
   return _graphics;   
  }

  public void set_graphics(ArrayList<GraphicObject> graphics) {
   _graphics = graphics;
  }

  public Panel(Context context) {
            super(context);
            getHolder().addCallback(this);
            _thread = new TutorialThread(getHolder(), this);
            setFocusable(true);
        }

        @Override
        public boolean onTouchEvent(MotionEvent event) {
            synchronized (_thread.getSurfaceHolder()) {
               // if (event.getAction() == MotionEvent.ACTION_DOWN) {
                    GraphicObject graphic = new GraphicObject(BitmapFactory.decodeResource(getResources(), R.drawable.icon));
                    graphic.getCoordinates().setX((int) event.getX() - graphic.getGraphic().getWidth() / 2);
                    graphic.getCoordinates().setY((int) event.getY() - graphic.getGraphic().getHeight() / 2);
                    _graphics.add(graphic);
                //}
                return true;
            }
        }

        @Override
        public void onDraw(Canvas canvas) {
            canvas.drawColor(Color.BLACK);
            Bitmap bitmap;
            GraphicObject.Coordinates coords;
            for (GraphicObject graphic : _graphics) {
                bitmap = graphic.getGraphic();
                coords = graphic.getCoordinates();
                canvas.drawBitmap(bitmap, coords.getX(), coords.getY(), null);
            }
        }

        public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
            // TODO Auto-generated method stub
        }


        public void surfaceCreated(SurfaceHolder holder) {
            try{
         _thread.setRunning(true);
            _thread.start();
            }catch(Exception ex){
             _thread = new TutorialThread(getHolder(), this);
             _thread.start();
            }

        }


        public void surfaceDestroyed(SurfaceHolder holder) {
            // simply copied from sample application LunarLander:
            // we have to tell thread to shut down & wait for it to finish, or else
            // it might touch the Surface after we return and explode
            boolean retry = true;
            _thread.setRunning(false);
            while (retry) {
                try {
                    _thread.join();
                    retry = false;
                } catch (InterruptedException e) {
                    // we will try it again and again...
                }
            }
        }
    }

    class TutorialThread extends Thread {
        private SurfaceHolder _surfaceHolder;
        private Panel _panel;
        private boolean _run = false;

        public TutorialThread(SurfaceHolder surfaceHolder, Panel panel) {
            _surfaceHolder = surfaceHolder;
            _panel = panel;
        }

        public void setRunning(boolean run) {
            _run = run;
        }

        public SurfaceHolder getSurfaceHolder() {
            return _surfaceHolder;
        }

        @Override
        public void run() {
            Canvas c;
            while (_run) {
                c = null;
                try {
                    c = _surfaceHolder.lockCanvas(null);
                    synchronized (_surfaceHolder) {
                        _panel.onDraw(c);
                    }
                } finally {
                    // do this in a finally so that if an exception is thrown
                    // during the above, we don't leave the Surface in an
                    // inconsistent state
                    if (c != null) {
                        _surfaceHolder.unlockCanvasAndPost(c);
                    }
                }
            }
        }
    }

    class GraphicObject {
        /**
         * Contains the coordinates of the graphic.
         */
        public class Coordinates {
            private int _x = 100;
            private int _y = 0;

            public int getX() {
                return _x + _bitmap.getWidth() / 2;
            }

            public void setX(int value) {
                _x = value - _bitmap.getWidth() / 2;
            }

            public int getY() {
                return _y + _bitmap.getHeight() / 2;
            }

            public void setY(int value) {
                _y = value - _bitmap.getHeight() / 2;
            }

            public String toString() {
                return "Coordinates: (" + _x + "/" + _y + ")";
            }
        }

        private Bitmap _bitmap;
        private Coordinates _coordinates;

        public GraphicObject(Bitmap bitmap) {
            _bitmap = bitmap;
            _coordinates = new Coordinates();
        }

        public Bitmap getGraphic() {
            return _bitmap;
        }

        public Coordinates getCoordinates() {
            return _coordinates;
        }
    }
}

package com.geniteam.mytest；
导入java.util.ArrayList；
导入android.app.Activity；
导入android.content.Context；
导入android.graphics.Bitmap；
导入android.graphics.BitmapFactory；
导入android.graphics.Canvas；
导入android.graphics.Color；
导入android.os.Bundle；
导入android.view.MotionEvent；
导入android.view.SurfaceHolder；
导入android.view.SurfaceView；
导入android.view.Window；
公共课堂教程2D扩展活动{
@凌驾
创建时的公共void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
requestWindowFeature（窗口。功能\u无\u标题）；
setContentView（新面板（本））；
}
@凌驾
SaveInstanceState上受保护的无效（束超出状态）{
super.onSaveInstanceState（超出状态）；
面板=新面板（本）；
可串行化（“测试”，面板._图形）；
}
@凌驾
RestoreInstanceState（Bundle savedInstanceState）上受保护的无效项{
super.onRestoreInstanceState（savedInstanceState）；
面板=新面板（本）；
panel.set_graphics（（ArrayList）savedInstanceState.getSerializable（“test”）；
}
类面板扩展了SurfaceView实现了SurfaceHolder.Callback{
私有教程线程_线程；
private ArrayList_graphics=new ArrayList（）；
公共阵列列表get_graphics（）{
返回图形；
}
公共无效集图形（ArrayList图形）{
_图形=图形；
}
公共面板（上下文）{
超级（上下文）；
getHolder（）.addCallback（此）；
_thread=newtutorialthread（getHolder（），this）；
设置聚焦（真）；
}
@凌驾
公共布尔onTouchEvent（运动事件）{
已同步（\u thread.getSurfaceHolder（））{
//if（event.getAction（）==MotionEvent.ACTION\u向下）{
GraphicObject graphic=新的GraphicObject（BitmapFactory.decodeResource（getResources（），R.drawable.icon））；
graphic.getCoordinates（）.setX（（int）event.getX（）-graphic.getGraphic（）.getWidth（）/2）；
graphic.getCoordinates（）.setY（（int）event.getY（）-graphic.getGraphic（）.getHeight（）/2）；
_图形。添加（图形）；
//}
返回true；
}
}
@凌驾
公共空白onDraw（画布）{
画布。drawColor（颜色。黑色）；
位图；
坐标坐标系；
用于（图形对象图形：_图形）{
位图=graphic.getGraphic（）；
coords=graphic.getCoordinates（）；
drawBitmap（位图，coords.getX（），coords.getY（），null）；
}
}
公共空白表面更改（表面文件夹持有者、整型格式、整型宽度、整型高度）{
//TODO自动生成的方法存根
}
已创建的公共空白表面（表面持有人）{
试一试{
_thread.setRunning（true）；
_thread.start（）；
}捕获（例外情况除外）{
_thread=newtutorialthread（getHolder（），this）；
_thread.start（）；
}
}
公共空间表面覆盖（表面覆盖物持有人）{
//仅从示例应用程序LunarLander复制：
//我们必须告诉线程关闭&等待它完成，否则
//它可能会在我们返回并爆炸后接触到表面
布尔重试=真；
_thread.setRunning（false）；
while（重试）{
试一试{
_thread.join（）；
重试=错误；
}捕捉（中断异常e）{
//我们会一次又一次的尝试。。。
}
}
}
}
类TutorialThread扩展线程{
私人表面股东(SurfaceHolder);；
私人事务委员会;；
私有布尔值_run=false；
公共教程线程（SurfaceHolder SurfaceHolder，面板）{
_surfaceHolder=surfaceHolder；
_面板=面板；
}
公共void setRunning（布尔运行）{
_跑=跑；
}
publicssurfaceholder getSurfaceHolder（）{
返回(surfaceHolder);；
}
@凌驾
公开募捐{
帆布c；
while（_run）{
c=零；
试一试{
c=_surfaceHolder.lockCanvas（null）；
已同步（_surfaceHolder）{
_专家组：onDraw（c）；
}
}最后{
//在finally中执行此操作，以便在引发异常时
//在上述过程中，我们不会将曲面保留在
//不一致状态
如果（c！=null）{
_打开CanvasandPost（c）的锁；
}
}
}
}
}
类GraphicObject{
/**
*包含图形的坐标。
*/
公共类坐标{
私有整数x=100；
私有整数_y=0；
公共int getX（）{
返回x+bitmap.getWidth（）/2；
}
公共void setX（int值）{
_x=value-\u bitmap.getWidth（）/2；
}
公共int getY（）{
返回_y+_bitmap.getHeight（）/2；
}
公共void setY（int值）{
_y=value-_bitmap.getHeight（）/2；
}
公共字符串toString（）{
返回“坐标：