成员变量的初始化顺序

最新推荐文章于 2023-01-30 21:59:51 发布

Stand1210

最新推荐文章于 2023-01-30 21:59:51 发布

阅读量2.8k

点赞数 1

本文链接：https://blog.csdn.net/Stand1210/article/details/52331624

版权

一.类加载时,变量的初始化顺序:
1.首先,给静态成员变量分配内存空间,进行默认初始化
(整型为0,浮点型为0.0,布尔型为false,字符型为'\u0000',引用型为null)

2.其次,执行静态成员变量的初始化操作
--静态成员的初始化,包括两种: 声明时直接初始化和静态代码块
--执行顺序为:在代码中的出现的顺序(声明的顺序)

注意: 1和2的动作,在类加载时只执行一次!!!!!!!

如果创建了对象,则在堆中给类的实例分配内存空间,
3.首先,对实例变量,进行默认初始化
(整型为0,浮点型为0.0,布尔型为false,字符型为'\u0000',引用型为null)

4.其次,执行实例变量的初始化操作
--实例变量的初始化,使用前2种初始化方式: 声明时直接初始化和代码块
--执行顺序为:在代码中的出现的顺序(声明的顺序)

5.最后,执行构造函数(实例变量的第3中初始化方式)

二.继承时,变量的初始化顺序:
1.当类第一次使用时,JVM就会加载该类,如果该类存在父类,那么就先加载父类,这是一个递归过程,直到Object为止.
在类加载中,首先进行静态成员变量按照默认值进行初始化,
然后按照在类中声明的顺序执行静态代码块和静态变量的显示初始化.
这个过程从父类到子类,并且只会执行一次!!!

2.当父类与子类的静态代码初始化完成后,如果创建了类的对象,
在初始化子类前,会先对其父类的实例变量进行默认初始化,
然后按照在类中的声明顺序来执行代码块与实例变量的显示初始化,
最后调用父类的构造函数,这也是一个递归过程,直到Object类为止.

(这个过程在每次创建对象时,都会执行!!!)

Java类成员变量的初始化顺序

初始化的顺序是先“静态”，（如果它们尚未因前面的对象创建过程而被初始化），后“非静态”。

具体的创建过程：

1.当首次创建某个类对象的时候，或者该类的静态方法/静态域首次被访问时，Java解释器必须查找该类的路径，以定位该类的class文件。

2.然后载入该class（创建一个Class对象），有关静态初始化的动作都会执行。静态初始化只在Class对象首次加载的时候进行一次。

例如：按照出现顺序执行初始化动作

static int n1 = f(1);

static{

n3 = f(3);

//静态域的初始化语句不必担心非法向前引用，但是如果是访问n3，就会发生非法向前引用的错误

System.out.println("println");

}

static int n2 = f(2);

static int n3;

static int f(int i){

System.out.println("n"+i);

return i;

}

创建对象或者访问此类的某个静态域/静态方法，打印出来:

println

3.当使用new操作符创建对象的时候，首先将在堆上为待创建的对象分配足够的存储空间。

4.这块存储空间会被清零，这就自动的将类中所有基本类型数据设置成了默认值（数值和字符是0，布尔是false），而引用则被设置成了null。

5.按出现顺序执行所有出现于域(非静态域)定义处的初始化动作。

6.执行构造器。

运行一下下面的例子就都清楚了。

public class MembersInitializeSequence {

public static void main(String[] args){
Bowl.f();
System.out.println("实例化一个Bowl对象");
new Bowl();
System.out.println("再实例化一个Bowl对象");
new Bowl();
}
}

class Cup {
Cup(int i){
System.out.println("new Cup("+i+")");
}
}

class Bowl{
Cup c1;
Cup c2 = new Cup(2);
{
c1 = new Cup(1);
}
static{
c4 = new Cup(4);
System.out.println("Bowl中的静态快,静态块只在类加载的时候运行，所以只运行一次");
}
static Cup c3 = new Cup(3);
static Cup c4;
Bowl(){
System.out.println("new Bowl()");
}

static void f(){
System.out.println("Bowl中的静态方法f()被访问");
}
}

在类被继承的情况下，初始化的顺序：

1.初始化子类，类加载器在加载它的时候会发现它继承了另外一个类，类加载器要先把父类加载进来。于是开始加载父类，父类的静态部分被按顺序加载。之后子类的静态部分被加载。这样的顺序是考虑子类的静态域可能会依赖父类的静态域；

2.父类的非静态部分被加载；

3.子类指定的父类的构造器；

4.子类的非静态部分被加载；

5.子类构造器的其余部分。

多个层次的继承关系，顺序也同理。

例：

public class MembersInitializeSequenceEx {
public static void main(String[] args){
// new Cat();
new Tiger();
}
}
class Cat{
int c1 = f1(1);
int f1(int i){
System.out.println("Cat unstatic "+i);
return i;
}
{
System.out.println("Cat unstatic block");
}
static int c2 = f2(2);
static int f2(int i){
System.out.println("Cat static "+i);
return i;
}
static{
System.out.println("Cat static block");
}
public Cat(){
System.out.println("new Cat()");
}
}
class Tiger extends Cat{
int c3 = f1(3);
@Override
int f1(int i){
System.out.println("Tiger unstatic "+i);
return i;
}
{
System.out.println("Tiger unstatic block");
}
static int c4 = f2(4);
static int f2(int i){
System.out.println("Tiger static "+i);
return i;
}
static{
System.out.println("Tiger static block");
}
public Tiger(){
super();
System.out.println("new Tiger()");
}
}

C++成员变量的初始化顺序问题：

问题来源：

由于面试题中，考官出了一道简单的程序输出结果值的题：如下，

[cpp] view plain copy print ?

class A
{
private:
int n1;
int n2;
public:
A():n2(0),n1(n2+2){}
void Print(){
cout << "n1:" << n1 << ", n2: " << n2 <<endl;
}
};
int main()
{
A a;
a.Print();
return 1;
}

这时，那个考生这样回答：n1是2，n2是0。
在我电脑输出结果为：

如果你也这样回答，那么你肯定不懂初始化成员列表的顺序。

如果我把A类中构造函数改成：

[cpp] view plain copy print ?

A()
{
n2 = 0;
n1 = n2 +2;
}

那么此时输出结果为：

分析：

1、成员变量在使用初始化列表初始化时，与构造函数中初始化成员列表的顺序无关，只与定义成员变量的顺序有关。因为成员变量的初始化次序是根据变量在内存中次序有关，而内存中的排列顺序早在编译期就根据变量的定义次序决定了。这点在EffectiveC++中有详细介绍。

2、如果不使用初始化列表初始化，在构造函数内初始化时，此时与成员变量在构造函数中的位置有关。

3、注意：类成员在定义时，是不能初始化的

4、注意：类中const成员常量必须在构造函数初始化列表中初始化。

5、注意：类中static成员变量，必须在类外初始化。

6、静态变量进行初始化顺序是基类的静态变量先初始化，然后是它的派生类。直到所有的静态变量都被初始化。这里需要注意全局变量和静态变量的初始化是不分次序的。这也不难理解，其实静态变量和全局变量都被放在公共内存区。可以把静态变量理解为带有“作用域”的全局变量。在一切初始化工作结束后，main函数会被调用，如果某个类的构造函数被执行，那么首先基类的成员变量会被初始化。