我可以在不使用序列化的情况下编写此代码吗？

Question

For my project I was wondering whether there is a way I can do this assignment without using serialization. Here are the guidelines to the project and the code I already have together:

The Canadian Forest Service wants to do a simple simulation of the growth and pruning of forests. Each forest has a name and exactly 10 trees. The trees are planted when they are 1' to 5' tall, and each tree has a individual growth rate of 50%-100% per year. For the simulation new trees are constructed randomly within these bounds. A forest is reaped (by lumberjacks) on demand - all trees above a specifed height are cut down and replaced with new trees.

The user interface to the simulation must allow the user to:

Display the current forest (with tree heights to 2 decimal places) Discard the current forest and create a new forest Simulate a year's growth in the current forest Reap the current forest of trees over a user specified height, replacing the reaped trees with random new trees. Save the information about the current forest to file (named after the forest) Discard the current forest and load the information about a forest from a file.

Class1

import java.io.*;
import java.util.*;
public class Forest{

//constants
    private static final int MAX_NUM_TREES = 10;

//variables
    int index;
    private String name;
    private Tree[] arrayOfTrees;
    public Forest(String forestName){
//Constructor class that takes a name and creates an array of trees().
        index = 0;
        name = forestName;
        arrayOfTrees = new Tree[MAX_NUM_TREES];

        for(index = 0; index < arrayOfTrees.length; index++){

            arrayOfTrees[index] = new Tree();

        }
    }

    public void display(){
// displays the array of trees and the index
        index = 0;

        if(name != null){

            System.out.println(name);
            for(index = 0; index < arrayOfTrees.length; index ++){
                System.out.printf("%2d   :   %s\n", (index + 1), arrayOfTrees[index]);
            }
        }else{
            System.out.println("No forest.");
        }

    }
   public void yearGrowth(){
//grows each tree in the array
        index = 0;

        for(index = 0; index < arrayOfTrees.length ; index ++){

            arrayOfTrees[index].grow();
        }

    }
   public void reap(int reapHeight){
        //reaps the trees and prints out the old and new information
        index = 0;


        for(index = 0; index < arrayOfTrees.length; index++){

            if(arrayOfTrees[index].getHeight() >= reapHeight){

                System.out.println("Cut " + (index+1) + " : " + arrayOfTrees[index] );
                arrayOfTrees[index] = new Tree();
                System.out.println("New " + (index+1) + " : " + arrayOfTrees[index] );

            }
        }

    }
public static void saveForest(Forest forest) throws IOException {
//saves the forest
        String name = forest.getName();
        ObjectOutputStream toStream;

        toStream = new ObjectOutputStream(new FileOutputStream(name));
        toStream.writeObject(forest);
        toStream.close();
    }

   public static Forest loadForest(String fileName) throws IOException {
//loads the forest
        ObjectInputStream fromStream = null;
        Forest local;

        fromStream = new ObjectInputStream(new FileInputStream(fileName));
        try {
            local = (Forest)fromStream.readObject();
        }catch (ClassNotFoundException e) {
            System.out.println(e.getMessage());
            return(null);
        }finally{
            try {
                if (fromStream != null) {
                    fromStream.close();
                }
            } catch (IOException e) {
                System.out.println(e.getMessage());
                return(null);
            }
        }
        return(local);
    }
    public String getName(){

        return (name);
    }
}

Class2

import java.util.Random;
import java.util.*;
import java.io.*;

public class Tree{

//creates the variables as the
    private double height;
    private double growthRate;
    private static Random rand = new Random();
    final double MIN_HEIGHT = 1;
    final double MIN_GROWTH_RATE = 0.5;
    final double MAX_HEIGHT = 5;
    final double MAX_GROWTH_RATE = 1.0;

    public Tree() {
//creates tree with a height and a growth rate
        Random rand = new Random();

        height = (MIN_HEIGHT + ((Math.random() * (MAX_HEIGHT - MIN_HEIGHT))));
        growthRate = (MIN_GROWTH_RATE + (Math.random() * (MAX_GROWTH_RATE - MIN_GROWTH_RATE)));


    }

    public double grow(){
//tree grows and returns height

        height = height * (1 + growthRate);
        return height;


    }

    public double getHeight(){

        return (height);

    }

    public double getGrowthRate(){

        return (growthRate);

    }

    public String toString(){
//toString formats the output with height and growthrate

        return (String.format("%7.2f (%2d%% pa)", height, ((int)(growthRate * 100))));

    }
}

Answer 1

If by serialization you understand standard java serialization with ObjectXXXStream , then yes, you can avoid it.

If you mean serialization in more broad way, then no. Files cant directly store java objects you have to convert them to bytes (which is serialization by definition).

PS: If you actually ask "How?" you should include it in your question.