最近翻书,看到这个Java初始化与类创建过程挺有意思的,动手试了试,才知道初始化非静态方法还有直接{}这种语法
class Apple {
public Apple(int i) {
System.out.println("Apple(" + i + ")");
}
}
class Apples {
private Apple apple1 = new Apple(11);
private static Apple apple_s1 = new Apple(1111);
{
apple1 = new Apple(1);
apple2 = new Apple(2);
System.out.println("apple1 and apple2 initialized!");
}
private Apple apple2 = new Apple(22);;
static {
apple_s1 = new Apple(111);
apple_s2 = new Apple(222);
}
private static Apple apple_s2 = new Apple(2222);
public Apples() {
System.out.println("Apples()");
}
public static void print(int i) {
System.out.println("Static fun(" + i + ")!");
}
}
public class Initial {
public static void main(String[] args) {
System.out.println("inside");
Apples.print(1000);
System.out.println("Static fun completed");
new Apples();
System.out.println("new Apples() completed");
}
}
Output:
inside
Apple(1111)
Apple(111)
Apple(222)
Apple(2222)
Static fun(1000)!
Static fun completed
Apple(11)
Apple(1)
Apple(2)
apple1 and apple2 initialized!
Apple(22)
Apples()
new Apples() completed
static 变量在首次用到类方法或首次初始化类的时候会进行初始化,按照变量在类中的顺序进行初始化。
非静态变量在初始化类的时候调用,初始化赋值顺序也是按照类中顺序进行。({}与static{}与变量顺序排序)
总结下对象的创建过程,例如Apple:
1)及时没有显示地使用static关键字,构造器实际上也是静态方法。因此,当首次创建类型为Apple时(构造器看成静态方法),或者Apple类的静态方法/静态域首次被访问时,Java解释器必须查找类路径,定位Apple.class文件。
2)然后载入Apple.class,有关静态初始化的所有动作都会执行。因此,静态初始化只在Class对象首次加载的时候进行一次。
3)当用new Apple()创建对象的时候,首先将在堆上为Apple对象分配足够的存储空间。
4)这块存储空间会被清零,这就自动得将Apple对象中的所有基本类型数据都设置成了默认值(boolean为false),引用则被设置成null。
5)执行所有出现于字段定义处的初始化动作。
6)执行构造器。
更新:
碰到一个新问题:
public class Test {
public static void main(String[] args) {
new B();
}
}
class A{
int i=20;
public A(){
print();
}
public void print(){
System.out.println("A:"+i);
}
}
class B extends A{
int i=30;
public B(){
print();
}
public void print(){
System.out.println("B:"+i);
}
}
输出什么呢
肯定知道第二行要输出 “B:30”;
那第一行呢,A的print()为java默认的virtual,那么要输出“B:”那A中的i=20起作用了么?
第一行是输出“B:0”,“B:20”还是“B:30”呢
答案是
B:0
B:30
理由呢,思考下
想了下,没想出原因,试着改改输出,改成这样
public class Test {
public static void main(String[] args) {
new B();
}
}
class A {
int i=a();
public A(){
System.out.println("A()");
print();
}
public int a(){
System.out.println("a");
return 20;
}
public void print(){
System.out.println("A:"+i);
}
}
class B extends A{
int i=b();
public B(){
System.out.println("B()");
print();
}
public int b(){
System.out.println("b");
return 30;
}
public void print(){
System.out.println("B:"+i);
}
}
输出:
a
A()
B:0
b
B()
B:30
说明class A中的int i = a();这句话调用了,而且是在A的构造函数之前,那么为什么A的构造函数中输出的i是0,难道是生成B对象时,A中print()函数调用B中的i,与A中i不是一个东西,不是简单的覆盖,而是更外生成,以前理解的一直错了。