Weird? Externalizing writes out transient fields automatically...

Question

Essentially, I made up some class implementing Externalizable - with empty write/readExternal methods. Some how, the transient field have been writtena dnread back. From the stuff I''ve read about this, nothing mentions externalizable overriding the "don't write transient fields behaviour". The weird thing is: externalizable is supposed be when you need to say explicitly how to write your object (field by field for e.g.). When I ran this, I got all the fields written and read...
import java.io.*;
public class SerializationExample {
     public static void main(String[] args) {
          try {
               ToBeWritten tbw = new ToBeWritten();
               FileOutputStream f_out = new FileOutputStream("test");
               ObjectOutputStream out = new ObjectOutputStream(f_out);
               out.writeObject(tbw);
               out.close();
               FileInputStream f_in = new FileInputStream("test");
               ObjectInputStream in = new ObjectInputStream(f_in);
               ToBeWritten tbr = (ToBeWritten) in.readObject();
               in.close();
               System.out.println(tbr.privateField);
               System.out.println(tbr.staticField);
               System.out.println(tbr.transientField);
          } catch (Exception e) {
               System.out.println(e);
     static class ToBeWritten implements Externalizable {
          private String staticField = "staticField";
          transient String transientField = "transientField";
          private String privateField = "privateField";
          public void writeExternal(ObjectOutput out) throws IOException {
          public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
          public ToBeWritten() {
}

Answer 1

ejp, you description is more accurate.
Technically, the serialization code creates an new constructor for the class which calls the first non serializable super class's no-arg constructor method, provided that constructor is public, protected or (package-private and in the same package as the class)
If the first non-serializable no-args contructor is not accessible, an InvalidClassException is thrown.
As ejp points out, it is more complex than most author would suggest.
@see code for java.io.ObjectStreamClass.getSerializableConstructor(Class)