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

    2010-07-26 11:01:00
    对象初始化顺序

    初始化 顺序应该是.

    父静态变量-->子静态变量-->父非静态变量-->父静态代码块-->父构造函数------>子非变量-->子静态代码块-->子构造函数

     

    以上是网上盛传的

    其实应该是这样:(大家自己写代码验证)

    1.  父类静态成员和静态初始化块 ,按在代码中出现的顺序依次执行
    2.  子类静态成员和静态初始化块 ,按在代码中出现的顺序依次执行
    3.  父类实例成员和实例初始化块 ,按在代码中出现的顺序依次执行
    4.  父类构造方法
    5.  子类实例成员和实例初始化块 ,按在代码中出现的顺序依次执行
    6.  子类构造方法
    附测试代码:
     
     
    测试结果:

     

    展开全文
  • 对象初始化顺序: 当无虚基类的时候:按照继承时候声明的顺序进行基类构造函数,这个是为了将继承的部分进行初始化;按照成员对象在类中的声明顺序进行成员对象的初始化,这是因为在创建对象之前必须对成员进行...

    当无虚基类的时候:按照继承时候声明的顺序进行基类构造函数,这个是为了将继承的部分进行初始化;按照成员对象在类中的声明顺序进行成员对象的初始化,这是因为在创建对象之前必须对成员进行初始化,这部分可以在构造函数初始化列表中进行;执行子类的构造函数体,对各部分进行初始化。

    销毁顺序与初始化相反。

    展开全文
  • 一、 代码块的概念在探究对象初始化顺序之前,我们先通过代码来了解一下代码块的概念。class Test{ public static String str1; //静态字段 public String str2; //普通字段 static{ //静态代码块 } { //构

    一、 代码块的概念

    在探究对象初始化顺序之前,我们先通过代码来了解一下代码块的概念。

    class  Test{
        public static String str1;  //静态字段
    
        public String str2;         //普通字段
    
        static{                     
            //静态代码块
        }
    
        {
            //构造代码块
        }
    
        public Test() {  
            //构造函数
        }
    }

    二、 创建子类对象时,对象的初始化顺序

    1. 字段初始化、代码块和构造函数的执行顺序

    我们先看代码和结果

    public class CodeBlockTest {
    
        public static void main(String[] args) {
            Child child = new Child();
        }
    
    }
    
    class Father {
        public static String fatherStr1 = "fatherStr1(静态字段初始化值)";
    
        public String fatherStr2 = "fatherStr2(字段初始化值)";
    
        static {
            System.out.println("父类静态代码块:" + fatherStr1);
            fatherStr1 = "fatherStr1(静态代码块赋值)";
        }
    
        {
            System.out.println("父类构造代码块:" + fatherStr2);
            fatherStr2 = "fatherStr2(构造代码块赋值)";
        }
    
        public Father() {
            System.out.println("父类构造函数块:" + fatherStr2);
            fatherStr2 = "fatherStr2(构造函数赋值)";
        }
    }
    
    class Child extends Father {
    
        public static String childStr1 = "childStr1(静态字段初始化值)";
    
        public String childStr2 = "childStr2(字段初始化值)";
    
        static {
            System.out.println("子类静态代码块:" + childStr1);
            childStr1 = "childStr1(静态代码块赋值)";
        }
    
        {
            System.out.println("子类构造代码块:" + childStr2);
            childStr2 = "childStr2(构造代码块赋值)";
        }
    
        public Child() {
            System.out.println("子类构造函数:" + childStr2);
            childStr2 = "childStr2(构造函数赋值)";
        }
    }
    
    //    输出结果:
    //    父类静态代码块:fatherStr1(静态字段初始化值)
    //    子类静态代码块:childStr1(静态字段初始化值)
    //    父类构造代码块:fatherStr2(字段初始化值)
    //    父类构造函数块:fatherStr2(构造代码块赋值)
    //    子类构造代码块:childStr2(字段初始化值)
    //    子类构造函数:childStr2(构造代码块赋值)
    

    通过每执行一个代码块或构造函数,输出字段在上一代码块执行后的值,以此来探究对象的初始化顺序。
    由目前的输出结果可知,对于对象的初始化顺序,我们可以得出以下结论:
    1. 父类静态字段初始化
    2. 父类静态代码块、子类静态字段初始化 (接下来探究两者的顺序)
    3. 子类静态代码块
    4. 父类普通字段初始化
    5. 父类构造代码块
    6. 父类构造函数
    7. 子类普通字段初始化
    8. 子类构造代码块
    9. 子类构造函数

    2. 父类静态代码块和子类静态字段初始化的执行顺序

    还是一样,我们通过代码的执行结果来探究两者间的执行顺序。

    public class CodeBloacTest2 {
    
        public static void main(String[] args) {
            Child child = new Child();
        }
    
    }
    
    
    class Father {
        public static String fatherStr = "(静态字段初始化值)";
    
        static {
            System.out.println("父类静态代码块:fatherStr" + fatherStr);
            fatherStr = "(静态代码块赋值)";
        }
    }
    
    class Child extends Father {
    
        public static String childStr = fatherStr;
    
        static {
            System.out.println("子类静态代码块:childStr = fatherStr" + childStr);
            childStr = "(静态代码块赋值)";
        }
    }
    
    //    输出结果:
    //    父类静态代码块:fatherStr(静态字段初始化值)
    //    子类静态代码块:childStr = fatherStr(静态代码块赋值)

    我们在子类静态字段childStr初始化的时候,赋的是父类静态字段fatherStr的值。由输出结果可知,childStr初始化后的值是父类静态代码块执行后赋予fatherStr的值。由此可知两者的执行顺序为:父类静态代码块==>子类静态字段初始化

    三、 结论

    1. 父类静态字段初始化
    2. 父类静态代码块
    3. 子类静态字段初始化
    4. 子类静态代码块
    5. 父类普通字段初始化
    6. 父类构造代码块
    7. 父类构造函数
    8. 子类普通字段初始化
    9. 子类构造代码块
    10. 子类构造函数

    通过结论我们可以很明显的看出:static字段、代码块的执行顺序优先于非static字段、代码块。这是因为在静态域是属于类的,在类加载后就一直存在;而普通域需要创建对象才能访问。而在创建对象时,需要先加载父类,然后再加载子类,因此父类的静态字段初始化和静态代码块执行先于子类

    展开全文
  • Java之创建对象初始化顺序

    千次阅读 2018-09-28 16:12:47
    父类静态成员(包括方法和变量,按顺序初始化) 子类静态成员(包括方法和变量,按顺序初始化) 父类成员变量(包括非静态代码块) 父类构造方法 子类成员变量(包括非静态代码块) 子类构造方法 验证代码:...

    创建顺序如下

    1. 父类静态成员(包括方法和变量,按顺序初始化)
    2. 子类静态成员(包括方法和变量,按顺序初始化)
    3. 父类成员变量(包括非静态代码块)
    4. 父类构造方法
    5. 子类成员变量(包括非静态代码块)
    6. 子类构造方法

    验证代码

    // 主类,用来创建子类对象,验证我们的结果
    public class Main {
        public static void main(String[] args) {
            new Son();
        }
    }
    
    // 书类,用于测试对象成员变量
    class Book{
        public Book(String user){
            System.out.println(user + "成员变量");
        }
    }
    
    // 子类
    class Son extends Fa{
        static Book book= new Book("子类静态");
        static{
            System.out.println("子类静态代码块");
        }
        
        Book sBook = new Book("子类");
        {
            System.out.println("子类非静态代码块");
        }
        
        public Son(){
            System.out.println("子类构造方法");
        }
    }
    
    // 父类
    class Fa{
        static Book book= new Book("父类静态");
        static{
            System.out.println("父类静态代码块");
        }
        
        Book fBook = new Book("父类");
        {
            System.out.println("父类非静态代码块");
        }
    
        public Fa(){
            System.out.println("父类构造方法");
        }
    }
    
    
    

    输出结果

    父类静态成员变量
    父类静态代码块
    子类静态成员变量
    子类静态代码块
    父类成员变量
    父类非静态代码块
    父类构造方法
    子类成员变量
    子类非静态代码块
    子类构造方法

    展开全文
  • java对象初始化顺序

    千次阅读 2018-08-10 10:18:34
    Java初始化顺序 类变量(静态变量)、实例变量(非静态变量)、静态代码块、非静态代码块 的初始化时机 由 static 关键字修饰的(如:类变量[静态变量]、静态代码块)将在类被初始化创建实例对象之前被初始化,...
  • non-local static对象初始化顺序

    千次阅读 2016-01-20 17:06:19
    non-local static对象什么是non-local?,non-local这个术语其实是我在effective c++这本书中学到的术语,这个术语指的是非函数局部局部用域内的.那么non-local static对象有指的是什么呢?,其实说到static(不是指...
  • 关键字static及对象初始化顺序

    千次阅读 2018-09-14 11:33:59
    1.static 变量 静态变量和非静态变量的区别: 静态变量在方法区被所有的对象所共享,...而非静态变量是对象所拥有的,在创建对象的时候被初始化,存在多个副本,各个对象拥有的副本互不影响。 2.static方法 sta...
  • Java 对象初始化顺序 执行顺序

    千次阅读 2015-10-14 22:59:53
    从程序的执行顺序去解答: 1.编译;当这个类被编译通知后,会在相应的目录下生成两个.class 文件。一个是 Base.class,另外一个就是Base$Sub.class。这个时候类加载器将这两个.class 文件加载到内存   2、Base
  • java创建对象的几种方式: (1) 用new语句创建对象,这是最常见的创建对象的方法。 (2) 运用反射手段,调用java.lang.Class或者java.lang.reflect....(4) 运用反序列手段,调用java.io.ObjectInputStream对象的 readO
  • 静态属性和静态代码块看书写先后顺序 5.统一类型(非数据类型),按代码书写顺序 父类静态变量,父类静态代码块 子类静态变量,子类静态代码块 父类非静态变量,父类非静态代码块 父类构造函数,子类非静态...
  • 初看到这个题目,你可能会有些疑惑:C++类对象的创建还有什么好说的,不就是调用构造函数么?实际上情况并不是想象中的那么简单,大量的细节被隐藏或者被忽略了,而这些细节又是解决一些其他问题的关键,所以我们很...
  • 1.静态成员变量从属于一个类而非某个具体的对象,它的值被该类的所有对象所共享... 先初始化 静态变量 然后运行静态构造函数 #region//类A B中都含有static变量 构造函数 class A { public static int X; static A
  • C# 对象初始化顺序分析

    千次阅读 2015-01-20 21:49:24
    C#对象初始化顺序
  • java 对象属性初始化顺序

    千次阅读 2018-05-30 16:19:56
    A、类的初始化顺序如下: ->1、为静态属性分配内存并赋值(后面大括号语句不执行,这里是初始化,只是添加变量和值)   或 执行静态代码块(立刻执行大括号里面的语句)  为什么这样说呢,因为谁在前先加载...
  • 1. 初始化块:  1) 在类中可以定义和方法平行的代码块,例如:public class A { { /* 初始化块 */ } ... },即直接用花括号括起来的代码块;  2) 这种代码块就是初始化代码块,用于给数据成员初始化,里面可以调用...
  • C++ 类对象初始化顺序

    千次阅读 2018-05-16 17:02:58
     基类构造函数如果有多个基类,则构造函数的调用顺序是某类在类派生表中出现的顺序而不是它们在成员初始化表中的顺序;4. 成员类对象构造函数如果有多个成员类对象,则构造函数的调用顺序是对...
  • -- Start 对象初始化方式 ...对象初始化方式的顺序 下面的例子演示了对象各种初始化方式的顺序. public class Test {  public static void main(String[] args) {  new Student();  } } class
  •  然后是成员初始化,这个部分在类的构造函数前初始化,因为编译器(或者设计者)可能认为构造函数调用了这个成员变量,所以在其前初始化了。或者说是成员自己有自己的能力来初始化自己,不用构造函数来管,这部分属于...
  • 在上一篇文章中, 探索了在一条继承链中静态初始化块和静态变量初始化初始化块和实例域初始化、构造函数的执行顺序(见...如果new一个自身类的对象赋值给静态变量来初始化的执行顺序会是怎么样... 以下是代码:package ...
  • 当一个对象被创建时,初始化的过程是这样的: 1. 父类静态成员和静态初始化块 ; 2. 子类静态成员和静态初始化块; 3. 父类实例成员和实例初始化块 ; 4. 父类构造方法; 5. 子类实例成员和实例初始化...
  • C++派生类对象构造函数初始化顺序

    千次阅读 2014-03-22 21:21:16
    答:(1)先调用基类中的构造函数(如果有多个基类,根据继承时声明的顺序进行初始化) (2)再调用成员类中的构造函数(如果有多个成员类,根据其声明的顺序进行初始化) (3)最后初始化派生类本身的构造函数 #...
  • java基础-延伸,变量的初始化顺序从这篇文章java基础-反射1(类型信息,Class对象简介,Class对象初始化) 我们可以了解到类在第一次使用时类加载到内存中的顺序有三个步骤 类的加载:由类加载器执行,根据类名查找...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 520,901
精华内容 208,360
关键字:

对象的初始化顺序