精华内容
下载资源
问答
  • 构造代码块 和 构造方法 执行顺序
    千次阅读
    2019-01-03 11:42:57

    构造代码块:定义在类的成员位置,直接使用{ },在{}中写代码内容。

    位置:类中,方法外,和方法并列,和先后位置无关。

    执行时机:创建对象的时候执行一次。在构造方法隐式3步的最后一步。当构造代码块执行结束之后,开始执行构造方法本身的代码内容

    格式:

    public class ClassName{
      // 构造代码块
      {
        // 执行语句 
      }
    }

    构造代码块和构造方法执行顺序:

    
    class ConsCode{
        // 成员变量
        int a;
        int b;
    
        // 空参构造
        public ConsCode() {
            //System.out.println("HelloWorld!");
          	System.out.println("11我在构造代码块执行结束之后执行...");
        }
    
        // 给变量a赋值的构造
        public ConsCode(int a) {
            this.a = a;
          	System.out.println("22我在构造代码块执行结束之后执行...");
            //System.out.println("HelloWorld!");
        }
    
        // 给变量ab同时赋值的构造
        public ConsCode(int a , int b) {
            this.a = a;
            this.b = b;
            //System.out.println("HelloWorld!");
          	System.out.println("33我在构造代码块执行结束之后执行...");
        }
    
        // 构造代码块
        {
            System.out.println("构造代码块!。。。。。。。。。。。。。。。");
        }
    }
    public class ConstructorCodeDemo {
        public static void main(String[] args) {
            // 分别使用3个构造方法创建对象,并运行程序,显示执行3遍HelloWorld!
            ConsCode c1 = new ConsCode();
            ConsCode c2 = new ConsCode(10);
            ConsCode c3 = new ConsCode(10,20);
        }
    }

    更多相关内容
  • 下面小编就为大家带来一篇java中的静态代码块、构造代码块、构造方法详解。小编觉得挺好的,现在分享给大家。给大家一个参考。一起跟随小编过来看看吧
  • 主要介绍了Java构造代码块,静态代码块,结合实例形式分析了Java构造代码块,静态代码块的功能、原理、用法及操作注意事项,需要的朋友可以参考下
  • java中的构造代码块和构造函数.pdf
  • 主要介绍了Java中普通代码块、构造代码块与静态代码块的相关资料,静态代码块>Main()>构造代码块。非常不错,具有参考借鉴价值,需要的朋友可以参考下
  • 主要介绍了Java 中普通代码块,构造代码块,静态代码块区别及代码示例的相关资料,需要的朋友可以参考下
  • 构造代码块和静态代码块的执行时机
  • 构造代码块 构造函数之间的调用 static关键字
    构造代码块
    • 特点:对象一建立就运行了,而且优先于构造函数执行
    • 作用:给对象进行初始化
    • 构造代码块与构造方法区别:
    • 构造代码块是给所有的对象进行统一的初始化
    • 构造方法是对应的对象进行初始化
    public class test10 {
    	public static void main(String[] args){
    		Person2 A = new Person2();
    		Person2 B = new Person2("小虎鲸");
    		System.out.println(A);
    		System.out.println(B);
    	}
    }
    
    class Person2{
    	String name;
    	//无参构造方法
    	Person2(){
    		System.out.println("无参构造方法");
    	}
    	//有参构造方法
    	Person2(String name){
    		this.name = name;
    		System.out.println("有参构造方法");
    	}
    	//构造代码块
    	{
    		System.out.println("构造代码块");
    	}
    }
    

    
    public class test11_student {
    	public static void main(String[] args){
    		Student2 A = new Student2();
    		Student2 B = new Student2("小虎鲸",5);
    		System.out.println(A);
    		System.out.println(B);
    	}
    }
    
    class Student2{
    	String name;
    	int age;
    	Student2(){
    		System.out.println("无参构造函数");
    	}
    	Student2(String name, int age){
    		this.name = name;
    		this.age = age;
    		System.out.println(this.name+this.age);
    	}
    	{
    		System.out.println("coding");
    	}
    }
    
    构造函数之间的调用
    public class test12 {
    	public static void main(String[] args){
    		Student3 A = new Student3("小虎鲸");
    		Student3 B = new Student3("彩虹鲸",12);
    		System.out.println(A);
    		System.out.println(B);
    	}
    }
    
    class Student3{
    	String name;
    	int age;
    	Student3(){
    		System.out.println("无参构造函数");
    	}
    	Student3(String name){
    		this();
    		this.name = name;
    		System.out.println("aaa");
    	}
    	Student3(String name, int age){
    		this(name);
    		this.age = age;
    		System.out.println("bbb");
    	}
    }
    
    • 构造函数之间的调用只能通过this语句来完成
    • this 用来区分局部变量和成员变量同名的情况
    • this 代表本类对象,this代表它所在函数所属对象的引用
    • 构造函数之间调用this语句时,只能出现在第一行,构造方法要先执行,乳沟构造方法中还有初始化,那就执行更细节的初始化

    例:
    在这里插入图片描述

    public class test13 {
    	public static void main(String[] args){
    		Student5 A = new Student5("karry",21,"China");
    		System.out.println(A);
    	}
    }
    
    class Student5{
    	String name;
    	int age;
    	String country;
    	Student5(String name){
    		this.name = name;
    		System.out.println(this.name);
    	}
    	Student5(String name, int age){
    		this(name);
    		this.age = age;
    		System.out.println(this.age);
    	}
    	Student5(String name, int age, String country){
    		this(name,age);
    		this.country = country;
    		System.out.println(this.country );
    	}
    }
    
    展开全文
  • Java提高篇——静态代码块、构造代码块、构造函数以及Java类初始化顺序阅读目录构造函数构造代码块静态代码块Java类初始化顺序静态代码块:用staitc声明,jvm加载类时执行,仅执行一次构造代码块:类中直接用{}定义...

    Java提高篇——静态代码块、构造代码块、构造函数以及Java类初始化顺序

    静态代码块:用staitc声明,jvm加载类时执行,仅执行一次
    构造代码块:类中直接用{}定义,每一次创建对象时执行。
    执行顺序优先级:静态块,main(),构造块,构造方法。

    构造函数

    public HelloA(){//构造函数
        }

    关于构造函数,以下几点要注意:
    1.对象一建立,就会调用与之相应的构造函数,也就是说,不建立对象,构造函数时不会运行的。
    2.构造函数的作用是用于给对象进行初始化。
    3.一个对象建立,构造函数只运行一次,而一般方法可以被该对象调用多次。

    构造代码块

    {//构造代码块    
    }

    关于构造代码块,以下几点要注意:

    1. 构造代码块的作用是给对象进行初始化。
    2. 对象一建立就运行构造代码块了,而且优先于构造函数执行。这里要强调一下,有对象建立,才会运行构造代码块,类不能调用构造代码块的,而且构造代码块与构造函数的执行顺序是前者先于后者执行
    3. 构造代码块与构造函数的区别是:构造代码块是给所有对象进行统一初始化,而构造函数是给对应的对象初始化,因为构造函数是可以多个的,运行哪个构造函数就会建立什么样的对象,但无论建立哪个对象,都会先执行相同的构造代码块。也就是说,构造代码块中定义的是不同对象共性的初始化内容。

    静态代码块

    static {//静态代码块    
    }

    关于静态代码块,要注意的是:

    1. 它是随着类的加载而执行,只执行一次,并优先于主函数。具体说,静态代码块是由类调用的。类调用时,先执行静态代码块,然后才执行主函数的。
    2. 静态代码块其实就是给类初始化的,而构造代码块是给对象初始化的
    3. 静态代码块中的变量是局部变量,与普通函数中的局部变量性质没有区别。
    4. 一个类中可以有多个静态代码块
    复制代码
    public class Test{
    staitc int cnt=6;
    static{
          cnt+=9;
    }
    public static void main(String[] args) {
          System.out.println(cnt);
    }
    static{
          cnt/=3;
    }
    }
    运行结果:
    5
    复制代码

    Java类初始化顺序

    ## 对于一个类的情况

    例子1:

    复制代码
    public class HelloA {
        public HelloA(){//构造函数
            System.out.println("A的构造函数");    
        }
        {//构造代码块
            System.out.println("A的构造代码块");    
        }
        static {//静态代码块
            System.out.println("A的静态代码块");        
        }
        public static void main(String[] args) {
        }
    }
    运行结果:
    A的静态代码块
    复制代码

    例子2:

    复制代码
    public class HelloA {
        public HelloA(){//构造函数
            System.out.println("A的构造函数");    
        }
        {//构造代码块
            System.out.println("A的构造代码块");    
        }
        static {//静态代码块
            System.out.println("A的静态代码块");        
        }
        public static void main(String[] args) {
            HelloA a=new HelloA();    
        }
    }
    
    运行结果:
    A的静态代码块
    A的构造代码块
    A的构造函数
    复制代码

    例子3:

    复制代码
    public class HelloA {
        public HelloA(){//构造函数
            System.out.println("A的构造函数");    
        }
        {//构造代码块
            System.out.println("A的构造代码块");    
        }
        static {//静态代码块
            System.out.println("A的静态代码块");        
        }
        public static void main(String[] args) {
            HelloA a=new HelloA();
            HelloA b=new HelloA();
        }
    
    }
    
    运行结果:
    A的静态代码块
    A的构造代码块
    A的构造函数
    A的构造代码块
    A的构造函数
    复制代码

    对于一个类而言,按照如下顺序执行:

    1. 执行静态代码块
    2. 执行构造代码块
    3. 执行构造函数

    对于静态变量、静态初始化块、变量、初始化块、构造器,它们的初始化顺序依次是(静态变量、静态初始化块)>(变量、初始化块)>构造器。

    例子4:

    复制代码
     1 public class InitialOrderTest {
     2         /* 静态变量 */
     3     public static String staticField = "静态变量";
     4         /* 变量 */
     5     public String field = "变量";
     6         /* 静态初始化块 */
     7     static {
     8         System.out.println( staticField );
     9         System.out.println( "静态初始化块" );
    10     }
    11         /* 初始化块 */
    12     {
    13         System.out.println( field );
    14         System.out.println( "初始化块" );
    15     }
    16         /* 构造器 */
    17     public InitialOrderTest()
    18     {
    19         System.out.println( "构造器" );
    20     }
    21 
    22 
    23     public static void main( String[] args )
    24     {
    25         new InitialOrderTest();
    26     }
    27 }
    复制代码

    运行以上代码,我们会得到如下的输出结果:

    1. 静态变量

    2. 静态初始化块

    3. 变量

    4. 初始化块

    5. 构造器

    ## 对于继承情况

    例子5:

    复制代码
    public class HelloA {
        public HelloA(){//构造函数
            System.out.println("A的构造函数");    
        }
        {//构造代码块
            System.out.println("A的构造代码块");    
        }
        static {//静态代码块
            System.out.println("A的静态代码块");        
        }
    }
    public class HelloB extends HelloA{
        public HelloB(){//构造函数
            System.out.println("B的构造函数");    
        }
        {//构造代码块
            System.out.println("B的构造代码块");    
        }
        static {//静态代码块
            System.out.println("B的静态代码块");        
        }
        public static void main(String[] args) {
            HelloB b=new HelloB();        
        }
    }
    运行结果:
    A的静态代码块
    B的静态代码块
    A的构造代码块
    A的构造函数
    B的构造代码块
    B的构造函数
    复制代码

    当涉及到继承时,按照如下顺序执行:

    1. 执行父类的静态代码块,并初始化父类静态成员变量
    2. 执行子类的静态代码块,并初始化子类静态成员变量
    3. 执行父类的构造代码块,执行父类的构造函数,并初始化父类普通成员变量
    4. 执行子类的构造代码块, 执行子类的构造函数,并初始化子类普通成员变量
    Java初始化顺序如图:

     

    例子6:

    复制代码
     1 class Parent {
     2         /* 静态变量 */
     3     public static String p_StaticField = "父类--静态变量";
     4          /* 变量 */
     5     public String    p_Field = "父类--变量";
     6     protected int    i    = 9;
     7     protected int    j    = 0;
     8         /* 静态初始化块 */
     9     static {
    10         System.out.println( p_StaticField );
    11         System.out.println( "父类--静态初始化块" );
    12     }
    13         /* 初始化块 */
    14     {
    15         System.out.println( p_Field );
    16         System.out.println( "父类--初始化块" );
    17     }
    18         /* 构造器 */
    19     public Parent()
    20     {
    21         System.out.println( "父类--构造器" );
    22         System.out.println( "i=" + i + ", j=" + j );
    23         j = 20;
    24     }
    25 }
    26 
    27 public class SubClass extends Parent {
    28          /* 静态变量 */
    29     public static String s_StaticField = "子类--静态变量";
    30          /* 变量 */
    31     public String s_Field = "子类--变量";
    32         /* 静态初始化块 */
    33     static {
    34         System.out.println( s_StaticField );
    35         System.out.println( "子类--静态初始化块" );
    36     }
    37        /* 初始化块 */
    38     {
    39         System.out.println( s_Field );
    40         System.out.println( "子类--初始化块" );
    41     }
    42        /* 构造器 */
    43     public SubClass()
    44     {
    45         System.out.println( "子类--构造器" );
    46         System.out.println( "i=" + i + ",j=" + j );
    47     }
    48 
    49 
    50         /* 程序入口 */
    51     public static void main( String[] args )
    52     {
    53         System.out.println( "子类main方法" );
    54         new SubClass();
    55     }
    56 }
    复制代码

    结果:

    父类--静态变量
    父类--静态初始化块
    子类--静态变量
    子类--静态初始化块
    子类main方法
    父类--变量
    父类--初始化块
    父类--构造器
    i=9, j=0
    子类--变量
    子类--初始化块
    子类--构造器
    i=9,j=20

    子类的静态变量和静态初始化块的初始化是在父类的变量、初始化块和构造器初始化之前就完成了。静态变量、静态初始化块,变量、初始化块初始化了顺序取决于它们在类中出现的先后顺序。

    ### 分析

    • (1)访问SubClass.main(),(这是一个static方法),于是装载器就会为你寻找已经编译的SubClass类的代码(也就是SubClass.class文件)。在装载的过程中,装载器注意到它有一个基类(也就是extends所要表示的意思),于是它再装载基类。不管你创不创建基类对象,这个过程总会发生。如果基类还有基类,那么第二个基类也会被装载,依此类推。

    • (2)执行根基类的static初始化,然后是下一个派生类的static初始化,依此类推。这个顺序非常重要,因为派生类的“static初始化”有可能要依赖基类成员的正确初始化。

    • (3)当所有必要的类都已经装载结束,开始执行main()方法体,并用new SubClass()创建对象。

    • (4)类SubClass存在父类,则调用父类的构造函数,你可以使用super来指定调用哪个构造函数。基类的构造过程以及构造顺序,同派生类的相同。首先基类中各个变量按照字面顺序进行初始化,然后执行基类的构造函数的其余部分。

    • (5)对子类成员数据按照它们声明的顺序初始化,执行子类构造函数的其余部分。

    原博客:

    Java提高篇——静态代码块、构造代码块、构造函数以及Java类初始化顺序

    静态代码块:用staitc声明,jvm加载类时执行,仅执行一次
    构造代码块:类中直接用{}定义,每一次创建对象时执行。
    执行顺序优先级:静态块,main(),构造块,构造方法。

    构造函数

    public HelloA(){//构造函数
        }

    关于构造函数,以下几点要注意:
    1.对象一建立,就会调用与之相应的构造函数,也就是说,不建立对象,构造函数时不会运行的。
    2.构造函数的作用是用于给对象进行初始化。
    3.一个对象建立,构造函数只运行一次,而一般方法可以被该对象调用多次。

    构造代码块

    {//构造代码块    
    }

    关于构造代码块,以下几点要注意:

    1. 构造代码块的作用是给对象进行初始化。
    2. 对象一建立就运行构造代码块了,而且优先于构造函数执行。这里要强调一下,有对象建立,才会运行构造代码块,类不能调用构造代码块的,而且构造代码块与构造函数的执行顺序是前者先于后者执行
    3. 构造代码块与构造函数的区别是:构造代码块是给所有对象进行统一初始化,而构造函数是给对应的对象初始化,因为构造函数是可以多个的,运行哪个构造函数就会建立什么样的对象,但无论建立哪个对象,都会先执行相同的构造代码块。也就是说,构造代码块中定义的是不同对象共性的初始化内容。

    静态代码块

    static {//静态代码块    
    }

    关于静态代码块,要注意的是:

    1. 它是随着类的加载而执行,只执行一次,并优先于主函数。具体说,静态代码块是由类调用的。类调用时,先执行静态代码块,然后才执行主函数的。
    2. 静态代码块其实就是给类初始化的,而构造代码块是给对象初始化的
    3. 静态代码块中的变量是局部变量,与普通函数中的局部变量性质没有区别。
    4. 一个类中可以有多个静态代码块
    复制代码
    public class Test{
    staitc int cnt=6;
    static{
          cnt+=9;
    }
    public static void main(String[] args) {
          System.out.println(cnt);
    }
    static{
          cnt/=3;
    }
    }
    运行结果:
    5
    复制代码

    Java类初始化顺序

    ## 对于一个类的情况

    例子1:

    复制代码
    public class HelloA {
        public HelloA(){//构造函数
            System.out.println("A的构造函数");    
        }
        {//构造代码块
            System.out.println("A的构造代码块");    
        }
        static {//静态代码块
            System.out.println("A的静态代码块");        
        }
        public static void main(String[] args) {
        }
    }
    运行结果:
    A的静态代码块
    复制代码

    例子2:

    复制代码
    public class HelloA {
        public HelloA(){//构造函数
            System.out.println("A的构造函数");    
        }
        {//构造代码块
            System.out.println("A的构造代码块");    
        }
        static {//静态代码块
            System.out.println("A的静态代码块");        
        }
        public static void main(String[] args) {
            HelloA a=new HelloA();    
        }
    }
    
    运行结果:
    A的静态代码块
    A的构造代码块
    A的构造函数
    复制代码

    例子3:

    复制代码
    public class HelloA {
        public HelloA(){//构造函数
            System.out.println("A的构造函数");    
        }
        {//构造代码块
            System.out.println("A的构造代码块");    
        }
        static {//静态代码块
            System.out.println("A的静态代码块");        
        }
        public static void main(String[] args) {
            HelloA a=new HelloA();
            HelloA b=new HelloA();
        }
    
    }
    
    运行结果:
    A的静态代码块
    A的构造代码块
    A的构造函数
    A的构造代码块
    A的构造函数
    复制代码

    对于一个类而言,按照如下顺序执行:

    1. 执行静态代码块
    2. 执行构造代码块
    3. 执行构造函数

    对于静态变量、静态初始化块、变量、初始化块、构造器,它们的初始化顺序依次是(静态变量、静态初始化块)>(变量、初始化块)>构造器。

    例子4:

    复制代码
     1 public class InitialOrderTest {
     2         /* 静态变量 */
     3     public static String staticField = "静态变量";
     4         /* 变量 */
     5     public String field = "变量";
     6         /* 静态初始化块 */
     7     static {
     8         System.out.println( staticField );
     9         System.out.println( "静态初始化块" );
    10     }
    11         /* 初始化块 */
    12     {
    13         System.out.println( field );
    14         System.out.println( "初始化块" );
    15     }
    16         /* 构造器 */
    17     public InitialOrderTest()
    18     {
    19         System.out.println( "构造器" );
    20     }
    21 
    22 
    23     public static void main( String[] args )
    24     {
    25         new InitialOrderTest();
    26     }
    27 }
    复制代码

    运行以上代码,我们会得到如下的输出结果:

    1. 静态变量

    2. 静态初始化块

    3. 变量

    4. 初始化块

    5. 构造器

    ## 对于继承情况

    例子5:

    复制代码
    public class HelloA {
        public HelloA(){//构造函数
            System.out.println("A的构造函数");    
        }
        {//构造代码块
            System.out.println("A的构造代码块");    
        }
        static {//静态代码块
            System.out.println("A的静态代码块");        
        }
    }
    public class HelloB extends HelloA{
        public HelloB(){//构造函数
            System.out.println("B的构造函数");    
        }
        {//构造代码块
            System.out.println("B的构造代码块");    
        }
        static {//静态代码块
            System.out.println("B的静态代码块");        
        }
        public static void main(String[] args) {
            HelloB b=new HelloB();        
        }
    }
    运行结果:
    A的静态代码块
    B的静态代码块
    A的构造代码块
    A的构造函数
    B的构造代码块
    B的构造函数
    复制代码

    当涉及到继承时,按照如下顺序执行:

    1. 执行父类的静态代码块,并初始化父类静态成员变量
    2. 执行子类的静态代码块,并初始化子类静态成员变量
    3. 执行父类的构造代码块,执行父类的构造函数,并初始化父类普通成员变量
    4. 执行子类的构造代码块, 执行子类的构造函数,并初始化子类普通成员变量
    Java初始化顺序如图:

     

    例子6:

    复制代码
     1 class Parent {
     2         /* 静态变量 */
     3     public static String p_StaticField = "父类--静态变量";
     4          /* 变量 */
     5     public String    p_Field = "父类--变量";
     6     protected int    i    = 9;
     7     protected int    j    = 0;
     8         /* 静态初始化块 */
     9     static {
    10         System.out.println( p_StaticField );
    11         System.out.println( "父类--静态初始化块" );
    12     }
    13         /* 初始化块 */
    14     {
    15         System.out.println( p_Field );
    16         System.out.println( "父类--初始化块" );
    17     }
    18         /* 构造器 */
    19     public Parent()
    20     {
    21         System.out.println( "父类--构造器" );
    22         System.out.println( "i=" + i + ", j=" + j );
    23         j = 20;
    24     }
    25 }
    26 
    27 public class SubClass extends Parent {
    28          /* 静态变量 */
    29     public static String s_StaticField = "子类--静态变量";
    30          /* 变量 */
    31     public String s_Field = "子类--变量";
    32         /* 静态初始化块 */
    33     static {
    34         System.out.println( s_StaticField );
    35         System.out.println( "子类--静态初始化块" );
    36     }
    37        /* 初始化块 */
    38     {
    39         System.out.println( s_Field );
    40         System.out.println( "子类--初始化块" );
    41     }
    42        /* 构造器 */
    43     public SubClass()
    44     {
    45         System.out.println( "子类--构造器" );
    46         System.out.println( "i=" + i + ",j=" + j );
    47     }
    48 
    49 
    50         /* 程序入口 */
    51     public static void main( String[] args )
    52     {
    53         System.out.println( "子类main方法" );
    54         new SubClass();
    55     }
    56 }
    复制代码

    结果:

    父类--静态变量
    父类--静态初始化块
    子类--静态变量
    子类--静态初始化块
    子类main方法
    父类--变量
    父类--初始化块
    父类--构造器
    i=9, j=0
    子类--变量
    子类--初始化块
    子类--构造器
    i=9,j=20

    子类的静态变量和静态初始化块的初始化是在父类的变量、初始化块和构造器初始化之前就完成了。静态变量、静态初始化块,变量、初始化块初始化了顺序取决于它们在类中出现的先后顺序。

    ### 分析

    • (1)访问SubClass.main(),(这是一个static方法),于是装载器就会为你寻找已经编译的SubClass类的代码(也就是SubClass.class文件)。在装载的过程中,装载器注意到它有一个基类(也就是extends所要表示的意思),于是它再装载基类。不管你创不创建基类对象,这个过程总会发生。如果基类还有基类,那么第二个基类也会被装载,依此类推。

    • (2)执行根基类的static初始化,然后是下一个派生类的static初始化,依此类推。这个顺序非常重要,因为派生类的“static初始化”有可能要依赖基类成员的正确初始化。

    • (3)当所有必要的类都已经装载结束,开始执行main()方法体,并用new SubClass()创建对象。

    • (4)类SubClass存在父类,则调用父类的构造函数,你可以使用super来指定调用哪个构造函数。基类的构造过程以及构造顺序,同派生类的相同。首先基类中各个变量按照字面顺序进行初始化,然后执行基类的构造函数的其余部分。

    • (5)对子类成员数据按照它们声明的顺序初始化,执行子类构造函数的其余部分。

    原博客:https://www.cnblogs.com/Qian123/p/5713440.html

    展开全文
  • Java中构造方法,构造代码块和静态代码块执行顺序详解 前言: 构造方法,构造代码块和静态代码块的执行顺序是一个常见的面试题,精通Java的人都知道执行顺序为:“静态代码块——>构造方法——>构造代码块”,...

    Java中构造方法,构造代码块和静态代码块执行顺序详解

    前言:

    构造方法,构造代码块和静态代码块的执行顺序是一个常见的面试题,精通Java的人都知道执行顺序为:“静态代码块——>构造方法——>构造代码块”,接下来对该顺序进行详细分析

    分析:

    1.构造方法的执行:

    ​ 所有的Java类中至少都会有一个构造方法,用于对象的初始化。
    在这里每次创建新的对象时,红箭头所指的“ ( ) ”部分其实就是在调用构造方法插入图片描述

    2.构造代码块的执行:

    ​ 构造代码块是类中编写的一个代码块成员,它与构造方法不同,如下图所示:
    在这里插入图片描述
    ​ 我们定义一个对象后执行代码,结果如下:
    在这里插入图片描述
    ​ 从上图我们可以发现,构造代码块的执行早于构造方法。

    ​ 实际上,构造代码块和构造方法执行的时机都很类似,甚至可以说功能上是重复的,那为什么还要使用构造代码块呢?是因为构造方法一般有很多种,比如无参构造,一参构造,二参构造等等,而有些操作是不论我们使用哪种构造方法都需要使用的,那么这时候使用构造代码块来放置这些操作,便不会因为构造方法太多而多次编写同样的操作,节省了我们的精力。

    3.静态代码块的执行:

    静态代码块,构造代码块和构造方法示例

    ​ 如上图,静态代码块由static修饰,我们知道,在Java中,使用static修饰的成员属性和成员方法,是独立于具体的变量和具体的方法的,它们并不是随着对象的创建而创建,而是在类加载时便已经初始化,换言之,可以将静态成员、静态方法和静态代码块看成是“属于类的”,只要类被加载出了,它们便可以被我们访问,也正因此,无论其他对象创建多少次,创建多少份数据,静态成员和方法均只有一份数据。

    ​ 进一步使用类比理解,我们可以将类和对象分别类比为图纸和依照图纸制造的实物。例如:类对应宝马汽车的图纸,对象对应为某辆宝马汽车,而静态修饰的属性可以看做是类的属性,也就是图纸的属性,将之类比为记录图纸使用次数的电脑;非静态修饰的属性我们看做是对象的属性,将之类比为宝马的方向盘。

    ​ 在制造宝马的时候,图纸被不断地使用,但是不论图纸如何使用,记录图纸使用次数的电脑都只有一台,而宝马不断制造时,每一辆宝马都有一个方向盘,也就是说,static修饰的部分并不会随着新对象的创建(新宝马的制造)而建立新的数据(使用新的电脑),而非static修饰的部分会随着新对象的创建(新宝马的制造)而建立新的数据(新的方向盘)。

    图解:

    ​ 定义一个类,同时定义其静态代码块,构造代码块和构造方法如图:

    在这里插入图片描述

    ​ 定义三个相应的对象,执行结果如图:
    在这里插入图片描述

    总结:

    ​ 构造代码块,构造方法和静态代码块的执行顺序是:

    ​ 静态代码块——>构造代码块——>构造方法

    ​ 并且我们可以注意到,构造代码块和构造方法随着每一次对象的创建而执行,但静态代码块只随着类的加载而执行,由于类只加载一次,因此静态代码块也只加载一次。
    构造代码块和构造方法随着每一次对象的创建而执行,但静态代码块只随着类的加载而执行,由于类只加载一次,因此静态代码块也只加载一次。

    展开全文
  • 构造代码块:执行时间比静态代码块晚,比构造函数早,和构造函数一样,只在对象初始化的时候运行。没有名字、参数和返回值。构造函数:执行时间比构造代码块时间晚,也是在对象初始化的时候运行。没有返回值,构造...
  • package gt; /** * Created by Cronous on 2017/10/29. * 静态代码块和构造代码块的区别 */ public class day01 { public static void main(String[] args){ Person p1 = new Person("tom"); Person p2 =
  • 构造代码块是在类中方法外用 {} 括起来的代码,作用是把所有构造方法中相同的内容抽取出来,将来在调用构造方法的时候会去自动调用构造代码块,构造代码快优先于构造方法 构造代码块的作用是给对象进行初始化 构造代...
  • java构造代码块详解

    万次阅读 多人点赞 2017-02-06 15:58:53
    简介首先说一下,Java中有哪些代码块.普通代码块就是在方法后面使用"{}"括起来的代码片段,不能单独执行,必须调下其方法名才可以执行. 静态代码块在类中使用static修饰,并使用"{}"括起来的代码片段,用于静态变量的初始...
  • 代码块(局部代码块、构造代码块、静态代码块)

    千次阅读 多人点赞 2019-06-18 20:17:41
    根据位置和声明不同,可以分为局部代码块,构造代码块,静态代码块,同步代码块 局部代码块:在方法中出现,限定变量生命周期,及早释放,提高内存利用率 构造代码块(初始化块):在类中方法外出现 静态代码块:...
  • 构造代码块的作用

    千次阅读 2019-02-25 17:35:33
    构造代码块的生命周期跟类一直,成员变量的生命周期跟方法一直   Java常见代码块的作用与区别   1. 局部代码块 作用在方法当中,作用是控制变量的生命周期: public void show(){ { System.out.println("...
  • 构造代码块与静态代码块1.构造代码块:每次创建对象时执行 2.静态代码块:JVM加载类(加载在运行之前)时执行,静态代码块只执行一次 3.public static B t1 = new B();也是静态代码块 4.执行顺序:静态代码块>...
  • 今天我总结了一下java中静态代码块 构造代码块 构造方法的执行顺序及其注意问题 执行顺序: 静态代码块>构造代码块>构造方法体 首先要知道静态代码块是随着类的加载而加载,而构造代码块和构造方法都是随着对象...
  • 构造代码块: 作用:给对象进行初始化。 对象一建立就运行,而且优先于构造函数执行。 构造代码块与构造函数的区别: 构造代码块是给所有对象进行统一初始化, 而构造函数是给对应的对象初始化。 构造代码快中...
  • 构造代码块

    2018-07-05 10:29:59
    1.什么是构造代码块?没有前缀没有后缀,并用“{}”括起来的代码块。2.特性它会被嵌入到每一个构造器的最前面,在实例化对象时被执行。3.举例package org.qqwe.innerClass; /** * @author 王阳明的徒弟 * @date ...
  • 构造代码块>构造方法 理由:静态代码块(static{})在类加载的时候执行一次。 构造代码块({}内的部分)在每一次创建对象时执行,始终在构造方法前执行。 构造方法在新建对象时调用( 就是new的时候 )。 注意: ...
  • 文章目录声明构造方法普通代码块静态代码块构造代码块构造方法、静态代码块、构造代码块的执行顺序 声明 1)该文章部分内容整理自网上的资料,如不小心侵犯了大家的权益,还望海涵,并联系博主删除。 2)博主是萌新...
  • 在学习Java基础期间,子父类的静态代码块、构造代码块、构造方法的执行顺序容易混淆,现在通过一段程序来说明它们的执行顺序。 一、先看一个简单的静态测试程序: 运行结果: 执行父类的静态代码...
  • 静态代码块 static {  执行语句 } 在java中使用static关键字声明的代码块。静态块用于初始化类,为类的属性初始化。每个静态代码块只会执行一次。由于JVM在加载类时会执行静态代码块,所以静态代码块先于主方法...
  • 构造函数与构造代码块

    千次阅读 2018-01-24 23:00:35
    构造函数 1.构造函数的作用:给对应的对象进行初始化。 2.构造函数的定义格式: 修饰符 函数名(形式参数){  函数体; } 3.构造函数要注意的细节: (1)构造函数是没有返回值类型的。 (2)构造函数的函数名...
  • 局部代码块  局部位置在方法内部,...构造代码块  在类中的成员位置(就是成员变量和成员方法可以在的位置)。在构造方法执行之前执行。  每一次调构造方法执行前都会自动先执行构造代码块。  {} 静态代码块  ...
  • 构造代码块 构造方法
  • 接下来看探讨静态代码块,构造代码块和构造方法间的执行顺序 输出结果为: 看到main方法中的第一行语句并不是最先被执行,同时也看到static块只会执行一次 static块(静态代码块)可以置于类中的任何地方,类...
  • 1.首先在任何一个类中,一般来说一定存在着构造方法,即使什么也没写,那就说明类中默认是无参的构造方法,例如 public class Student{ private int age; public void setAge(int age){ this.age=age; } ...
  • 直接上代码,简洁明了!... System.out.println("静态代码块"); } {//构造方法块 System.out.println("构造方法块"); } public Main(){//构造方法 System.out.println("构造方法"); } publi...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 508,004
精华内容 203,201
关键字:

构造代码块