There are two options: either a user can serialize an object or
deserialize it. (using the -s or -d flag). These options allow
for the demonstration of bidirection readability and writeability
between the original and the evolved class. In other words,
one can serialize an object here and deserialize it with the evolved
class or vice versa.
AClass serializeclass = new AClass(20, "serializedByEvolvedClass");
AClass deserializeclass = null;
boolean serialize = false;
boolean deserialize = false;
/*
* see if we are serializing or deserializing.
* The ability to deserialize or serialize allows
* us to see the bidirectional readability and writeability
*/
if (args.length == 1) {
if (args[0].equals("-d")) {
deserialize = true;
} else if (args[0].equals("-s")) {
serialize = true;
} else {
usage();
System.exit(0);
}
} else {
usage();
System.exit(0);
}
/*
* Serialize the original class if that's the option chosen
*/
if (serialize) {
try {
FileOutputStream fo = new FileOutputStream("evolve.tmp");
ObjectOutputStream so = new ObjectOutputStream(fo);
so.writeObject(serializeclass);
so.flush();
} catch (Exception e) {
System.out.println(e);
System.exit(1);
}
}
/*
* Deserialize, if that's the option chosen and print the name
* of the object, which will allow us to see who serialized the
* object, the original class or the evolved class file
*/
if (deserialize) {
try {
FileInputStream fi = new FileInputStream("evolve.tmp");
ObjectInputStream si = new ObjectInputStream(fi);
deserializeclass = (AClass) si.readObject();
} catch (Exception e) {
System.out.println(e);
System.exit(1);
}
/*
* Print out to see that it is indeed the same object as it was
* when it was serialized (depending on whether it was the original
* class that serialized it or the evolved class)
*/
System.out.println("Now printing deserialized object's name: ");
System.out.println();
System.out.println("name: " + deserializeclass.name);
System.out.println();
}
