Java-存在导致程序无法正常工作的方法

在我的Java程序中，我有一个名为

Car

的类，它是

Serializable

。我有另一个类叫做

StaffCar

，它是

Car

的子类

然后有一个名为

Fleet

的类，它基本上在

ArrayList Fleet

中存储

StaffCar

对象

然后我有一个类

Main

，它由

Main

方法组成，该方法包括一个菜单和一个

开关来处理菜单选项

我遇到的问题是，当我在
StaffCar
中添加一个方法时，即使该方法内部没有任何内容，并且该方法甚至没有被调用，其中一个菜单选项“显示所有车辆信息”也会停止工作

如果我注释掉这个方法，它会再次开始工作

“Display…”选项从
Fleet
调用
printCars（）
，其中
Fleet
加载了序列化文件中的
StaffCar
对象，就好像此方法的存在阻止了文件的读取

Car的片段

import java.util.ArrayList;
import java.io.*;

@SuppressWarnings("serial")
public class Car implements Serializable
{
    //attributes for Car
    String regNo;
    String model;
    int mileage;

    //default constructor
    public Car() throws CarException
    {
        try 
        {
            setRegNo("??????");
            setModel("Unknown");
            setMileage(0);
        }
        catch (CarException c) 
        {
            System.out.println(c.getMessage());
        }
    }

    //setters
    public void setRegNo(String regNo) throws CarException
    {
        if (regNo.isEmpty())
        {
            throw new CarException("\nInvalid registration number!\n");
        }
        this.regNo = regNo;
    }

    public void setModel(String model) throws CarException
    {
        if (model.isEmpty())
        {
            throw new CarException("\nModel can't be empty!\n");
        }
        this.model = model;
    }

    public void setMileage(int mileage) throws CarException
    {
        if (mileage < 0)
        {
            throw new CarException("\nInvalid mileage!");
        }
        this.mileage = mileage;
    }
}

Fleet
类的片段

import java.util.ArrayList;
import java.io.*;

public class Fleet 
{
    //declare container
    ArrayList<StaffCar> fleet;
    //container to hold regNos
    ArrayList<String> regNumbers;

    //create constructor
    public Fleet()
    {
        fleet = new ArrayList<StaffCar>();
        regNumbers = new ArrayList<String>();
    }

    //add method
    public void addCar(StaffCar car)
    {
        fleet.add(car);
        regNumbers.add(car.regNo);
    }

    //print all cars' details
    public void printCars()
    {
        for (StaffCar car:fleet)
        {
            System.out.println(car);
        }
    }

    public void saveAs(String fileName) throws CarException
    {
        FileOutputStream outputFile;

        try
        {
            outputFile = new FileOutputStream(fileName);
        }
        catch (IOException io)
        {
            throw new CarException("\nCannot create " + fileName + "\n");
        }

        ObjectOutputStream fleetFile;

        try
        {
            fleetFile = new ObjectOutputStream(outputFile);
            fleetFile.writeObject(regNumbers);
            fleetFile.writeObject(fleet);
            fleetFile.close();
        }
        catch (FileNotFoundException e)
        {
            throw new CarException("\nCannot create " + fileName + "\n");
        }
        catch (IOException io)
        {
            throw new CarException("\nCannot write " + fileName + "\n");
        }
    }

    @SuppressWarnings({ "unchecked", "resource" })
    public void open(String fileName) throws CarException
    {
        FileInputStream inputFile;

        try
        {
            inputFile = new FileInputStream(fileName);
        }
        catch (FileNotFoundException e)
        {
            throw new CarException("\nCannot open " + fileName + "\n");
        }

        ObjectInputStream fleetFile;

        try
        {
            fleetFile = new ObjectInputStream(inputFile);
            regNumbers = (ArrayList<String>)fleetFile.readObject();
            fleet = (ArrayList<StaffCar>)fleetFile.readObject();
        }
        catch (IOException io)
        {
            throw new CarException("\nError reading from " + fileName + "\n");
        }
        catch (ClassNotFoundException e)
        {
            throw new CarException("\nError reading from " + fileName + "\n");
        }

        try
        {
            fleetFile.close();
        }
        catch (IOException io)
        {
            throw new CarException("\nCannot close " + fileName + "\n");
        }
    }
}

public class Main 
{   
    // new container
    static Fleet fleet = new Fleet();

    // initialise car object
    static StaffCar car;

    // programme loop variable
    static boolean state = false;

    String fileName;

    public static void main(String[] args) throws CarException
    {
        start();

        // programme loop
        while (!state) 
        {
            try 
            {
                // menu option variable
                String option;

                //displays menu to user and takes in input
                option = Console.askString("Menu:\n1 Add a car\n2 Display all car information\n3 Find a car\n4 Borrow a car\n5 Return a car\n6 Exit\n\n");
                //removes white spaces
                option = option.trim();

                //switch to handle user request
                switch (option) 
                {
                //if option 1
                case "1":
                    //call static add car method
                    addMethod();
                    break;
                //if option 2
                case "2":
                    //call static print car method
                    displayMethod();
                    break;
                //..option 3
                case "3":
                    //call static find car method
                    findMethod();
                    break;
                //..option 4
                case "4":
                    borrowMethod();
                    break;
                case "5":
                    //returnMethod();
                    break;
                case "6":
                    //call static quit method
                    quitMethod();
                    break;
                default:
                    System.out.println();

                    System.out.println("Invalid option.");

                    System.out.println();
                    break;
                }
            }
            catch (CarException c)
            {
                System.out.println(c.getMessage());
            }
        }
    }

    public static void start()
        {
            try
            {
                fleet.open("fleet.uwl");
            }
            catch (CarException e)
            {
                //System.out.println("\nFile not created yet!\n");
            }
        }

    //static menu method to print cars
    public static void displayMethod() throws CarException
    {
        System.out.println();

        //call printCars method
        fleet.printCars();

        System.out.println();
     }

}
您使用序列化保存了StaffCar实例，然后更改了StaffCar类，无法再次读取保存的StaffCar

这是因为，如果不在类中指定serialVersionUID，JVM将根据类的布局（字段、方法等）为您计算一个serialVersionUID。因此，要暂时解决问题，请检查读取文件时引发的IOException，它应该告诉您保存的类的serialVersionUID是什么，并将以下内容添加到类中：

private static final long serialVersionUID = XXXL;

其中XXX是保存对象中的串行版本UID，应在异常堆栈跟踪中提及

但实际上，您有这些问题，因为您选择使用序列化进行长期存储，这使得您的代码很难进化。我不会那么做的。相反，我会选择一种不那么脆弱、更容易发展的格式，如JSON或XML。定义文件应包含的内容，并生成包含此数据的JSON/XML文档。然后，无论您未来的CASS是什么样子，只要您仍然可以解析JSON/XML，就可以读取文件并获取保存的数据。
您使用序列化保存了StaffCar实例，然后更改了StaffCar类，并且无法再次读取保存的StaffCar

这是因为，如果不在类中指定serialVersionUID，JVM将根据类的布局（字段、方法等）为您计算一个serialVersionUID。因此，要暂时解决问题，请检查读取文件时引发的IOException，它应该告诉您保存的类的serialVersionUID是什么，并将以下内容添加到类中：

private static final long serialVersionUID = XXXL;

其中XXX是保存对象中的串行版本UID，应在异常堆栈跟踪中提及

但实际上，您有这些问题，因为您选择使用序列化进行长期存储，这使得您的代码很难进化。我不会那么做的。相反，我会选择一种不那么脆弱、更容易发展的格式，如JSON或XML。定义文件应包含的内容，并生成包含此数据的JSON/XML文档。然后，无论您未来的CASS是什么样子，只要您仍然可以解析JSON/XML，就可以读取文件并获取保存的数据。
您使用序列化保存了StaffCar实例，然后更改了StaffCar类，并且无法再次读取保存的StaffCar

这是因为，如果不在类中指定serialVersionUID，JVM将根据类的布局（字段、方法等）为您计算一个serialVersionUID。因此，要暂时解决问题，请检查读取文件时引发的IOException，它应该告诉您保存的类的serialVersionUID是什么，并将以下内容添加到类中：

private static final long serialVersionUID = XXXL;

其中XXX是保存对象中的串行版本UID，应在异常堆栈跟踪中提及

但实际上，您有这些问题，因为您选择使用序列化进行长期存储，这使得您的代码很难进化。我不会那么做的。相反，我会选择一种不那么脆弱、更容易发展的格式，如JSON或XML。定义文件应包含的内容，并生成包含此数据的JSON/XML文档。然后，无论您未来的CASS是什么样子，只要您仍然可以解析JSON/XML，就可以读取文件并获取保存的数据。
您使用序列化保存了StaffCar实例，然后更改了StaffCar类，并且无法再次读取保存的StaffCar

这是因为，如果不在类中指定serialVersionUID，JVM将根据类的布局（字段、方法等）为您计算一个serialVersionUID。因此，要暂时解决问题，请检查读取文件时引发的IOException，它应该告诉您保存的类的serialVersionUID是什么，并将以下内容添加到类中：

private static final long serialVersionUID = XXXL;

其中XXX是保存对象中的串行版本UID，应在异常堆栈跟踪中提及

但实际上，您有这些问题，因为您选择使用序列化进行长期存储，这使得您的代码很难进化。我不会那么做的。相反，我会选择一种不那么脆弱、更容易发展的格式，如JSON或XML。定义文件应包含的内容，并生成包含此数据的JSON/XML文档。然后，无论您未来的casse是什么样子，只要您仍然能够解析JSON/XML，您就能够读取文件并获得保存的数据。
Hi。在您看到奇怪行为的地方使用
开关
代码也是值得的。在您看到奇怪行为的地方使用
开关
代码也是值得的。我们需要使用
开关
编码