精华内容
下载资源
问答
  • 静态代码块和构造方法
    千次阅读
    2016-03-01 09:54:49
      对静态代码块以及构造函数的执行先后顺序,一直很迷惑,现用下面的这段小程序来简明扼要的叙述一下,以加深理解,与君共勉....
                                 

                    public class Fu {

                                          static {
                                                System.out.print(1);

                                                      }

                                          public Fu() {
                                                 System.out.print(2);
                                                     }
                                              }

                   public class Zi extends Fu {

                                           static {
                                                System.out.print("a");
                                                     }

                                           public Zi() {
                                                System.out.print("b");
                                                       }
                                               }

               public class demo {

                              public static void main(String[] args) {
                                             Fu fu = new Zi();
                                             fu = new Zi();
                                                          }
                                                 }

    1.
           当父类与子类都有静态代码块和构造函数的时候,执行顺序如下:

           父类静态代码块 > 子类静态代码块 java虚拟机加载类时,就会执行该块代码。

           父类构造函数 > 子类构造函数 (先有父亲,后有孩子)

           如果是多级继承关系的话,高层的父类首先执行,然后依次递减

        总结:静态优先执行,父类优先于子类执行
                    静态代码块是在JVM加载类的时候执行的,而且静态代码块执行且仅执行一次


    2.

           在调用类中的方法时,在方法体执行之前,首先要对类中的成员变量进行赋值,如果代码中没有赋具体的值,就会赋予变量默认值。成员变量的赋值顺序按照前后顺序进行。如果代码中既有直接赋值,也有构造方法赋值,那么根据先后顺序执行

    更多相关内容
  • 下面小编就为大家带来一篇java中的静态代码块、构造代码块、构造方法详解。小编觉得挺好的,现在分享给大家。给大家一个参考。一起跟随小编过来看看吧
  • 静态代码块以及构造函数的执行先后顺序,一直很迷惑,直到最近看到一段代码,发现终于弄懂了,所以这篇文章主要给大家介绍了关于如何判断java中静态代码块构造方法的执行顺序的相关资料,需要的朋友可以参考下。
  • 静态代码块在类被加载的时候执行,并且他只会执行一次,优先于其他所有代码块以及构造方法执行,如果有多个静态代码块则按编写顺序执行。 静态代码块在项目启动的时候执行, 静态代码块不能存在方法,主要放一些...

    1.使用示例

    2.静态代码块介绍

       在类中通过static修饰然后大括号里面的内容就是静态代码块。见13.1实例

          static {

    }

        静态代码块在类被加载的时候执行,并且他只会执行一次,优先于其他所有代码块以及构造方法执行,如果有多个静态代码块则按编写顺序执行。

         

         静态代码块在项目启动的时候执行, 静态代码块不能存在方法,主要放一些项目启动就需要加载的配置或者固定资源以及属性。

       比如我们可以放一些固定的正则表达式规则等。

       3. 构造代码块介绍

        在类中没有关键字修饰的大括号里面的内容就是构造代码块。见13.1实例

            {

            }

         构造代码块在构造方法之前静态代码块之后执行,因为构造方法分带参和不带参,所以构造代码块一般执行他们通用功能。

            

           构造代码块在创建对象的时候都会被调用,每次创建都会执行。

           比如我们可以通过在构造代码块里面统计对象创建次数。    

     4.有参构造方法和无参构造方法介绍

           在类中方法名和类名一致,并无返回值类型的内容就是构造方法。见13.1实例

                类名Test

                 public Test(){

    }

                 public Test(String name){

    }

           构造方法在我们创建对象的时候都会被调用,静态代码块以及构造代码块之后执行,当我们创建对象时候传入参数即调用有参构  造方法,不传参数时候调用无参构造方法。

           每一个类会默认有一个隐式的无参构造方法,我们可以直接使用,创建对象,但是当我们新写了带参构造方法时候,这个隐式的无参构造方法就会失效,我们就只能通过这个带参构造方法创建对象。如果我们想不传参创建对象,就得新加一个无参构造方法。

           构造方法的作用主要是用来创建对象,或者创建对象并传入前置一些属性初始化的值。

    5.普通代码块介绍

    普通代码块又叫局部代码块是放在方法体中,在所有代码块之后执行,并只有调用该方法的时候才会执行。主要是存一些局部变量,因为他会随着方法体的退出而消失,所以他能够减少变量的生命周期,提高内存的使用效率。

         比如一些只有在某个方法才会用到的属性,计算房屋面积的方法中的一些单位等。

    6.总结

      执行顺序:

      静态代码块》构造代码块》构造方法》普通代码块

      生命周期

       静态代码块》构造代码块=构造方法》普通代码块

       代码块的作用主要是把一些程序运行中通用固定的操作给抽出来放在一起执行,具体业务场景选择性的使用各种代码块。

    展开全文
  • 静态代码块>构造代码块>构造方法 原因: 静态代码块(static{})在类加载的时候执行一次,是最早被执行的。 构造代码块({}内的部分)在每一次创建对象时执行,始终在构造方法前执行。 构造方法在新建对象时...

    1、执行顺序

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

    原因:

    • 静态代码块(static{})在类加载的时候执行一次,是最早被执行的。
    • 构造代码块({}内的部分)在每一次创建对象时执行,始终在构造方法前执行。
    • 构造方法在新建对象时调用( 就是new的时候 )。

    注意:

    • 静态代码块在类加载的时候就执行,所以它的优先级高于入口main()方法。
    • 当三种形式不止一次出现,同优先级是按照先后顺序执行。

    程序代码示例:

    public class StaticTest {
        public static StaticTest t1 = new StaticTest();
        public static StaticTest t2 = new StaticTest();
    
        {
            System.out.println("构造块");
        }
    
        static {
            System.out.println("静态块");
        }
    
        public static void main(String[] args) {
            StaticTest t = new StaticTest();
        }
    }
    

    执行main方法打印结果:
    在这里插入图片描述


    为什么会出现这种打印结果?

    拓展知识点:静态域

    静态域:分为静态变量,静态方法,静态块。当执行到静态域时,按照静态域的顺序加载。并且静态域只在类的第一次加载时执行

    注意:加载了静态域的一部分,这时候不能再加载另一个静态域了,静态域必须当成一个整体来看待,否则加载会错乱。比如上面的代码,有静态变量和静态代码块儿,当加载了静态变量后,就不能加载静态代码块儿了

    根据代码执行顺序:

    (1)执行程序入口main方法时,首先加载类StaticTest
    注意:加载类时并不会调用构造块和构造方法,只有静态域会执行
    (2)加载类StaticTest,执行静态域的第一个静态变量,StaticTest t1 = new StaticTest();,输出构造块和构造方法(空)。打印出构造块。
    (3)由于每次new对象时,会执行一次构造块和构造方法,构造块总是在构造方法前执行,(当然,第一次new时,会先执行静态域,静态域〉构造块〉构造方法)所以执行StaticTest t1 = new StaticTest();时,执行了下面代码:

     	{
            System.out.println("构造块");
        }
    

    (4)同理,StaticTest t1 = new StaticTest();加载完后,以此执行第二个静态变量StaticTest t2 = new StaticTest();,执行构造块代码块。
    (5)执行static静态块,完成对整个静态域的加载
    (6)最后,再执行main方法,new StaticTest();,执行构造块。

    附加:代码中添加了构造方法

    public class StaticTest {
        public static StaticTest t1 = new StaticTest();
        public static StaticTest t2 = new StaticTest();
    
        {
            System.out.println("构造块");
        }
    
        static {
            System.out.println("静态块");
        }
    
        public StaticTest() {
            System.out.println("构造方法代码");
        }
    
        public static void main(String[] args) {
            StaticTest t = new StaticTest();
        }
    }
    

    执行main方法的打印结果:
    在这里插入图片描述

    总结:
    1、每调用一次构造方法,则执行一次构造块
    2、静态块只在类加载的时候加载一次
    3、有多个静态变量或块时,按声明顺序加载


    2、java中父类和子类代码执行顺序

    父类和子类代码执行顺序:

    父类静态代码块 =》 子类静态代码块 =》 父类代码块 =》 父类构造方法 =》 子类代码块 =》 子类构造方法


    程序代码如下:
    1、创建Father和Son类,让Son继承Father
    2、编写Father和Son的代码

    /**
     * 父类(抽象类)
     */
    public abstract class Father {
    
        static {
            System.out.println("父类静态代码执行了");
        }
    
        {
            System.out.println("父类非静态代码执行了");
        }
    
        public Father() {
            System.out.println("父类构造函数代码执行了");
        }
    
        public static void main(String[] args) {
            Son son = new Son();
        }
    }
    
    /**
     * 子类(具体类)
     */
    public class Son extends Father {
    
        static {
            System.out.println("子类静态代码执行了");
        }
    
        {
            System.out.println("子类非静态代码执行了");
        }
    
        public Son() {
            System.out.println("子类构造函数代码执行了");
        }
    }
    

    打印结果:
    在这里插入图片描述

    注意:由于代码的执行顺序不同,经常通过执行顺序进行后端初始化


    拓展链接:
    java的static关键字

    展开全文
  • 1.执行顺序:静态代码块>构造代码块>构造方法 理由:静态代码块(static{})在类加载的时候执行一次。 构造代码块({}内的部分)在每一次创建对象时执行,始终在构造方法前执行。 构造方法在新建对象时调用( ...

    总结一下:

    1.执行顺序:静态代码块>构造代码块>构造方法
    理由:静态代码块(static{})在类加载的时候执行一次。
    构造代码块({}内的部分)在每一次创建对象时执行,始终在构造方法前执行。
    构造方法在新建对象时调用( 就是new的时候 )。
    注意: a.静态代码块在类加载的时候就执行,所以它的优先级高于入口main()方法。
    b.当三种形式不止一次出现,同优先级是按照先后顺序执行。

    来看一道题巩固一下:

    public class B
    {
        public static B t1 = new B();
        public static B t2 = new B();
        {
            System.out.println("构造块");
        }
        static
        {
            System.out.println("静态块");
        }
        public static void main(String[] args)
        {
            B t = new B();
        }
    }
    
    

    所以这段代码的输出结果是?

    构造块,构造块,静态块,构造块
    

    解释:

    1.程序入口main方法要执行首先要加载类B
    2.静态域:分为静态变量,静态方法,静态块。这里面涉及到的是静态变量和静态块,当执行到静态域时,按照静态域的顺序加载。并且静态域只在类的第一次加载时执行
    3.每次new对象时,会执行一次构造块和构造方法,构造块总是在构造方法前执行(当然,第一次new时,会先执行静态域,静态域〉构造块〉构造方法)
    注意:加载类时并不会调用构造块和构造方法,只有静态域会执行
    4.根据前三点,首先加载类B,执行静态域的第一个静态变量,static b1=new B,输出构造块和构造方法(空)。ps:这里为什么不加载静态方法呢?因为执行了静态变量的初始化,意味着已经加载了B的静态域的一部分,这时候不能再加载另一个静态域了,否则属于重复加载 了(静态域必须当成一个整体来看待。否则加载会错乱) 于是,依次static b2 =new B,输出构造块,再执行静态块,完成对整个静态域的加载,再执行main方法,new b
    链接:https://www.nowcoder.com/questionTerminal/ab6eb06face84c4e81ab5bc6f0f7f258
    来源:牛客网

    开始时JVM加载B.class,对所有的静态成员进行声明,t1 t2被初始化为默认值,为null,又因为t1 t2需要被显式初始化,所以对t1进行显式初始化,初始化代码块→构造函数(没有就是调用默认的构造函数),咦!静态代码块咋不初始化?因为在开始时已经对static部分进行了初始化,虽然只对static变量进行了初始化,但在初始化t1时也不会再执行static块了,因为JVM认为这是第二次加载类B了,所以static会在t1初始化时被忽略掉,所以直接初始化非static部分,也就是构造块部分(输出’‘构造块’’)接着构造函数(无输出)。接着对t2进行初始化过程同t1相同(输出’构造块’),此时就对所有的static变量都完成了初始化,接着就执行static块部分(输出’静态块’),接着执行,main方法,同样也,new了对象,调用构造函数输出(‘构造块’)
    总结:
    1、每调用一次构造方法,则执行一次构造块
    2、静态块只在类加载的时候加载一次
    3、有多个静态变量或块时,按声明顺序加载
    下面再看一道题:

    public class HelloB extends HelloA {
    	
    	 public HelloB(){
    		 System.out.println("B的构造方法");
    	 }
    	 {
    	     System.out.println("B的构造代码块");
    	 }
    	 static{
    	     System.out.println("B的静态代码块");
    	 }
    	 //public static HelloB hB = new HelloB();
    	 public static void main(String[] args){
    	     new HelloB();//调用B的构造方法
    	 }
    }
    
    class HelloA{
    	 public HelloA(){
    		 System.out.println("A的构造方法");
    	 }
    	 {
    	     System.out.println("A的构造代码块");
    	 }
    	 static{
    	     System.out.println("A的静态代码块");
    	 }
    } 
    

    输出的结果大家都应该是知道的:

    A的静态代码块
    B的静态代码块
    A的构造代码块
    A的构造方法
    B的构造代码块
    B的构造方法
    
    展开全文
  • 接下来看探讨静态代码块,构造代码块和构造方法间的执行顺序 输出结果为: 看到main方法中的第一行语句并不是最先被执行,同时也看到static块只会执行一次 static块(静态代码块)可以置于类中的任何地方,类...
  •  1 静态变量,静态代码块(类加载时执行,类不加载不执行)  2 实例变量,实例代码块(创建对象时才执行,不创建对象不执行)  3 构造函数,(创建对象时执行完2后再执行构造函数,不管构造函数是public还是private...
  • 若仅声明为static,打印Parent.CITY_NAME时会先执行静态代码块,而打印Parent.RG_CODE却不会。 public static final Color COLOR_RED=new Color(255,0,0); 引用类似这些非常数静态域时会执行static代码块, 2...
  • 静态代码块:是用来初始化类的信息,在类被加载的时候就会被执行,且只执行一次。执行优先级高于非静态的初始化块。 非静态代码块:是用来初始化类的实例信息,在创建对象的时候就会被执行,且每创建一个对象都会被...
  • Java中构造方法,构造代码块和静态代码块执行顺序详解 前言: 构造方法,构造代码块和静态代码块的执行顺序是一个常见的面试题,精通Java的人都知道执行顺序为:“静态代码块——>构造方法——>构造代码块”,...
  • 父类:FatherStaticDemo public class FatherStaticDemo { { System.out.println("father普通代码块"); } static { System.out.println("father静态代码块"); } public FatherStaticDe...
  • 构造代码块、变量的执行顺序
  • 在学习Java基础期间,子父类的静态代码块、构造代码块、构造方法的执行顺序容易混淆,现在通过一段程序来说明它们的执行顺序。 一、先看一个简单的静态测试程序: 运行结果: 执行父类的静态代码...
  • 由于JVM在加载类时会执行静态代码块,所以静态代码块先于主方法执行。 如果类中包含多个静态代码块,那么将按照"先定义的代码先执行,后定义的代码后执行"。 注意:1 静态代码块不能存在...
  • 首先要知道静态代码块是随着类的加载而加载,而构造代码块和构造方法都是随着对象的创建而加载 当时做了这么一个小案例(想必这个大多数学java的都做过,不知道是否都理解了) class Fu{ static { System.out.pr...
  • 静态初始化代码块、构造代码块构造方法 (2)如果有父类子类,执行顺序: 1.父类静态初始化代码块、子类静态初始化代码块 2.父类构造代码块、父类构造方法 3.子类构造代码块、子类构造方法 代码举例: ...
  • 目录一、代码块概述二、代码块分为构造代码块和静态代码块1.构造代码块2.静态代码块三、注意作者:KJ.JK 一、代码块概述 *代码块是类的成分之一(成员变量、构造器,方法,代码块,内部类)。 *在Java类中,使用 ...
  • java中类的静态代码块、构造代码块、构造方法、静态成员的初始化顺序:  首先,在类加载时,为类中的静态成员变量分配内存空间,并为其赋予默认值(整数型为0,浮点型为0.0,布尔型为false,字符型为'\u0000',引用...
  • 主要介绍了Java 中普通代码块,构造代码块,静态代码块区别及代码示例的相关资料,需要的朋友可以参考下
  • 直接上代码,简洁明了!... System.out.println("静态代码块"); } {//构造方法块 System.out.println("构造方法块"); } public Main(){//构造方法 System.out.println("构造方法"); } publi...
  • 静态代码块、静态方法、静态变量、普通代码块、构造方法的执行顺序。 定义一个父类Test public class Test { static int age = 10; // 静态变量age static { System.out.println("Test静态代码块"); } { ...
  • 下面小编就为大家带来一篇Java 普通代码块静态代码块执行顺序(实例讲解)。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • java 静态代码块、非静态代码块构造方法 执行顺序
  • 例子:package io.renren;/** * Created by root on 9/29/17. */ public class StaticTest { static int age = 1; int age1 = 2; static { System.out.println("这是静态代码块"); } { Sys
  • 1、静态代码块:在类中方法外出现,并加上static修饰;用于给类进行初始化,在类加载的时候就执行,并且只执行一次。 2、构造代码块:在类中方法外出现,多个构造方法相同的代码存放到一起,每次调用构造都执行,...
  • 介绍构造代码块和静态代码块的格式特性。末尾给出了一个静态代码块在数据库连接池应用的简单介绍。
  • 静态代码块构造块的执行顺序

    千次阅读 2018-05-05 17:21:38
    静态代码块、非静态代码块对象相关的,每构造一个对象就会执行一次总结一句话:父类优先,静态优先,构造最后。执行顺序: 当实例化子类对象时,首先要加载父类的class文件进内存(前提是父类没有被加载),...
  • 构造代码块、静态代码块构造方法是三种不同的代码块,那么他们到底有什么区别呢? 一、简单认识一下构造代码块、静态代码块构造方法 class A { //构造代码块 { System.out.println("构造代码块A"); } //...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 271,319
精华内容 108,527
关键字:

静态代码块和构造方法