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