添加自己的接口后,Java会抛出NotSerializableException

人们,我正在坚持我正在开发的新 Android应用程序.对于应用程序(纸牌游戏),我需要保存一些数据.我使用序列化来完成这项工作.

现在的问题是：
当我尝试实现一个用于跟踪付款人转向的界面时,应用程序从类Game(主要活动)返回NoSerializableException.当我删除界面时,每件事都有效.

转弯类包含以下代码：

public class Turn<T> implements Serializable{

/**
 * 
 */
private static final long serialVersionUID = 1L;

public interface OnTurnEndedListener<T>{
    void onTurnEnded(T currentPlayer);
}

private ArrayList<T> players;
private int turnIndex;
private int rounds;
private ArrayList<OnTurnEndedListener<T>> turnEndListenerList;

public Turn() {
    throw new UnsupportedOperationException("cannot init without players");
}

public Turn(ArrayList<T> players,int startingPlayerIndex) {
    this.players = players;
    this.turnIndex = startingPlayerIndex;
    this.rounds = 0;
    turnEndListenerList = new ArrayList<OnTurnEndedListener<T>>();
}

public int getRounds() {
    return rounds;
}

public T next() {
    turnIndex = (turnIndex + 1) % players.size();
    if (turnIndex == 0) {
        rounds++;
    }
    T retVal = players.get(turnIndex);
    for (OnTurnEndedListener<T> l : turnEndListenerList) {
        l.onTurnEnded(retVal);
    }
    return retVal;
}

public T peek() {
    return players.get(turnIndex);
}

public void addOnTurnEndedListener(OnTurnEndedListener<T> l) {
    this.turnEndListenerList.add(l);

}
}

当我在主要活动(游戏)中添加以下代码时,每次关闭活动时都会收到异常.

gameData.getTurn().addOnTurnEndedListener(new Turn.OnTurnEndedListener<Hand>() {
            @Override
            public void onTurnEnded(Hand hand) {
                turnEndedHandler(hand);
            }
        });

您可以找到Game和GameData类的完整代码,以及下面的错误日志.

import java.util.ArrayList;
import java.util.Collections;

import android.app.Activity;
import android.content.Intent;
import android.content.res.Configuration;
import android.os.Bundle;
import android.util.Log;
import android.view.Gravity;
import android.view.MotionEvent;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.View.OnTouchListener;
import android.view.ViewGroup.LayoutParams;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.TextView;
import android.widget.Toast;

public class Game extends Activity implements OnTouchListener{

    private Deck deck;
    private GameData gameData;
    Hand playerHand,oppHand;
    private ImageView ivDeckClosed,ivDeckOpen,ivPlayerCard1,ivPlayerCard2,ivPlayerCard3,ivPlayerCard4,ivPlayerCard5,ivPlayerCard6,ivPlayerCard7,ivPlayerCard8,ivPlayerCard9,ivPlayerCard10,ivPlayerCard11,ivPlayerCard12,ivPlayerCard13,ivPlayerCard14;
    private ImageView[] playerCards;
    private TextView tvOpp1;
    private ArrayList<Hand> playersInOrder;
    private LinearLayout llPlayGround,llPlayGroundRow1,llPlayGroundRow2,llCardDeck;
    private ArrayList<PlayedSet> playedSets;
    public static final String SAVE_FILENAME = "jokerensave.ser";
    private SaveHandler savehandler;
    private Hand currentHand;
    private int defaultStartingPlayer = 0;

    public static enum STATES {
        start,resume,end
    };

    public static final int START_CODE = 0;
    public static final int RESUME_CODE = 1;
    public static final String GAME_STATE = "STATE";
    public static final String GAME_DATA = "GameData";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Log.d("PUKI","onCreate");

        // Get save game
        savehandler = SaveHandler.getInstance(this);
        gameData = savehandler.readLastState();

        setContentView(R.layout.gamescreen);

        // Load which state was given by the mainscreen
        switch ((STATES) getIntent().getExtras().get(GAME_STATE)) {
        case start:
            gameData.setFirstRun(true);
            Log.i("ONCREATE","Received state: start");
            break;
        case resume:
            gameData.setFirstRun(false);
            Log.i("ONCREATE","Received state: resume");
            break;
        default:
            gameData.setFirstRun(true);
            Log.i("ONCREATE","Received state: none");
            break;
        }

        // Transferring game data to MainScreen
        Bundle b = new Bundle();
        b.putInt("int",5);
        b.putSerializable(GAME_DATA,gameData);
        Intent i = new Intent();
        i.putExtras(b);
        setResult(0,i);
    }

    @Override
    protected void onStart() {
        super.onStart();
        Log.d("PUKI","onStart");
        Log.i("FIRSTRUN","Firstrun = "+gameData.getFirstRun());

        init(gameData.getFirstRun());


        gameData.getTurn().addOnTurnEndedListener(new Turn.OnTurnEndedListener<Hand>() {
            @Override
            public void onTurnEnded(Hand hand) {
                turnEndedHandler(hand);
            }
        });
    }

    private void init(boolean first) {
        initGraphics(first);
        Log.i("INIT","Game init graphics");
        if (first) {
            Log.i("INIT","Game init core");
            initGameCore();
        }
    }

    private void initGameCore() {
        deck = new Deck();
        playedSets = new ArrayList<PlayedSet>();

        // Create array with players and their hand
        playersInOrder = new ArrayList<Hand>();
        playerHand = new PlayerHand(playerCards,"Player name");
        playersInOrder.add(playerHand);
        oppHand = new OppHand(new GameStrategy(),null,"Opponent");
        playersInOrder.add(oppHand);

        // Push all data to gamedata class
        gameData.init(playerHand,oppHand,playersInOrder,deck,playedSets,new Turn<Hand>(playersInOrder,defaultStartingPlayer));
        gameData.setGameInProgress(true);

        // Deal cards to players
        dealCards();
    }


    //TODO
    protected void turnEndedHandler(final Hand hand) {
        if(hand.isAwaitingInput()){
            // This means the turn is for a human player,so do nothing.
            Log.i("TURN","The turn is for the human player: "+hand.getPlayerName());
        }
        else{
            // This means the turn is for a AI. Decide!
            Log.i("TURN","The turn is for the AI player: "+hand.getPlayerName());
            gameData.getTurn().next();

            // Update players hand size for human player
            this.updateOppScore();
        }
    }

(我从上面的例子中删除了很多代码,因为解决这个问题不需要代码)

import java.io.Serializable;
import java.util.ArrayList;

public class GameData implements Serializable {

    /**
     * 
     */
    private static final long serialVersionUID = -3796450525724090900L;

    private Hand playerHand,oppHand;
    private ArrayList<Hand> playersInOrder;
    private Deck deck;
    private boolean gameInProgress,grabbedCard,playerMustThrow,firstRun;
    private ArrayList<PlayedSet> playedSets; 
    private Turn<Hand> turn;

    private static GameData instance = new GameData();

    public GameData(){
        // Do nothing
    }

    public static GameData getInstance(){
        return instance;
    }

    public void init(Hand playerHand,Hand oppHand,ArrayList<Hand> playersInOrder,Deck deck,ArrayList<PlayedSet> playedSets,Turn<Hand> turn) {
        this.playerHand = playerHand;
        this.playersInOrder = playersInOrder;
        this.oppHand = oppHand;
        this.deck = deck;
        this.grabbedCard = false;
        this.playerMustThrow = false;
        this.playedSets = playedSets;
        this.firstRun = false;
        this.turn = turn;
    }

    public Hand getPlayerHand(){
        return playerHand;
    }
    public Hand getOppHand(){
        return oppHand;
    }
    public Deck getDeck(){
        return deck;
    }
    public ArrayList<Hand> getPlayersInOrder(){
        return playersInOrder;
    }
    public void setGrabbedCard(boolean set){
        this.grabbedCard = set;
    }
    public boolean getGrabbedCard(){
        return grabbedCard;
    }

    public void setGameInProgress(boolean progress) {
        this.gameInProgress = progress;
    }

    public boolean isGameInProgress(){
        return gameInProgress;
    }

    public void createNewPlaySet(PlayedSet newSet){
        playedSets.add(newSet);
    }

    public ArrayList<PlayedSet> getAllPlayedSets(){
        return playedSets;
    }

    public void setPlayerCanThrow(boolean set){
        this.playerMustThrow = set;
    }

    public boolean canPlayerThrow(){
        return playerMustThrow;
    }

    public boolean getFirstRun(){
        return firstRun;
    }

    public void setFirstRun(boolean set){
        this.firstRun = set;
    }

    public Turn<Hand> getTurn(){
        return turn;
    }

}

（编辑：安卓应用网）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!