Java语言规范第十一/十二章-异常/执行

Java语言规范第十一章-异常(Java Language Specification – Chapter11 Interface)

 

在抛出异常的过程中，JVM突然的技术当前线程中已经开始但还没有执行完的表达式，语句，方法和构造方法调用，初始化，成员初始化表达式。这个过程持续到发现可以处理对应异常的handler，如果没有发现这样的handler，那么将会调用当前线程的父线程ThreadGroup的uncaughtException方法。该方法会打印线程的名字和异常的堆栈信息：

if (parent != null) {

parent.uncaughtException(t, e);

}

else {

    Thread.UncaughtExceptionHandler ueh =

        Thread.getDefaultUncaughtExceptionHandler();

    if (ueh != null) {

        ueh.uncaughtException(t, e);

    } else if (!(e instanceof ThreadDeath)) {

System.err.print("Exception in thread /""

               + t.getName() + "/" ");

        e.printStackTrace(System.err);

    }

}

异常机制和java平台的同步模型集成在一起，当同步语句以及同步方法的调用突然结束后，lock就被释放了。

 

public class Test {

       public Test() throws Exception{

              throw new Exception();

       }

       public static void main(String[] args) {

              Test test = null;

              try{

                     test = new Test();

              }catch(Exception e){

                     e.printStackTrace();

              }finally{

                     System.out.println(test == null);

              }

       }

}

//java.lang.Exception

//     at jp.co.valup.jls.Test.<init>(Test.java:6)

//     at jp.co.valup.jls.Test.main(Test.java:15)

//true

 

public class Test {

       public Test() throws RuntimeException{

              throw new RuntimeException();

       }

       public static void main(String[] args) {

              Test test = null;

              try{

                     test = new Test();

              }finally{

                     System.out.println(test == null);

              }

       }

}

//true

//Exception in thread "main" java.lang.RuntimeException

//     at jp.co.valup.jls.Test.<init>(Test.java:5)

//     at jp.co.valup.jls.Test.main(Test.java:10)

 

 

Java语言规范第十二章-执行(Java Language Specification – Chapter12 Execution)

 

执行的过程是通过java虚拟机来完成的，关于java虚拟机有专门的规范来定义，即Java Virtual Machine Specification，JSR 924。

 

一般说来，执行的过程就是加载包含main方法的类，然后执行其main方法。执行的过程包括加载，链接和初始化。

虚拟机通过使用类加载器来加载类，加载的过程中可能会发生下面的异常：

ClassCircularityError: 由于类或者接口是自己的父类或者父接口导致无法加载。

ClassFormatError: 二进制字节码文件的内容不正确。

NoClassDefFoundError: 请求的类或者接口找不到。

由于加载的时候涉及到为新的数据结构分配内存，所以还可能因为OutOfMemoryError而导致加载失败。

jdk提供的类加载器包括：

java.lang.Object

  java.lang.ClassLoader

      java.security.SecureClassLoader

          java.net.URLClassLoader

              javax.management.loading.MLet

                  javax.management.loading.PrivateMLet

 

链接的过程就是将二进制的类或者接口类型组合成JVM运行时的状态以被执行。链接的过程一般包含三个活动，即验证，准备和处理符号引用。

这个过程如果发生错误的话，将导致LinkageError或者其子类，例如VerifyError。

验证用来确保二进制格式的类或者接口在格式上是正确的。

准备阶段将类变量或者常量初始化为默认的。显式的static成员的初始化在初始化阶段进行，而不是准备阶段。

 

只有当类被初始化了，才会被虚拟机执行。初始化阶段包括类的成员变量初始化，静态初始化，按照文字先后的顺序。但是在类被初始化之前，其父类必须先被初始化，以此类推。在初始化父类的时候，又涉及到加载，链接和初始化，所以可能发生前两个阶段发生的错误。

但是类继承的接口不需要被初始化。

在以下情况下，类或者接口会在下面情况之前被初始化：

类T的一个实例被创建。

类T的静态方法被类T调用。

T(类或者接口)的静态成员被赋值。

T(类或者接口)声明的静态成员被使用，并且静态成员不是常量。

类T是顶层类，嵌套T的断言(assert)被执行。

class Super {

        static { System.out.print("Super "); }

}

class One {

        static { System.out.print("One "); }

}

class Two extends Super {

        static { System.out.print("Two "); }

}

class Test {

        public static void main(String[] args) {

                One o = null;

                Two t = new Two();

                System.out.println((Object)o == (Object)t);

        }

}

prints:

Super Two false

 

对类变量的引用会导致声明它的类或者接口的初始化，即使它被子类或者自接口直接使用。

class Super { static int taxi = 1729; }

class Sub extends Super {

        static { System.out.print("Sub "); }

}

class Test {

        public static void main(String[] args) {

                System.out.println(Sub.taxi);

        }

}

prints only:

 

1729

 

对接口的初始化不会初始化任何其父接口。

interface I {

        int i = 1, ii = Test.out("ii", 2);

}

interface J extends I {

        int j = Test.out("j", 3), jj = Test.out("jj", 4);

}

interface K extends J {

        int k = Test.out("k", 5);

}

class Test {

        public static void main(String[] args) {

                System.out.println(J.i);

                System.out.println(K.j);

        }

        static int out(String s, int i) {

                System.out.println(s + "=" + i);

                return i;

        }

}

produces the output:

1

j=3

jj=4

3

J.i是一个编译时的常量，因此不会初始化I。K.j实际上是引用J中声明的常量，不是编译时的常量，所以初始化J，但是不会初始化J的父接口I。尽管使用了K.j，但是不会初始化K。

 

important:

class Point {

        int x, y;

        Point() { x = 1; y = 1; }

}

class ColoredPoint extends Point {

        int color = 0xFF00FF;

}

class Test {

        public static void main(String[] args) {

                ColoredPoint cp = new ColoredPoint();

                System.out.println(cp.color);

        }

}

创建了一个新的ColoredPoint实例。首先，为新的实例分配空间，以便存储x，y和color成员变量。然后初始化这些成员变量为初始值，即都等于0。

然后，首先调用无参的ColoredPoint构造方法，由于该类没有声明构造方法，所以调用Java编译器提供的缺省的构造方法：

ColoredPoint() { super(); }

这个构造方法然后调用Point的无参构造方法，Point的构造方法没有以调用构造方法开始，所以编译器提供的隐式调用父类的缺省构造方法被执行：

Point() { super(); x = 1; y = 1; }

所以，Object类的无参构造方法被调用。

Object类没有超类，所以递归到此结束，然后Object的任何成员初始化，成员变量初始化被调用，接着Object类的无参构造方法的body部分被执行，Object类中并没有这个构造方法，所以使用编译器提供的默认的：

Object() { }

这个构造方法什么都不做就返回。

然后，所有的Point类的成员变量被初始化，在Point类中，x和y没有提供初始化表达式，所以在本例中不进行该步骤操作。然后执行Point构造方法的body部分，将x和y设置为1。

然后，ColoredPoint类的成员变量被初始化，将color的值设置为0xFF00FF。最后，执行ColoredPoint构造方法的body部分(即super调用之后的部分)。ColoredPoint的构造方法在super调用之后没有语句，所以就结束了初始化的操作。

 

和C++不同，Java在新的类实例初始化的时候不进行方法的转发。如果调用创建对象的方法是对父类方法的覆盖，那么就使用子类的方法，即使在新的对象还没有完成初始化，所以下面的例子运行如下：

class Super {

        Super() { printThree(); }

        void printThree() { System.out.println("three"); }

}

class Test extends Super {

        int three = (int)Math.PI;// That is, 3

        public static void main(String[] args) {

                Test t = new Test();

                t.printThree();

        }

        void printThree() { System.out.println(three); }

}

 

获得输出如下：

0

3

这表示在Super类中调用printThree并没有调用Super类的printThree，而是调用了子类的printThree，由于此时子类的three还没有被初始化，所以默认的值是0。但是一旦子类实例不创建完成，即three已经被初始化为3，那么将打印3。