java笔记-基础点II

java

现在这篇里，包括静态块和构造块等的执行顺序。

1.一个栗子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class B
{
    public static B t1 = new B();
    public static B t2 = new B();
    {
        System.out.println("构造块");
    }
    static
    {
        System.out.println("静态块");
    }
    public static void main(String[] args)
    {
        B t = new B();
    }
}

输出为：构造块 构造块 静态块 构造块

解释：

静态块：用static申明，JVM加载类时执行，仅执行一次；
构造块：类中直接用{}定义，每一次创建对象时执行；
执行顺序优先级：静态块>main()>构造块>构造方法；
静态块按照声明顺序执行，所以先执行publicstaticB t1 = newB();该语句创建对象，则又会调用构造块，输出构造块；
接着执行public static B t1 = new B();输出构造块；
再执行static{System.out.println("静态块");}输出静态块；
最后main方法执行，创建对象，输出构造块。



2.另一个栗子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public class HelloB extends HelloA 
{
 public HelloB()
 {
 }
 {
     System.out.println("I’m B class");
 }
 static
 {
     System.out.println("static B");
 }
 public static void main(String[] args)
 {
     new HelloB();
 }
}
class HelloA
{
 public HelloA()
 {
 }
 {
     System.out.println("I’m A class");
 }
 static
 {
     System.out.println("static A");
 }
}

当涉及到继承时，按照如下顺序执行：
（1）执行父类的静态代码块
static {
System.out.println(“static A”);
}
输出:static A
（2）执行子类的静态代码块
static {
System.out.println(“static B”);
}
输出:static B
（3）执行父类的构造代码块
{
System.out.println(“I’m A class”);
}
输出:I’m A class
（4）执行父类的构造函数
public HelloA() {
}
输出：无
（5）执行子类的构造代码块
{
System.out.println(“I’m B class”);
}
输出:I’m B class
（6）执行子类的构造函数
public HelloB() {
}
输出：无

那么，最后的输出为：
static A
static B
I’m A class
I’m B class