精华内容
下载资源
问答
  • 类初始化顺序

    2021-04-02 11:13:42
    类初始化顺序: 初始化父类中的静态成员和静态代码块,初始化顺序取决于两者在代码中出现的顺序 初始化子类中的静态成员和静态代码块,初始化顺序取决于两者在代码中出现的顺序 初始化父类中的普通成员和普通代码块...

    类初始化顺序:

    1. 初始化父类中的静态成员静态代码块,初始化顺序取决于两者在代码中出现的顺序
    2. 初始化子类中的静态成员静态代码块,初始化顺序取决于两者在代码中出现的顺序
    3. 初始化父类中的普通成员普通代码块,初始化顺序取决于两者在代码中出现的顺序
    4. 执行父类构造函数
    5. 初始化子类中的普通成员普通代码块,初始化顺序取决于两者在代码中出现的顺序
    6. 执行子类构造函数
    展开全文
  • Java类初始化顺序

    2019-05-27 20:18:04
    文章目录一、Java类初始化顺序说明二、初始化顺序三、总结普通类:继承的子类:抽象的实现子类: 接口 - 抽线类 - 实现类接口注意: 一、Java类初始化顺序说明 一个类中包含如下几类东西,他们前后是有顺序关系的 1....

    一、Java类初始化顺序说明

    一个类中包含如下几类东西,他们前后是有顺序关系的
    1.静态属性:static 开头定义的属性
    2.静态方法块: static{}圈起来的方法块
    3.普通属性:未带static定义的属性
    4.普通方法块:{}圈起来的方法块
    5.构造函数:类名相同的方法
    6.方法:普通方法

    二、初始化顺序

    public class LifeCycle {
        // 静态属性
        private static String staticField = getStaticField();
        // 静态方法块
        static {
            System.out.println(staticField);
            System.out.println("静态方法块初始化");
            System.out.println("Static Patch Initial");
        }
        // 普通属性
        private String field = getField();
        // 普通方法块
        {
            System.out.println(field);
            System.out.println("普通方法块初始化");
            System.out.println("Field Patch Initial");
        }
        // 构造函数
        public LifeCycle() {
            System.out.println("构造函数初始化");
            System.out.println("Structure Initial ");
        }
    
        public static String getStaticField() {
            String statiFiled = "Static Field Initial";
            System.out.println("静态属性初始化");
            return statiFiled;
        }
    
        public static String getField() {
            String filed = "Field Initial";
            System.out.println("普通属性初始化");
            return filed;
        }   
        // 主函数
        public static void main(String[] argc) {
            new LifeCycle();
        }
    }
    

    执行代码:
    在这里插入图片描述

    三、总结

    排前面的先执行

    普通类:

    静态变量
    静态代码块
    普通变量
    普通代码块
    构造函数

    继承的子类:

    父类静态变量
    父类静态代码块
    子类静态变量
    子类静态代码块
    父类普通变量
    父类普通代码块
    父类构造函数
    子类普通变量
    子类普通代码块
    子类构造函数

    抽象的实现子类: 接口 - 抽线类 - 实现类

    接口静态变量
    抽象类静态变量
    抽象类静态代码块
    实现类静态变量
    实习类静态代码块
    抽象类普通变量
    抽象类普通代码块
    抽象类构造函数
    实现类普通变量
    实现类普通代码块
    实现类构造函数

    接口注意:

    声明的变量都是静态变量并且是final的,所以子类无法修改,并且是固定值不会因为实例而变化
    接口中能有静态方法,不能有普通方法,普通方法需要用defalut添加默认实现
    接口中的变量必须实例化
    接口中没有静态代码块、普通变量、普通代码块、构造函数

    展开全文
  • java类初始化顺序

    java类初始化顺序

    静态属性第一个值为null,后赋值
    在这里插入图片描述
    在这里插入图片描述

    public class StaticBlockTest{

    static{
    	 a = 6;
    }
    
    static int a = 9;
    
    public static void main(String[] args)
    {
    	System.out.println("a的值:" + StaticBlockTest.a);
    }
    

    }

    JVM默认初始化变量,后赋值,
    如果static int a = 9;定义类型不同,会报错。

    顺序:a=0 --> a=6 --> a=9

    答案:无论代码顺序,都是静态属性会按声明赋予初始值,int 为0。再根据代码顺序执行。如果类型不同,static代码块里的同名变量会被当做新的变量。代码块里的变量作用范围为本代码块{}范围。

    在这里插入图片描述

    展开全文
  • java类初始化顺序

    2017-01-05 11:11:00
    一、概述 了解类的初始化顺序,可以更...二、类初始化顺序 2.1 示例 public class InitialOrderTest { public static void main(String[] args) { new InitialOrderTest(); } // 变量 public FieldClass fi...

    一、概述

    了解类的初始化顺序,可以更灵活、方便的构造一个类。

    二、类初始化顺序

    2.1 示例

    public class InitialOrderTest {
    
        public static void main(String[] args) {
            new InitialOrderTest();
        }
    
        // 变量
        public FieldClass field = new FieldClass("变量");
    
        // 初始化块
        {
            System.out.println("初始化块");
        }
    
        // 静态变量
        public static FieldClass staticField = new FieldClass("静态变量");
    
        // 静态初始化块
        static {
            System.out.println("静态初始化块");
        }
    
        // 构造器
        public InitialOrderTest() {
            System.out.println("构造器");
        }
    }
    
    public class FieldClass {
        public FieldClass(String msg){
            System.out.println(msg);
        }
    }
    

    2.2 结论

    2.1 示例运印结果:

    1.静态变量
    2.静态初始化块
    3.变量
    4.初始化块
    5.构造器

    三、继承关系初始化顺序

    3.1 示例

    public class Parent {
        
        public Parent(){
            System.out.println("父类构造器");
        }
    
        //静态初始块
        static{
            System.out.println("父类静态初始化");
        }
    
        //静态变量
        public static FieldClass parentStaticField=new FieldClass("父类静态变量");
    
        //初始化块
        {
            System.out.println("父类初始化块");
        }
    
        //变量
        public FieldClass parentField=new FieldClass("父类变量");
    }
    
    
    public class Child extends Parent{
    
        public Child(){
            System.out.println("子类构造器");
        }
    
        //静态初始块
        static{
            System.out.println("子类静态初始化");
        }
    
        //静态变量
        public static FieldClass childStaticField=new FieldClass("子类静态变量");
    
        //初始化块
        {
            System.out.println("子类初始化块");
        }
    
        //变量
        public FieldClass childField=new FieldClass("子类变量");
    
        public static void main(String[] args){
            new Child();
        }
    }
    
    
    public class FieldClass {
        public FieldClass(String msg){
            System.out.println(msg);
        }
    }

    3.2 结论

    3.1 示例打印结果:

    1. 父类静态初始化
    2. 父类静态变量
    3. 子类静态初始化
    4. 子类静态变量
    5. 父类初始化块
    6. 父类变量
    7. 父类构造器
    8. 子类初始化块
    9. 子类变量
    10. 子类构造器

    四、静态变量与静态初始化块、变量与初始化块的顺序

    仔细观察以上两个示例,会发现关于静态变量与静态初始化块、变量与初始化块的结果打印顺序是不同的,所以最终的结论:静态变量和静态初始化块、变量和初始化块的初始化顺序取决于在类中定义的顺序

    转载于:https://www.cnblogs.com/ninth/p/6251589.html

    展开全文
  • Java类初始化顺序说明

    2019-09-26 18:11:17
    Java类初始化顺序说明 一个类中包含如下几类东西,他们前后是有顺序关系的 静态属性:static 开头定义的属性 静态方法块: static {} 圈起来的方法块 普通属性: 未带static定义的属性 普通方法块: {} 圈起来...
  • 派生类初始化顺序 在构造派生类的新实例的过程中,第一步完成其基类的初始化(在之前只有对基类构造函数参数的求值),因此发生在派生类的初始化逻辑运行之前。 open class Base(val name: String) { ​ init ...
  • 【Java】类初始化顺序

    2017-11-29 20:08:59
    类初始化顺序 虚拟机在首次加载Java类时,会对静态代码块、静态成员变量、静态方法进行一次初始化(静态间按顺序执行)。 只有在调用new方法时才会创建类的实例。 类实例创建过程:父子继承关系,先父类再...
  • Java-类初始化顺序

    2018-10-25 14:11:16
    普通类初始化顺序 1. 静态变量 2. 静态代码块 3. 普通变量 4. 普通代码块 5. 构造函数 public class Demo { // 实例变量 String string = getString(); // 静态变量 static String staticString = ...
  • 分析Java类初始化顺序之前,先回顾下类加载的过程和时机 类加载的过程 加载:通过类名从class文件获取二进制流,生成Class对象(在方法区) 连接:包括验证、准备(类变量分配内存、赋初值)、解析(编译期确定...
  • 类是java中重要的引用数据类型,了解类的初始化顺序对正确设计程序逻辑具有重要的指导作用。本文主要从创建对象角度分析类的初始化顺序,主要包含两个方面内容:一是创建对象时各成员的初始化...图2类初始化顺序 ...
  • 类初始化顺序:父类静态变量——父类静态代码块——子类静态代码块——父类非静态变量——父类非静态代码块——父类构造函数——子类非静态变量——子类非静态代码块——子类构造函数 ...
  • JAVA类初始化顺序总结

    2021-02-23 11:41:28
    初始化顺序 带继承关系的,使用网上一张图来表示: OK,的初始化中的知识点基本上就是初始化的顺序。
  • java类初始化顺序 正常类的类加载顺序: 静态变量/静态代码块 => main方法=> 非静态变量/代码块 => 构造方法 继承关系中: package com.example.demo; class Parent { /* 静态变量 */ public static ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,463
精华内容 4,185
关键字:

类初始化顺序