精华内容
下载资源
问答
  • 2022-04-09 19:29:19

    代码:

    父类:

    
    class Father {
    	
    	private String name;
    	//无参构造
    	Father() {
    		System.out.println("--父类的无参构造函数--");
    	}
    	//有参构造
    	Father(String name) {
    		this.name = name;
    		System.out.println("--父类的有参构造函数--" + this.name);
    	}
    	//静态代码块
    	static {
    		System.out.println("--父类的静态代码块--");
    	}
    	//非静态代码块
    	{
    		System.out.println("--父类的非静态代码块--");
    	}
    	//父类speak()方法
    	public void speak() {
    		System.out.println("--父类的方法--");
    	}
    }

    子类:

    public class Son extends Father {
    	private String name;
    	//静态代码块
    	static {
    		System.out.println("--子类的静态代码块--");
    	}
    	//非静态代码块
    	{
    		System.out.println("--子类的非静态代码块--");
    	}
    	//子类无参构造函数
    	Son() {
    		System.out.println("--子类的无参构造函数--");
    	}
    	//子类有参构造函数
    	Son(String name) {
    		super(name);
    		this.name = name;
    		System.out.println("--子类的有参构造函数--" + this.name);
    	}
    	//子类覆盖父类方法
    	public void speak() { 
    		System.out.println("--子类覆盖了父类的方法--");
    	}
    	//子类主程序
    	public static void main(String[] args) {
    		System.out.println("--子类主程序--");
    		Son s1= new Son("儿子的名字");
    		Son s2= new Son();
    		s1.speak();
    	}
    }

    注意:在子类构造方法引用父类构造方法时,应放在子类构造方法中的第一行。 

    运行结果:(再查看运行结果之前不妨先自己思考一遍答案)

    --父类的静态代码块--
    --子类的静态代码块--
    --子类主程序--
    --父类的非静态代码块--
    --父类的有参构造函数--儿子的名字
    --子类的非静态代码块--
    --子类的有参构造函数--儿子的名字
    --父类的非静态代码块--
    --父类的无参构造函数--
    --子类的非静态代码块--
    --子类的无参构造函数--
    --子类覆盖了父类的方法--
    

    结论:

    子类继承父类时,各代码段的执行顺序:

    优先级:

    1.父类静态代码块>子类静态代码块

    2.静态代码块>主程序(静态代码块只执行一次)

    3.非静态代码块>构造函数(如果主函数有构造函数,执行非静态代码块后再执行构造函数)

    4.父类构造函数>子类构造函数(非静态代码块执行多次,与引用构造函数次数有关)

    5.最后执行普通方法(注意普通方法里面是否有执行父类方法、是否覆盖父类方法,覆盖了则执行子类方法)

    更多相关内容
  • 下面小编就为大家带来一篇Java 普通代码块静态代码块执行顺序(实例讲解)。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 本篇文章主要介绍了Android代码块执行顺序分析总结,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 对静态代码块以及构造函数的执行先后顺序,一直很迷惑,直到最近看到一段代码,发现终于弄懂了,所以这篇文章主要给大家介绍了关于如何判断java中静态代码块与构造方法的执行顺序的相关资料,需要的朋友可以参考下。
  • java代码块执行顺序

    2021-12-18 10:29:20
    目录 静态代码块 格式 执行时机 静态代码块的作用 静态代码块不能存在任何方法体中 ...在java类中(方法中不能存在静态代码块)使用static关键字和{}声明的代码块: public class CodeBlock { static{

    目录

    1.静态代码块

    1.1.格式

    1.2.执行时机

    1.3.静态代码块的作用

    1.4.静态代码块不能存在任何方法体中

    1.5.静态代码块不能访问普通变量

    2.构造代码块

    2.1.格式

    2.2.执行时机

    2.3.构造代码块的作用

    3.构造函数

    4.普通代码块

    5.执行顺序

    6.父类和子类执行顺序


    1.静态代码块

    1.1.格式

    在java类中(方法中不能存在静态代码块)使用static关键字和{}声明的代码块:

    public class CodeBlock {
        static{
            System.out.println("静态代码块");
        }
    }

    1.2.执行时机

    静态代码块在类被加载的时候就运行了,而且只运行一次,并且优先于各种代码块以及构造函数。如果一个类中有多个静态代码块,会按照书写顺序依次执行。后面在比较的时候会通过具体实例来证明。

    1.3.静态代码块的作用

    一般情况下,如果有些代码需要在项目启动的时候就执行,这时候就需要静态代码块。比如一个项目启动需要加载的很多配置文件等资源,我们就可以都放入静态代码块中。

    1.4.静态代码块不能存在任何方法体中

    这个应该很好理解,首先我们要明确静态代码块是在类加载的时候就要运行了。我们分情况讨论: 对于普通方法,由于普通方法是通过加载类,然后new出实例化对象,通过对象才能运行这个方法,而静态代码块只需要加载类之后就能运行了。 对于静态方法,在类加载的时候,静态方法也已经加载了,但是我们必须要通过类名或者对象名才能访问,也就是说相比于静态代码块,静态代码块是主动运行的,而静态方法是被动运行的。 不管是哪种方法,我们需要明确静态代码块的存在在类加载的时候就自动运行了,而放在不管是普通方法还是静态方法中,都是不能自动运行的。

    1.5.静态代码块不能访问普通变量

    这个理解思维同上,普通变量只能通过对象来调用,是不能放在静态代码块中的。

    2.构造代码块

    2.1.格式

    在java类中使用{}声明的代码块(和静态代码块的区别是少了static关键字):

    public class CodeBlock {
        static{
            System.out.println("静态代码块");
        }
        {
            System.out.println("构造代码块");
        }
    }

    2.2.执行时机

    构造代码块在创建对象时被调用,每次创建对象都会调用一次,但是优先于构造函数执行。需要注意的是,听名字我们就知道,构造代码块不是优先于构造函数执行,而是依托于构造函数,也就是说,如果你不实例化对象,构造代码块是不会执行的。怎么理解呢?我们看看下面这段代码:

    public class CodeBlock {
      {
        System.out.println("构造代码块");
      }
    
      public CodeBlock(){
        System.out.println("无参构造函数");
      }
    
      public CodeBlock(String str){
        System.out.println("有参构造函数");
      }
    }

    反编译生成的class文件:

    public class CodeBlock {
    
      public CodeBlock(){
        System.out.println("构造代码块");
        System.out.println("无参构造函数");
      }
    
      public CodeBlock(String str){
        System.out.println("构造代码块");
        System.out.println("有参构造函数");
      }
    }

    如果存在多个构造代码块,则执行顺序按照书写顺序依次执行。

    2.3.构造代码块的作用

    和构造函数的作用类似,都能对对象进行初始化,并且只要创建一个对象,构造代码块都会执行一次。但是反过来,构造函数则不一定每个对象建立时都执行(多个构造函数情况下,建立对象时传入的参数不同则初始化使用对应的构造函数)。 利用每次创建对象的时候都会提前调用一次构造代码块特性,我们可以做诸如统计创建对象的次数等功能。 回到顶部

    3.构造函数

    1. 构造函数的命名必须和类名完全相同。在java中普通函数可以和构造函数同名,但是必须带有返回值;
    2. 构造函数的功能主要用于在类的对象创建时定义初始化的状态。它没有返回值,也不能用void来修饰。这就保证了它不仅什么也不用自动返回,而且根本不能有任何选择。而其他方法都有返回值,即使是void返回值。尽管方法体本身不会自动返回什么,但仍然可以让它返回一些东西,而这些东西可能是不安全的;
    3. 构造函数不能被直接调用,必须通过new运算符在创建对象时才会自动调用;而一般的方法是在程序执行到它的时候被调用的;
    4. 当定义一个类的时候,通常情况下都会显示该类的构造函数,并在函数中指定初始化的工作也可省略,不过Java编译器会提供一个默认的构造函数.此默认构造函数是不带参数的。而一般的方法不存在这一特点; 回到顶部

    4.普通代码块

    普通代码块和构造代码块的区别是,构造代码块是在类中定义的,而普通代码块是在方法体中定义的。且普通代码块的执行顺序和书写顺序一致。

    public void sayHello(){
        {
            System.out.println("普通代码块");
        }
    }

    5.执行顺序

    静态代码块>构造代码块>构造函数>普通代码块

    public class CodeBlock {
        static{
            System.out.println("静态代码块");
        }
    
        {
            System.out.println("构造代码块");
        }
    
      public CodeBlock(){
            System.out.println("无参构造函数");
      }
    
      public void sayHello(){
        {
            System.out.println("普通代码块");
        }
      }
    
      public static void main(String[] args) {
          System.out.println("执行了main方法");
    
          new CodeBlock().sayHello();;
          System.out.println("---------------");
          new CodeBlock().sayHello();;
       }
    }

    执行结果

    静态代码块
    执行了main方法
    构造代码块
    无参构造函数
    普通代码块
    ---------------
    构造代码块
    无参构造函数
    普通代码块

    我们创建了两个匿名对象,但是静态代码块只是调用了一次。

    6.父类和子类执行顺序

    对象的初始化顺序: 首先执行父类静态的内容,父类静态的内容执行完毕后,接着去执行子类的静态的内容,当子类的静态内容执行完毕之后,再去看父类有没有构造代码块,如果有就执行父类的构造代码块,父类的构造代码块执行完毕,接着执行父类的构造方法;父类的构造方法执行完毕之后,它接着去看子类有没有构造代码块,如果有就执行子类的构造代码块。子类的构造代码块执行完毕再去执行子类的构造方法。 总之一句话,静态代码块内容先执行,接着执行父类构造代码块和构造方法,然后执行子类构造代码块和构造方法。 父类:SuperClass.java

    public class SuperClass {
        static{
            System.out.println("父类静态代码块");
        }
    
        {
            System.out.println("父类构造代码块");
        }
    
        public SuperClass(){
            System.out.println("父类构造函数");
        }
    }

    子类:SubClass.java

    public class SubClass extends SuperClass{
        static{
            System.out.println("子类静态代码块");
        }
    
      {
        System.out.println("子类构造代码块");
      }
    
      public SubClass(){
        System.out.println("子类构造函数");
      }
    }

    测试

    public static void main(String[] args) {
        SubClass sb = new SubClass();
        System.out.println("------------");
        SubClass sb1 = new SubClass();
    }

    打印结果

    父类静态代码块
    子类静态代码块
    父类构造代码块
    父类构造函数
    子类构造代码块
    子类构造函数
    ------------
    父类构造代码块
    父类构造函数
    子类构造代码块
    子类构造函数
    展开全文
  • 主要介绍了Java静态代码块作用及执行顺序解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 主要介绍了java 代码块与静态代码块加载顺序的相关资料,需要的朋友可以参考下
  • 代码块执行顺序

    2022-04-08 17:48:08
    代码块/局部代码块/构造代码块/静态代码块/各代码块执行顺序/继承关系中的代码块执行顺序:/静态变量和静态代码块执行顺序 代码块:1.就是被一对{}所括起来的代码2.根据代码块定义的位置不同分为:局部代码块,...

      目  录   

    代码块:

    局部代码块:

    构造代码块: 

    静态代码块:

    各代码块的执行顺序:

    继承关系中的代码块的执行顺序:


    代码块:

    1.就是被一对{}所括起来的代码

    2.根据代码块定义的位置不同分为:局部代码块,构造代码块,静态代码块

    局部代码块:

    定义在方法中的代码块,限定变量生命周期,及早释放,提高内存利用率

    public class MyTest {
        public static void main(String[] args) {
    
            //局部代码块       
            {
                //在方法中出现
                int num = 200;
                System.out.println("局部代码块");
                System.out.println(num);        //输出200
            }
    
     
            //System.out.println(num);          //出了代码块的范围,就不能再使用了!所以会报错!
        }
    }
    
    
    

    构造代码块: 

             处于类中方法外.构造代码块由可称为实例代码块,可以为该类的所有对象的成员变量赋值.实际上是SUN公司给我们java程序员的一个特殊得到时刻/时机,叫做对象构建时机.

            当我们创建对象时,如果构造代码块与构造方法同时存在时,那就先执行构造代码块,再执行构造方法,也就是说构造代码块优先于构造方法执行。每次创建对象,都会执行构造代码块和构造方法的!如果多个构造方法中存在相同的代码,就可以提取出来放到构造代码块中.减少了代码的复用.

    public class Student {
        static int num;
    
        //构造代码块
        {
            System.out.println("构造代码块");
            //构造代码块,可以为该类的所有对象的成员变量赋值。
            num = 100;
        }
    
        //构造方法
        public Student() {
            System.out.println("构造方法");
        }
    
        public static void main(String[] args) {       //进程入口
    
        }
    
    }

    静态代码块:

            代码块前有static关键字修饰,   随着类的加载而加载,优先于构造代码块执行。而且只执行一次。在静态代码块里面,只能访问静态修饰的。一般在静态代码块里面,做一些提前准备工作。比如我提前读取配置文件中数据等.

            静态代码块这种语法机制实际上是SUN公司给我们java程序员的一个特殊得到时刻/时机,叫做类加载时机.

    public class Student {
    
         static {
         System.out.println("静态代码块");
        }
         public static void main(String[] args) {       //进程入口
    
        }
    }

    而静态变量和静态代码块的执行顺序呢?

            同为静态修饰,静态变量和静态代码块的执行顺序按照代码的自上而下的顺序来.谁在前面,谁就先执行!

    各代码块的执行顺序:

    最先执行静态代码块,然后是构造代码块,接着是构造方法,最后便是局部代码块.看个例子:

    创建一个Student类:

    class Student {
        static {
            System.out.println("Student 静态代码块");  
        }
    
        {
            System.out.println("Student 构造代码块");
        }
    
        public Student() {
            System.out.println("Student 构造方法");
        }

    创建student测试类:

    public class StudentTest { 
        static {
            System.out.println("StudentTest的静态代码块"); 
        }
    
        public static void main(String[] args) {
            System.out.println("我是main方法"); 
            Student s1 = new Student();
            Student s2 = new Student();
        }
    }
    
    //输出结果:
    /*  
        StudentTest的静态代码块
        我是main方法
        Student 静态代码块
        Student 构造代码块
        Student 构造方法
    */

    继承关系中的代码块的执行顺序:

    继承的相关介绍在这里!

    //测试类
    public class Test {
            public static void main(String[] args) {
                Zi z = new Zi(); 
            }
    }
    
    
    //Fu类
    class Fu {
        static {
            System.out.println("静态代码块Fu"); //1
        }
    
        {
            System.out.println("构造代码块Fu"); //3
        }
    
        public Fu() {
            System.out.println("构造方法Fu");   //4
        }
    }
    
    
    //Zi类继承Fu类
    class Zi extends Fu {
        static {
            System.out.println("静态代码块Zi");//2
        }
    
        {
            System.out.println("构造代码块Zi"); //5
        }
    
        public Zi() {
            super();
            System.out.println("构造方法Zi"); //6
        }
    }
    
    
    //执行结果:
    /*
        静态代码块Fu
        静态代码块Zi
        构造代码块Fu
        构造方法Fu
        构造代码块Zi
        构造方法Zi
    */
    

     (小编也在努力学习更多哟!以后会多多分享哒!)

    希望对友友们有所帮助!!!!

    展开全文
  • 父类的静态代码块==>子类的静态代码块==>父类普通代码块==>父类构造方法==>子类普通代码块==>子类构造

    在单个类中

    测试代码

    // 类的定义
    public class TestClass {
    
        public TestClass (){
            System.out.println("Class 的构造方法");
        }
    
        {
            System.out.println("Class 的普通代码块");
        }
    
        static  {
            System.out.println("Class 的静态代码块");
        }
    }
    
    // 主方法
    public static void main(String[] args) {
        new ParentClass();
    }
    

    运行结果

    Class 的静态代码块
    Class 的普通代码块
    Class 的构造方法
    
    Process finished with exit code 0
    

    结论

    在单个类中的执行顺序: 静态代码块==>普通代码块==>构造方法

    在父子类中

    测试代码

    // 父类
    public class ParentClass {
    
        public ParentClass(){
            System.out.println("ParentClass 的构造方法");
        }
    
        {
            System.out.println("ParentClass 的普通代码块");
        }
    
        static  {
            System.out.println("ParentClass 的静态代码块");
        }
    }
    
    // 子类
    public class ChildClass extends ParentClass {
    
        public ChildClass(){
            System.out.println("ChildClass 的构造方法");
        }
    
        {
            System.out.println("ChildClass 的普通代码块");
        }
    
        static  {
            System.out.println("ChildClass 的静态代码块");
        }
    
    }
    
    // 主方法
    public static void main(String[] args) {
        new ChildClass();
    }
    

    运行结果

    ParentClass 的静态代码块
    ChildClass 的静态代码块
    ParentClass 的普通代码块
    ParentClass 的构造方法
    ChildClass 的普通代码块
    ChildClass 的构造方法
    
    Process finished with exit code 0
    

    结论

    在父子类中的执行顺序: 父类的静态代码块==>子类的静态代码块==>父类普通代码块==>父类构造方法==>子类普通代码块==>子类构造方法

    在内部类中

    测试代码

    public class MyClass {
    
        public MyClass(){
            System.out.println("MyClass 的构造方法");
        }
    
        {
            System.out.println("MyClass 的普通代码块");
        }
    
        static  {
            System.out.println("MyClass 的静态代码块");
        }
    
        // 内部类
        public static class InnerClass{
            public InnerClass(){
                System.out.println("InnerClass 的构造方法");
            }
    
            {
                System.out.println("InnerClass 的普通代码块");
            }
    
            static  {
                System.out.println("InnerClass 的静态代码块");
            }
        }
    
    }
    

    主方法

    public static void main(String[] args) {
        new MyClass();
    }
    

    运行结果

    MyClass 的静态代码块
    MyClass 的普通代码块
    MyClass 的构造方法
    
    Process finished with exit code 0
    

    主方法

    public static void main(String[] args) {
        new MyClass.InnerClass();
    }
    

    运行结果

    InnerClass 的静态代码块
    InnerClass 的普通代码块
    InnerClass 的构造方法
    
    Process finished with exit code 0
    

    结论
    在一个类里在定义一个内部类

    创建外面类的实例时,不会影响内部类
    创建内部类的实例时,也不会影响外面的类

    展开全文
  • 文章目录代码块的分类1、静态代码块(也叫静态块、静态初始化块)2、构造代码块(也叫构造初始化块)3、代码块(又叫普通代码块、初始化块)...代码块执行顺序静态代码块——> 构造代码块 ——> 构造函数——&
  • Java中构造方法,构造代码块和静态代码块执行顺序详解 前言: 构造方法,构造代码块和静态代码块的执行顺序是一个常见的面试题,精通Java的人都知道执行顺序为:“静态代码块——>构造方法——>构造代码块”,...
  • 代码块 代码块:又称初始化块,属于类中的成员。与方法类似,将逻辑语句封装于方法体内,但没有方法名,没有返回,没有参数,只有方法体。加载类或创建对象时隐式调用 [修饰符]{ 代码 }; 静态代码 static修饰的...
  • 静态代码块执行顺序

    2021-04-18 13:14:51
    虽然说不管是静态变量还是静态方法,这些都是java基础的知识了,但我发现还是有很多人不懂静态的原理,静态的属性遵循以下规则: ... System.out.println("1:静态代码块"); } public Main(){ ...
  • 静态代码块1.1 格式1.2 静态代码块执行时机1.3 静态代码块的作用2. 构造代码块2.1 格式2.2 构造代码块执行时机2.3 构造代码块的作用3. 构造方法4. 普通代码块5. 执行顺序6. 父子类执行顺序 本文参考自: ...
  • java静态代码块和代码块执行顺序

    千次阅读 2019-04-12 16:07:52
    java静态代码块和代码块执行顺序 先执行static方法,再执行普通方法,最后执行构造方法。 eg: package other; class B { public B() { super(); System.out.println("构造器B"); } { System.out.println...
  • 执行顺序:父类静态代码块(只执行一次,并且是在main之前执行)>子类静态代码块>父类构造块>父类构造方法>子类构造块>子类构造方法 ​ //构造块就是非静态代码块 //执行顺序:父类静态代码块(只...
  • 构造、代码块、变量的执行顺序
  • 注意:(静态)变量和(静态)代码块的也是有执行顺序的,与代码书写的顺序一致。在(静态)代码块中可以使用(静态)变量,但是被使用的(静态)变量必须在(静态)代码块前面声明。 最后给出执行步骤: 1、父类静态变量和静态...
  • 什么是代码块 将代码写入一对括号内的{ },就可以称为代码块 根据位置不同可以分为:局部...局部代码块在一个方法内是自上而下依次执行的 public class testdemo { public static void main(String[] args) { {
  • Java中代码块执行顺序

    2020-03-27 15:17:27
    情况一 public class Test { Test() { System.out.println("构造函数"); } public void run() { { System.out.println("普通代码块1"); } System.out.println("run方法"); {...
  • 从以下代码可以看出,静态代码块执行与构造函数,但是静态代码块和静态变量之间的执行顺序决定于它们在代码中出现的顺序 public class Test5 { public static void main(String[] args) { A a = new A(); ...
  • 局部代码块存在于方法中,一般进行一次性地调用,调用其所在的方法时执行,调用完立刻释放空间,限定局部变量的生命周期,避免在接下来的调用过程中占用栈空间。 静态代码块 静态代码块存在方法外部,和构造代码块...
  • 代码块执行顺序

    2022-01-22 13:38:23
    1. 在没有继承关系上的执行顺序 public class Person { public String name; public int age; public Person(String name, int age){ this.name = name; this.age = age; System.out.println("构造方法执行");...
  • 静态代码块执行顺序 public class demo { private static int num = 1; // 1 static { num = 10; // 2 number = 50; // 3 System.out.println(num); // 4 //System.out.println(number);
  • 1、三者在单个类中执行顺序 代码 public class Check { static String str = "这是一个静态变量"; static { System.out.println("这里是静态代码块。。。"); } { System.out.println("这里是构造代码块...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 959,462
精华内容 383,784
关键字:

代码块执行顺序

友情链接: 58478.zip