Java IO.pdf - Nguyen Dang Binh

}
public int getFace() {
return this.face;
}
public void setFace(int face) {
this.face = (int) (Math.abs(face % 6) + 1);
}
public int roll() {
this.face = (int) ((Math.abs(shooter.nextInt()) % 6) + 1);
return this.face;
}
public static void main(String[] args) {
}
Die d = new Die(2);
for (int i = 0; i < 10; i++) {
d.roll();
System.out.println(d.getFace());
}
Java I/O
Obviously, this class, simple as it is, goes to a lot of trouble to ensure that the die always has a
value between 1 and 6. Every method that can possibly set the value of the private field face
carefully checks to make sure the value is between 1 and 6. However, serialization provides a
back door through which the value of face can be changed, because default serialization uses
neither constructors nor set methods but accesses the private field directly. To close the door,
you can provide a readObject() method that performs the necessary check:
private void readObject(ObjectInputStream in)
throws IOException, ClassNotFoundException {
}
in.defaultReadObject();
this.face = (int) (Math.abs(this.face % 6) + 1);
In this example, the normal serialization format is perfectly acceptable, so that's completely
handled by defaultReadObject(). It's just that a little more work is required than merely
restoring the fields of the object.
11.8.3 Preventing Serialization
On occasion, you need to prevent a normally serializable subclass from being serialized. This
most commonly occurs with components that are serializable, because java.awt.Component
is serializable. You can prevent an object from being serialized, even though it or one of its
superclasses implements Serializable, by throwing a NotSerializableException from
writeObject(). NotSerializableException is a subclass of
java.io.ObjectStreamException, which is itself a kind of IOException:
public class NotSerializableException extends ObjectStreamException
For example:
256