本文主要是介绍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。
这篇关于Java语言规范第十一/十二章-异常/执行的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！
