精华内容
下载资源
问答
  • 我们都知道,在Java语言中,有静态字段和实例字段,但是,它们两者之间的初始化说明还是有区别!!! 1. 静态字段 static 静态字段 / 静态变量 的初始化过程,由Java虚拟机JVM加载后,自动进行静态字段初始...

    我们都知道,在Java语言中,有静态字段和实例字段,但是,它们两者之间的初始化是有区别的。

    其中,需要说明的一点就是:静态字段由类调用,实例字段由对象调用!!!

    1. 静态字段

    static 静态字段 / 静态变量 的初始化过程,由Java虚拟机JVM加载类后,自动进行静态字段初始化。

    ①静态字段的默认初始化:静态字段设置为其类型的默认值。

    ②静态字段的声明初始化:静态字段设置为声明时的初始化值。

    ③静态字段的静态块初始化:依次调用静态块进行初始化。

    从源程序的角度看,静态字段以上三种初始化的顺序:

    ①首先进行默认初始化。

    ②然后根据声明初始化、静态块初始化这两者在程序中的顺序来依次进行!!!(两者谁先谁后是不一定的)

    2. 实例字段 

    实例字段 / 实例变量 的初始化过程,由new进行实例初始化。

    ①实例字段的默认初始化:实例字段设置为其类型的默认值。

    ②实例字段的声明初始化:实例字段设置为声明时的初始化值。

    ③实例字段的实例构造方法初始化:根据实例构造方法签名,调用实例构造方法进行初始化。

    从源程序的角度看,实例字段以上三种初始化的顺序:

    ①首先必须进行默认初始化。

    ②然后进行声明初始化。

    ③最后进行实例构造方法的初始化。

    因为实例字段相对来说,比较好理解,所以我们在这里重点对静态字段的初始化进行讲解!!!

    我们依次来看下面的五个程序!!!👇👇👇 

    Program Ⅰ: (没有静态块,静态变量的声明初始化的顺序不同)

    class Test1 {
    	public Test1() {
    		System.out.println("Test1实例构造函数之前 a="+Test.a+",b="+Test.b);
    		Test.a++;
    		Test.b++;
    		System.out.println("Test1实例构造函数之后 a="+Test.a+",b="+Test.b);
    	}
    }
    public class Test {
    	public static Test1 t=new Test1();
    	public static int a;
    	public static int b=10;
    	public static void main(String[] args) {
    		System.out.println("最后的结果:a="+Test.a+",b="+Test.b);
    	}
    }

    Program Output Ⅰ: 

    Program Analysis Ⅰ:

    按此顺序初始化静态变量:默认初始化→声明初始化 

    默认初始化:静态变量按照声明的顺序依次设置为该类型的默认值。

    声明初始化:静态变量按声明的顺序依次设置为声明初始化的值,如果没有声明初始化就跳过。 

    静态字段初始化流程如下:

    1. 默认初始化:类被加载后,首先静态字段会进行默认初始化。结果:t=null,a=0,b=0

    2. 声明初始化:①首先进行静态字段t的声明初始化,创建Test1的实例,调用实例构造方法,执行之后的结果:a=1,b=1

                              ②然后进行静态字段a和b的声明初始化,因为静态字段a没有声明初始化,所以就跳过,并执行Test.a++,                     此时a=1;但是静态字段b由声明初始化,结果b=10。(大家对照这个流程,看一下上面的代码和运行结果)

     

    Program Ⅱ:(没有静态块,静态变量的声明初始化的顺序不同)

    class Test1 {
    	public Test1() {
    		System.out.println("Test1实例构造函数之前 a="+Test.a+",b="+Test.b);
    		Test.a++;
    		Test.b++;
    		System.out.println("Test1实例构造函数之后 a="+Test.a+",b="+Test.b);
    	}
    }
    public class Test {
    	public static int a;
    	public static int b=10;
            public static Test1 t=new Test1();
    	public static void main(String[] args) {
    		System.out.println("最后的结果:a="+Test.a+",b="+Test.b);
    	}
    }

    Program Output Ⅱ: 

    Program Analysis Ⅱ:

    按此顺序初始化静态变量:默认初始化→声明初始化 

    默认初始化:静态变量按照声明的顺序依次设置为该类型的默认值。

    声明初始化:静态变量按声明的顺序依次设置为声明初始化的值,如果没有声明初始化就跳过。 

    静态字段初始化流程如下:

    1. 默认初始化:类被加载后,首先静态字段会进行默认初始化。结果:t=null,a=0,b=0。

    2. 声明初始化:①首先进行静态字段a和b的声明初始化,因为静态字段a没有声明初始化,所以就跳过,结果还是a=0;但                     静态字段b有声明初始化,所以结果是b=10。

                             ②然后再进行静态字段t的声明初始化,创建Test1的实例,调用实例构造方法,Test.a++,Test.b++,执行                     之后的结果是a=1,b=11。(大家对照这个流程,看一下上面的代码和运行结果)

     

    Program Ⅲ:(有静态块,静态块定义在声明初始化语句之后)

    class Test1 {
    	public Test1() {
    		System.out.println("Test1实例构造函数之前 a="+Test.a+",b="+Test.b);
    		Test.a++;
    		Test.b++;
    		System.out.println("Test1实例构造函数之后 a="+Test.a+",b="+Test.b);
    	}
    }
    public class Test {
    	public static Test1 t=new Test1();
    	public static int a;
    	public static int b=10;
    	static {
    		a=20;
    		System.out.println("static静态代码块1之后 a="+Test.a+",b="+Test.b);
    	}
    	static {
    		b=30;
    		System.out.println("static静态代码块2之后 a="+Test.a+",b="+Test.b);
    	}
    	public static void main(String[] args) {
    		System.out.println("最后的结果:a="+Test.a+",b="+Test.b);
    	}
    }

    Program Output Ⅲ:

    Program Analysis Ⅲ:

    按此顺序初始化静态变量:默认初始化→声明初始化→静态代码块初始化

    默认初始化:静态变量按照声明的顺序依次设置为该类型的默认值。

    声明初始化:静态变量按声明的顺序依次设置为声明初始化的值,如果没有声明初始化就跳过。 

    静态代码块初始化:按照静态代码块的顺序依次设置静态字段的值。

    静态字段初始化流程如下:

    1. 默认初始化:类被加载后,首先静态字段会进行默认初始化。 结果:t=null,a=0,b=0。

    2. 声明初始化:①首先进行静态字段t的声明初始化,创建Test1的实例,调用实力构造方法,执行之后的结果是a=1,b=1

                              ②进行静态字段a和b的声明初始化,因为静态字段a没有声明初始化,所以就跳过,结果还是a=1;但是静                    态字段b有声明初始化,所以结果是b=10。

    3. 静态代码块初始化:①首先执行静态代码块1,对静态字段a进行静态块初始化,结果是a=20,b=10。

                                         ②然后执行静态代码块2,对静态字段b进行静态块初始化,结果是a=20,b=30。(大家对照这个流程,看一下上面的代码和运行结果)

     

    Program Ⅳ:(有静态块,静态块定义在声明初始化语句之前)

    class Test1 {
    	public Test1() {
    		System.out.println("Test1实例构造函数之前 a="+Test.a+",b="+Test.b);
    		Test.a++;
    		Test.b++;
    		System.out.println("Test1实例构造函数之后 a="+Test.a+",b="+Test.b);
    	}
    }
    public class Test {
    	static {
    		a=20;
    		System.out.println("static静态代码块1之后 a="+Test.a+",b="+Test.b);
    	}
    	static {
    		b=30;
    		System.out.println("static静态代码块2之后 a="+Test.a+",b="+Test.b);
    	}
    	public static Test1 t=new Test1();
    	public static int a;
    	public static int b=10;
    	public static void main(String[] args) {
    		System.out.println("最后的结果:a="+Test.a+",b="+Test.b);
    	}
    }

    Program Output Ⅳ:

    Program Analysis Ⅳ:

    按此顺序初始化静态变量:默认初始化→静态代码块初始化→声明初始化

    默认初始化:静态变量按照声明的顺序依次设置为该类型的默认值。

    静态代码块初始化:按静态块的顺序依次设置静态字段的值。 

    声明初始化:静态变量按声明的顺序依次设置为声明初始化的值,如果没有声明初始化就跳过。

    静态字段初始化流程如下:

    1. 默认初始化:类被加载后,首先静态字段会进行默认初始化。 结果:t=null,a=0,b=0。

    2. 静态代码块初始化:①首先执行静态代码块1,对静态字段a进行静态块初始化,结果是a=20,b=0。

                                         ②然后执行静态代码块2,对静态字段b进行静态块初始化,结果是a=20,b=30。

    3. 声明初始化:①首先进行静态字段t的声明初始化,创建Test1的实例,调用实例构造方法,执行后的结果是a=21,b=31

                              ②然后进行静态字段a和b的声明初始化,因为静态字段a没有声明初始化,所以就跳过,结果还是a=21;                      但是静态字段b有声明初始化,所以结果是b=10。(大家对照这个流程,看一下上面的代码和运行结果)

     

    Program Ⅴ:(有静态块,声明初始化语句在两个静态块定义之间)

    class Test1 {
    	public Test1() {
    		System.out.println("Test1实例构造函数之前 a="+Test.a+",b="+Test.b);
    		Test.a++;
    		Test.b++;
    		System.out.println("Test1实例构造函数之后 a="+Test.a+",b="+Test.b);
    	}
    }
    public class Test {
    	static {
    		a=20;
    		System.out.println("static静态代码块1之后 a="+Test.a+",b="+Test.b);
    	}
    	public static Test1 t=new Test1();
    	public static int a;
    	public static int b=10;
    	static {
    		b=30;
    		System.out.println("static静态代码块2之后 a="+Test.a+",b="+Test.b);
    	}
    	public static void main(String[] args) {
    		System.out.println("最后的结果:a="+Test.a+",b="+Test.b);
    	}
    }

    Program Output Ⅴ:

    Program Analysis Ⅴ:

    按此顺序初始化静态变量:默认初始化→静态代码块1初始化→声明初始化→静态代码块2初始化

    默认初始化:静态变量按照声明的顺序依次设置为该类型的默认值。

    静态代码块初始化:按静态块的顺序依次设置静态字段的值。 

    声明初始化:静态变量按声明的顺序依次设置为声明初始化的值,如果没有声明初始化就跳过。

    静态字段初始化流程如下:

    1. 默认初始化:类被加载后,首先静态字段会进行默认初始化。 结果:t=null,a=0,b=0。

    2. 静态代码块1初始化:对静态字段a进行静态块初始化,结果a=20,b=0。

    3. 声明初始化:①首先进行静态字段t的声明初始化,创建Test1的实例,调用实例构造方法,执行之后结果是a=21,b=1。

                              ②然后进行静态字段a和b的声明初始化,因为静态字段a没有声明初始化,所以就跳过,结果还是a=21;                      但是静态字段b有声明初始化,所以结果是b=10。

    4. 静态代码块2初始化:对静态字段b进行静态块初始化,结果a=21,b=30。(大家对照这个流程,看一下上面的代码和运行结果)


    根据上面这五个Java小程序,大家可能觉得比较多,看起来不舒服,但是静态字段这部分内容还是很重要的!!!

    所以希望大家可以耐心的去理解每一个程序代码,对我们后面的Java知识的学习还是有很大帮助的!!!😊😊😊

    展开全文
  • 类的初始化顺序;字段和属性的定义 首先必须知道静态成员属于类,非静态成员属于对象 package static关键字; /* * 类的加载顺序:静态成员默认初始化(顺序)-静态成员显示初始化(顺序)-main方法。 如果有父类先...

    类的初始化顺序;字段和属性的定义

    首先必须知道静态成员属于类,非静态成员属于对象

    package static关键字;
    /*
     * 类的加载顺序:静态成员默认初始化(顺序)-静态成员显示初始化(顺序)-main方法。  如果有父类先执行父类的初始化(执行顺序一样)
     * 注意: 什么时候执行非静态成员呢?
     * 		只有实例化类之后才会执行非静态成员的,因为非静态成员是属于实例对象的,而静态成员是属于类的。
     * 		当创建了一个对象的时候,就需要对其进行初始化-顺序:
     * 							非静态成员-构造方法	
     * 		
     */
    public class StaticTest {
        public static int k = 0;//1
        public static StaticTest t1 = new StaticTest("t1");//2-4
        /*这里创建了一个类对象,那么就必须对其进行初始化:
         * 		按照顺序来:j-构造代码块-构造方法
         * 		(这里必须知道一件事对于i和n只进行了默认初始化所以它的值是0(int型))
         */
        public static StaticTest t2 = new StaticTest("t2");//5-7
        /*
         * 这里同上
         */
        public static int i = print("i");//8
        public static int n = 99;
        public int j = print("j");
        {
            print("构造快");
        }
        static{
            print("静态块");
        }
        public StaticTest(String str) {
            System.out.println((++k) + ":" + str + " i=" + i + " n=" + n);
            ++n;
            ++i;
        }
        public static int print(String str) {
            System.out.println((++k) + ":" + str + " i=" + i + " n=" + n);
            ++i;
            return ++n;
        }
        public static void main(String[] args) {
            StaticTest t = new StaticTest("init");//9-11  
            System.out.println("i="+StaticTest.i+",k="+StaticTest.k+",n="+StaticTest.n+",j="+t.j);//12
        }
    }
    

    以下转载自于--------------- 作者:chunlynn 来源:CSDN 原文:
    https://blog.csdn.net/chenchunlin526/article/details/71424844?utm_source=copy

    字段和属性的定义

    字段(field):

    通常叫做“类成员”,或 "类成员变量”,有时也叫“域”,理解为“数据成员”,用来承载数据的。

    public class A{
        private int b;
    }
    

    从上面的例子我们可以说类A有一个成员变量b或者说类A中有一个字段b。字段一般是用来承载数据的,为了安全我们一般将其设置为私有的。既然是私有的那么我们该如何访问这个字段呢?-那就必须通过属性方法来访问!

    属性

    就是字面上的意思(想不出词!)

    属性只局限于类中方法的声明,并不与类中其他成员相关,属于JavaBean的范畴。例如:

    void setA(String s){}

    String getA(){}

    当一个类中拥有这样一对方法时,我们可以说,这个类中拥有一个可读写的a属性(注意是小写a)。如果去掉了set的方法,则是可读属性,反之亦然。

    public class User {
        private String id; //私有字段    
        private String name; //私有字段    
        private String identifier = "440282199008098076"; //私有字段
        public String getId() { 
            //id的可读属性        
            return id;    
        }    
        public void setId(String id) { 
            //id的可写属性        
            this.id = id;    
        }
        public String getName() { 
            //name的可读属性        
            return name;    
        }    
        public void setName(String name) { 
        	//name的可写属性        
        	this.name = name;    
        }
        public String getIdentifier() { 
        	//identifier只有一个get方法,所以它是只读属性
            return identifier;    
        }
        public final static Integer SHOW_STATUS_YES = 1; //公共字段   
        public final static Integer SHOW_STATUS_No = 0; //公共字段
    }
    
    
    

    当我操作这个类时,比如调用getName()方法时,我们要说是获得name属性,调用setName(String name)方法时要说设置name属性,因为对我们来说name字段是私有的,我们操作该Person类时根本看不到有这个name字段 。

    一个类主要包括字段、属性和方法。属性在此时指的就是get/set访问器。

    同时我们可以看到,这个类有3个属性,5个字段。

    SHOW_STATUS_YES 为公用字段,一般修饰为final static类型,可以通过User类直接访问该字段。

    getIdentifier为只读属性,只能读取私有的identifier字段,这样就起到了保护数据的安全性的作用。

    id和name为私有字段,且有两个操作他们的public属性。可以通过getId()、setId(String id)、getName()、setName(String name)来读取和设置他们的值。

    更形象的说就是:属性是对字段的封装,供外部访问。

    通常属性将相应的私有字段通过封装成公共属性,以便于外界访问和修改。当然你在封装成属性时,也可以设置该属性为只读,可读写等等权限。

    展开全文
  • 首先解释一下内联初始化的内联意思:就是在声明字段的时候同时进行初始化赋值。举个简单例子就是:class SomeType(){int x = 5;}这里为x赋值为5实际上发生在SomeType构造器中,IL代码可以作证:SomeType构造...

    首先解释一下内联初始化的内联的意思:就是在声明字段的时候同时进行初始化赋值。

    举个简单的例子就是:
    class SomeType()
    {
          int x = 5;
    }
    这里为x赋值为5实际上发生在SomeType的构造器中,IL代码可以作证:
    SomeType的构造函数的IL代码如下:

    None.gif.method public hidebysig specialname rtspecialname 
    None.gif        instance 
    void  .ctor() cil managed
    ExpandedBlockStart.gifContractedBlock.gif
    dot.gif{
    InBlock.gif  
    // 代码大小       14 (0xe)
    InBlock.gif
      .maxstack  2
    InBlock.gif  IL_0000:  ldarg.
    0
    InBlock.gif  IL_0001:  ldc.i4.
    5
    InBlock.gif  IL_0002:  stfld      int32 SomeType::x
    InBlock.gif  IL_0007:  ldarg.
    0
    InBlock.gif  IL_0008:  call       instance 
    void [mscorlib]System.Object::.ctor()
    InBlock.gif  IL_000d:  ret
    ExpandedBlockEnd.gif}
     // end of method SomeType::.ctor
    None.gif

    None.gif

    我们可以看到确实如此。
    所以说内联初始化字段只是C#提供的一种简化语法,但是往往会造成代码的膨胀。

    比如说:

    None.gifclass SomeType
    ExpandedBlockStart.gifContractedBlock.gif
    dot.gif{
    InBlock.gif    
    int x = 5;
    InBlock.gif    
    string s = "Hi there";
    InBlock.gif    
    double d = 3.14159;
    InBlock.gif    
    byte b;
    InBlock.gif    
    InBlock.gif    
    public SomeType()
    ExpandedSubBlockStart.gifContractedSubBlock.gif    
    dot.gif{}
    InBlock.gif    
    public SomeType(int x)
    ExpandedSubBlockStart.gifContractedSubBlock.gif    
    dot.gif{
    ExpandedSubBlockEnd.gif    }

    InBlock.gif    
    public SomeType(string s)
    ExpandedSubBlockStart.gifContractedSubBlock.gif    
    dot.gif{
    ExpandedSubBlockEnd.gif    }

    ExpandedBlockEnd.gif}

    编译以后查看IL代码:
    其中有三个构造函数:
    .ctor : void(int32)的代码为:
    None.gif.method public hidebysig specialname rtspecialname 
    None.gif        instance 
    void  .ctor(int32 x) cil managed
    ExpandedBlockStart.gifContractedBlock.gif
    dot.gif{
    InBlock.gif  
    // 代码大小       40 (0x28)
    InBlock.gif
      .maxstack  2
    InBlock.gif  IL_0000:  ldarg.
    0
    InBlock.gif  IL_0001:  ldc.i4.
    5
    InBlock.gif  IL_0002:  stfld      int32 SomeType::x
    InBlock.gif  IL_0007:  ldarg.
    0
    InBlock.gif  IL_0008:  ldstr      
    "Hi there"
    InBlock.gif  IL_000d:  stfld      
    string SomeType::s
    InBlock.gif  IL_0012:  ldarg.
    0
    InBlock.gif  IL_0013:  ldc.r8     
    3.1415899999999999
    InBlock.gif  IL_001c:  stfld      float64 SomeType::d
    InBlock.gif  IL_0021:  ldarg.
    0
    InBlock.gif  IL_0022:  call       instance 
    void [mscorlib]System.Object::.ctor()
    InBlock.gif  IL_0027:  ret
    ExpandedBlockEnd.gif}
     // end of method SomeType::.ctor
    None.gif

    .ctor : void(string)的IL代码:

    None.gif.method public hidebysig specialname rtspecialname 
    None.gif        instance 
    void  .ctor(string s) cil managed
    ExpandedBlockStart.gifContractedBlock.gif
    dot.gif{
    InBlock.gif  
    // 代码大小       40 (0x28)
    InBlock.gif
      .maxstack  2
    InBlock.gif  IL_0000:  ldarg.
    0
    InBlock.gif  IL_0001:  ldc.i4.
    5
    InBlock.gif  IL_0002:  stfld      int32 SomeType::x
    InBlock.gif  IL_0007:  ldarg.
    0
    InBlock.gif  IL_0008:  ldstr      
    "Hi there"
    InBlock.gif  IL_000d:  stfld      
    string SomeType::s
    InBlock.gif  IL_0012:  ldarg.
    0
    InBlock.gif  IL_0013:  ldc.r8     
    3.1415899999999999
    InBlock.gif  IL_001c:  stfld      float64 SomeType::d
    InBlock.gif  IL_0021:  ldarg.
    0
    InBlock.gif  IL_0022:  call       instance 
    void [mscorlib]System.Object::.ctor()
    InBlock.gif  IL_0027:  ret
    ExpandedBlockEnd.gif}
     // end of method SomeType::.ctor

    .ctor : void()的IL代码为:

    None.gif.method public hidebysig specialname rtspecialname 
    None.gif        instance 
    void  .ctor() cil managed
    ExpandedBlockStart.gifContractedBlock.gif
    dot.gif{
    InBlock.gif  
    // 代码大小       40 (0x28)
    InBlock.gif
      .maxstack  2
    InBlock.gif  IL_0000:  ldarg.
    0
    InBlock.gif  IL_0001:  ldc.i4.
    5
    InBlock.gif  IL_0002:  stfld      int32 SomeType::x
    InBlock.gif  IL_0007:  ldarg.
    0
    InBlock.gif  IL_0008:  ldstr      
    "Hi there"
    InBlock.gif  IL_000d:  stfld      
    string SomeType::s
    InBlock.gif  IL_0012:  ldarg.
    0
    InBlock.gif  IL_0013:  ldc.r8     
    3.1415899999999999
    InBlock.gif  IL_001c:  stfld      float64 SomeType::d
    InBlock.gif  IL_0021:  ldarg.
    0
    InBlock.gif  IL_0022:  call       instance 
    void [mscorlib]System.Object::.ctor()
    InBlock.gif  IL_0027:  ret
    ExpandedBlockEnd.gif}
     // end of method SomeType::.ctor

    这回清楚了吧,三个构造函数初始化了三次。所以最好避免在声明的时候初始化字段,而放在构造其中去进行,这样有助于减小代码尺寸,所以我们改写如下(假设每个构造器都需要初始化这些字段):

    None.gifclass SomeType
    ExpandedBlockStart.gifContractedBlock.gif
    dot.gif{
    InBlock.gif    
    int x;
    InBlock.gif    
    string s;
    InBlock.gif    
    double d;
    InBlock.gif    
    byte b;
    InBlock.gif    
    InBlock.gif    
    public SomeType()
    ExpandedSubBlockStart.gifContractedSubBlock.gif    
    dot.gif{
    InBlock.gif        x 
    = 5;
    InBlock.gif        s 
    = "Hi there";
    InBlock.gif        d 
    = 3.14159;
    ExpandedSubBlockEnd.gif    }

    InBlock.gif    
    public SomeType(int x) : this()
    ExpandedSubBlockStart.gifContractedSubBlock.gif    
    dot.gif{
    InBlock.gif        
    this.x = x;
    ExpandedSubBlockEnd.gif    }

    InBlock.gif    
    public SomeType(string s) : this()
    ExpandedSubBlockStart.gifContractedSubBlock.gif    
    dot.gif{
    InBlock.gif        
    this.s = s;
    ExpandedSubBlockEnd.gif    }

    ExpandedBlockEnd.gif}

    我们把公共的初始化代码放到默认构造器中,其他的构造器都先调用默认构造器就达到了我们的目的。

    转载于:https://www.cnblogs.com/wdxinren/archive/2005/05/17/157465.html

    展开全文
  • 3. 当创建一个类的实例时,初始化实例字段 4. 静态或实例 字段间的初始化顺序与在类的定义时,字段所处的行号顺序一致 5. 静态字段初始化过程: 1)类载入虚拟机时,分配静态字段所需内存,并清空内存,实际上就是...

    4 . 4  成员初始化;6 . 9 初始化和类装载


    构建器的调用遵照下面的顺序:
    (1) 调用基础类构建器。这个步骤会不断重复下去,首先得到构建的是分级结构的根部,然后是下一个衍生
    类,等等。直到抵达最深一层的衍生类。
    (2) 按声明顺序调用成员初始化模块。
    (3) 调用衍生构建器的主体。


    0. 先初始化父类字段

    1. 先静态字段,再实例字段

    2. 当类载入虚拟机时(第一次调用静态字段,或静态方法,或实例化一个对象),初始化静态字段

    3. 当创建一个类的实例时,初始化实例字段

    4. 静态或实例 字段间的初始化顺序与在类的定义时,字段所处的行号顺序一致

    5. 静态字段初始化过程:

    1)类载入虚拟机时,分配静态字段所需内存,并清空内存,实际上就是置0:简单数据类型均为0值,布尔型为false,引用类型为null

    2)执行字段定义时的赋值操作

    3)执行静态初始化块的赋值操作

    6. 实例字段初始化过程:

    1)新建一个对象时,分配对象所需内存,当然也包括实例字段所需内存,并清空内存,实际上就是置0:简单数据类型均为0值,布尔型为false,引用类型为null

    2)执行字段定义时的赋值操作

    3)执行实例初始化块的赋值操作

    4)执行构造方法里的赋值操作


    7. 载入一个类时,若检测到它有父类,则先载入它的父类,如此递推的找到继承的根类,从根类往下执行载入


    8. 方法内定义的局部变量,与类成员字段不同,方法内的局部变量定义时不会执行清空内存操作,所以必须进行赋值,初始化之后才能使用这些局部变量



    9. 代码示例

    class CA

    {

    int i;

    CA(int i)

    {

    this.i = i;

    }

    }


    class Test

    {

    static int snum1;

    static int snum2 = 2;//定义时的赋值操作

    static CA sca1;

    static CA sca2 = new CA(2);

    static

    {//静态初始化话块里的的赋值操作

    snum1 = 1;

    snum2 = 22;

    sca1 = new CA(1);

    }


    int num3;

    int num4 = 4;//定义时的赋值操作

    CA ca3 = null;

    CA ca4 = new CA(4);

    {//实例初始化话块里的的赋值操作

    num3 = 3;

    num4 = 44;

    ca3 = new CA(3);

    }


    Test()

    {{//构造方法里的的赋值操作

    num4 = 444;

    ca4 = new CA(44);

    }

    }

    snum2 初始化过程中值的变化为:0(清空内存)、2(定义时赋值)、22(静态初始化块内赋值)

    num4 初始化过程中值的变化为:0(清空内存)、4(定义时赋值)、44(实例初始化块内赋值)、444()构造方法内赋值




    展开全文
  • 类的初始化

    2013-04-09 14:32:15
    在C#中,类的初始化顺序是: ...1、首先,初始化类的实例字段; 2、其次,调用基类的构造函数,没有明确的基类则调用System.Object的构造函数; 3、最后,调用自己的构造函数  类的初始化顺序图 na
  • 子类的实例字段 父类的静态字段 父类的静态构造方法 父类的实例字段 父类的实例构造方法 java 初始化顺序 初始化过程: 1. 初始化父类中的静态成员变量和静态代码块(从上到下的顺序) ; 2. 初始化子中的...
  • 标记为const的字段只能在编译时初始化。你需要在运行时而不是在编译时将一个字段初始化为一个有效值。然后在应用程序剩余生命周期内,这个字段必须像一个常量字段那样工作。 解决方案: 在代码中声明一个常量时...
  • 你需要能够控制结构的初始化,取决于是否想要将结构所有内部字段初始化为基于字段类型标准默认值(例如,int 初始化为0,string 初始化为空字符串),或者初始化为一组非标准默认值,或者初始化为一组预定义...
  • 关于JAVA类的初始化(1)classLoad时候的初始化.classLoad时根据书写顺序初始化class字段和方法在任何方法之前.并不初始化静态字段和方法,构造函数可作为static看只有当class被实例化并被使用或作为类变量使用时才初始...
  • 在一个静态初始化程序求值时候,或者静态字段初始化的时候发生了异常,就会抛出一个ExceptionInInitializerError异常。 JDK中对NoClassDefFoundError描述是: JVM(Java虚拟机)或者装载器(ClassLoader)实例.....
  • 然后,从Person派生出一个学生Student,为其扩展出一个学号字段,同时为学生创建构造函数来初始化其三个字段,要求其中从父类中继承的字段由父类构造函数负责初始化。请利用静态字段的知识在学生中增加...
  • 以及类实例的初始化

    千次阅读 2006-08-26 16:59:00
    java虚拟机会在6种情况下初始化一个类对象,这六种情况称为主动使用,分别是:l 创建类的实例l 调用类中声明的静态方法l 操作类或接口中声明的非常量静态字段l 调用Java API中特定的反射方法l 初始化一个类的...
  • 初始化必须发生在装载、连接以后,Java虚拟机一般会在每个类或接口主动使用时才会对类型进行初始 化。下面六中情形符合主动使用的要求: 1.当创建某个类的实例时。注:包括创建的所有方式,如new、反射、克隆...
  • java类的初始化

    2019-04-28 13:41:27
    java类的初始化 对于一般的java类,其中包含的字段有类字段(static),实例字段。对于每个字段的初始化方式也有多种: 直接初始化。 使用初始化块。对于实例字段,使用static初始化块;对于实例字段,使用一般初始...
  • Java字段初始化的规律

    2019-09-22 16:45:20
    静态初始化块是中由static修饰的初始化块,实例初始化块为中没有任何关键字修饰的初始化语句。 如果在主函数中创建对象时没有形参时,如果在中定义了公共变量并给与了赋值,那么就会把值赋给主函数中变量...
  • 实例代码 package text; public class MethodOverload { /** * @param args */ public static void main(String[] args) { InitializeBlockClass obj=new Initializ...
  • C#本质上是一组类型声明(区别于...初始化是指为分配好内存空间对象赋值过程。 一些字段的创建也是按照上述流程。 例如: int a; //int这种类型本来就是封装好类型,它声明包含在其他命名空间中,这里是...
  • 刚学习C#时,在内定义变量时,经常会出现标题内容问题,即字段初始值无法引用非静态字段、方法或属性。这是为什么呢? 下面我们拿一个小程序来举例子。关于ArrayList 实例t3种不同生成方法。 class ...
  • 首次加载类时(创建对象/调用类的静态成员),java解释器必须查找类的路径,定位并载入其class文件。之后执行所有静态(static)初始化动作。...之后执行所有非静态字段(成员变量)的初始化。 最后执行构造器方法。
  • 类初始化首次访问时,通过分配编译时间常数字段,然后递归初始化超类(如果尚未初始化),然后处理静态初始化程序(包括用于非编译时静态字段的初始化程序),来初始化类或接口。常数)。您已经注意到,类的初始化本身...
  • Java字段初始化规律:

    2015-10-16 07:41:00
    Java字段初始化规律: Java进行初始化的地方有两个,初始化块和...执行类成员定义时指定的默认值或类的初始化块,到底执行哪一个要看哪一个“排在前面”。 当有两个构造函数时依据参数个数进行引用 转载于:http...
  • 使用了继承之后,当我们初始化一个子类时,除了会调用子类的... (1)初始化类的实例字段;  (2)调用基类的构造函数;  (3)调用子类的构造函数; 转载于:https://www.cnblogs.com/158-186/p/10552136.html...
  • 因为根据结构不同,成员的初始化顺序并不是一成不变。但是这个顺序是基础,可以推导出其他特殊的初始化顺序。下面我们就来看两种特殊情况: static void Main(string[] args) { Console.WriteLine(-----...
  • 使用了继承之后,当... ① 初始化类的实例字段;  ② 调用基类的构造函数,如果没有指明基类,则调用System.Object的构造函数;  ③ 调用子类的构造函数。  如下实例:   static void Main(string[]...
  • Java何时初始化final字段

    千次阅读 2017-02-19 01:18:02
    不可变的类的实例有天然是线程安全的优势,在写不可变类的时候经常用到final字段, 比如: private final String name;但是这样写,一般的IDE应该会给出错误提示,说你没有正确的初始化。那么, 为什么final字段需要...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,362
精华内容 544
关键字:

初始化类的实例字段