一、类的加载顺序

静态先行>构造块>构造方法

class Children {
    public Children() {
        System.out.println("构造方法111");
    }
    {
        System.out.println("构造块222");
    }
    static {
        System.out.println("静态代码块333");
    }
}
public class Demo01 {
    {
        System.out.println("构造方法444");
    }
    static {
        System.out.println("静态代码块555");
    }
    public Demo01() {
        System.out.println("构造方法666");
    }
    public static void main(String[] args) {
        System.out.println("美丽分割线000");
        new Children();
        new Children();
        new Demo01();
    }
}

运行结果

1、类初始化和实例化对象过程

image

如上来看，main方法在son中，启动后会加载Son类，因为Son类是Father的子类，所以先加载Father，父类要先初始化，静态static的随着类的加载进行加载，所以父类自上而下执行静态的方法和静态代码块，会调用method方法，输出（5),(1),子类同理,所以执行结果是5、1、10、6(懒得加括号)

image

首先如上面加载类，执行的是5、1、10、6，然后开始创建对象，Son实例开始初始化，实例初始化包含非静态实例变量显示赋值代码、非静态代码块、构造器，构造器是最后执行的，另外按照前后顺序，所以先是父类执行test方法，而这里要注意了，子类中也有test方法，实际上子类重写了父类的test方法，所以要执行子类的test，所以就是9、3、2。在执行子类的就是9、8、7。而接下来有创建了一个对象，所以又是9、3、2、9、8、7。所以最终是5、1、10、6、9、3、2、9、8、7、9、3、2、9、8、7。而为什么子类重写了test方法，而没有重写method方法呢，因为三种情况，是不能被重写的，static、final、private。

二、简单计算

public class Father {

    public static void main(String[] args) {
        int i = 1;
        String str = "hello";
        Integer num = 2;
        int[] arr = {1, 2, 3, 4, 5};
        MyDate myDate = new MyDate();

        change(i, str, num, arr, myDate);

        System.out.println(i);//1
        System.out.println(str);//hello
        System.out.println(num);//2
        System.out.println(Arrays.toString(arr));//22345
        System.out.println(myDate.a);//11
    }
    public static void change(int j, String s, Integer n, int[] a, MyDate m) {
        j += 1;
        s += "world";
        n += 1;
        a[0] += 1;
        m.a += 1;
    }
}
class MyDate {
    int a = 10;
}

这个题的重点在于基本数据类型和引用类型指向不同。其中实参是引用数据类型，传的是地址，是基本数据类型，传的是数据值。要特别注意这个题的String的不可变性，还有包装类Integer。

public class Father {

    public static void main(String[] args) {
        int i = 1;
        i = i++;
        int j = i++;
        int k = (++i + i++ * i);
        System.out.println(i);
        System.out.println(j);
        System.out.println(k);
    }
}

打眼一看，肯定是4、2、15啊，问题出在 i=i++，在这里先进行右边的计算，然后再赋值，这个局部变量现在是1，因为i++的“++”是在后边，所以先入栈后自增，先将i=1压入栈中，然后i自增1，局部变量就是2，然后进行“=”的赋值操作，就要把i从栈中取出来，最后i=1。其实结果是4、1、15

三、成员变量和局部变量

image

public class Father {
    static int s;
    int i;
    int j;

    {
        int i = 1;
        i++;
        j++;
        s++;
    }

    public void test(int j) {
        j++;
        i++;
        s++;
    }

    public static void main(String[] args) {
        Father obj1 = new Father();
        Father obj2 = new Father();
        obj1.test(10);
        obj1.test(20);
        obj2.test(30);
        System.out.println(obj1.i + "," + obj1.j + "," + obj1.s);
        System.out.println(obj2.i + "," + obj2.j + "," + obj2.s);
    }
}

image.png

（1）声明的位置

• 局部变量是在方法体{}中、形参、代码块{}中
• 成员变量是在类中的方法外，而成员变量又分类变量和实例变量：类变量是static修饰的，实例无

（2）修饰符

• 局部变量：final
• 成员变量：public、private、protected、final、static、volatile、transient

（3）值存储位置

• 局部变量：栈
• 实例变量：堆
• 类变量：方法区

（4）作用域

• 局部变量：从声明位置到}
• 实例变量：在当前类中“this.”调用（“this.”可以省略，但是访问的就是就近的这个变量了，就有可能是局部变量），在其他类中，“对象名.”来访问。
• 类变量：当前类中“类名.”（“类名.”可以省略，但是访问的就是就近的这个变量了，就有可能是局部变量），在其他类中，“对象名.”或者“类名.”访问

（5）生命周期

• 局部变量：每一个线程，每一次调用执行的都是新的生命周期。
• 实例变量：随着对象的创建而初始化，随着对象回收消亡，每一个对象的实例变量是独立的。
• 类变量：随着对象的初始化而初始化，随着类卸载而消亡，该类的所有对象的类变量是共享的。

要注意，方法在执行的时候会在栈中分配一块空间，比如说在main方法执行的时候，是在栈分配了一块区域，然后实例化obj1，会有一个<init>方法，又会分配一块区域，这时候局部变量int i = 1 也是在栈这块区域的。

四、单例模式

image image image