精华内容
下载资源
问答
  • Java构造函数调用顺序

    千次阅读 2015-04-27 21:46:40
    使用super调用父类构造器的语句必须...如果父类没有不带参数的构造器,并且在子类的构造器中又没有显式地调用父类的构造器,则java编译器将报告错误 父类: public class Parents { private int age; private Strin

    使用super调用父类构造器的语句必须是子类构造器的第一条语句,如果子类构造器没有显式地调用父类的构造器,则将自动调用父类的默认(没有参数)的构造器。如果父类没有不带参数的构造器,并且在子类的构造器中又没有显式地调用父类的构造器,则java编译器将报告错误


    父类:

    public class Parents {
        private int age;
        private String name;
        {
            System.out.println("Parents property init");
        }
    
        public Parents() {
            // TODO Auto-generated constructor stub
            age = 100;
            name = "parents";
            System.out.println("Parents no parem constructor init");
        }
    }
    

    子类:

    public class Childs extends Parents {
        private String points;
        {
            System.out.println("childs property init");
        }
        public Childs(String points) {
            // TODO Auto-generated constructor stub
            this.points = points;
            System.out.println("Childs constructor init");
        }
        
        public static void main(String[] args) {
            // TODO Auto-generated method stub
            Parents child = new Childs("100");
        }
    
    }
    

    输出结果:

    Parents property init
    Parents no parem constructor init
    childs property init
    Childs constructor init

    此时子类的构造函数没有显示调用父类的构造函数,那么调用的是父类的默认无参构造函数,所以父类必须要么只定义无参构造函数,要么不存在任何构造函数,要么在存在有参构造函数情况下必须定义无参构造函数


    总结继承关系中,当new一个对象时,调用顺序如下(此时不讨论静态代码块static修饰的代码块)

    1. 首先初始化父类的成员变量,如果后面跟有代码块那么执行该块-》Parents property init

    2. 调用父类的构造函数 -》Parents no parem constructor init

    3. 初始化子类的成员变量,如果后面跟有代码块那么执行该块 -》childs property init

    4. 调用子类的构造函数 -》Childs constructor init


    注意如果此时父类还有父类,那么首先会初始化父类的父类的成员变量,然后父类的父类的构造函数,以此类推,总是第一个初始化最顶层父类的变量和调用父类的构造函数

    展开全文
  • Java构造函数调用顺序问题

    千次阅读 2017-06-07 19:18:15
    java构造代码调用顺序研究。

    今天对Java的构造函数调用顺序进行研究,使用的是与C++类似的方法,即不对源码进行研究,而是直接通过打印代码对构造函数的调用顺序进行研究。

    代码如下,使用的是Java核心技术中的代码,对其进行了改造,在构造函数中加入了输出信息

    public class ConstructorTest
    {
       public static void main(String[] args)
       {
    	Employee temp = new Employee();
       }
    }
    
    class Employee
    {
       private static int nextId;
       private static int counter;
    
       private int id;
       private String name = ""; // instance field initialization
       private double salary;
      
       // static initialization block
       static
       {
          Random generator = new Random();
          // set nextId to a random number between 0 and 9999
          nextId = generator.nextInt(10000);
          System.out.println(" static initialization block : " + counter++);
       }
    
       // object initialization block
       {
          id = nextId;
          nextId++;
          System.out.println(" object initialization block : " + counter++);
       }
    
       // three overloaded constructors
       public Employee(String n, double s)
       {
          name = n;
          salary = s;
          System.out.println(" constructors1 : " + counter++);
       }
    
       public Employee(double s)
       {
          // calls the Employee(String, double) constructor
          this("Employee #" + nextId, s);
          System.out.println(" constructors2 : " + counter++);
       }
    
       // the default constructor
       public Employee()
       {
          // name initialized to ""--see above
          // salary not explicitly set--initialized to 0
          // id initialized in initialization block
    	   System.out.println(" constructors3 : " + counter++);
       }
    
    
    }

    运行结果如下:

     static initialization block : 0
     object initialization block : 1
     constructors3 : 2

    通过上述程序验证了:所有数据域被初始化为默认值(0,false,NULL),此处counter初始化为0。

    再来看第二条规则:按照类声明中出现的次序,依次执行所有域初始化语句和初始化块。

    程序运行结果显示先执行静态初始化块后执行域初始化块,可以通过调换上述两个初始化块的次序对这一规则进行验证。

    这里书中的讲解并不是很清楚,静态初始化块的优先级要高于域初始化块,因此静态初始化块的执行要早于域初始化块,只有在同级别的情况下,才按照声明的顺序调用,这一点我通过将static去掉进行了验证。

    代码:

    // object initialization block
       {
          id = nextId;
          nextId++;
          System.out.println(" object initialization block : " + counter++);
       }
       
       // static initialization block
       {
          Random generator = new Random();
          // set nextId to a random number between 0 and 9999
          nextId = generator.nextInt(10000);
          System.out.println(" static initialization block : " + counter++);
       }


    执行结果

     object initialization block : 0
     static initialization block : 1
     constructors3 : 2


    构造函数最后调用,没有什么问题。

    最后一点:如果构造器第一行调用了第二个构造器,则执行第二个构造器的主体。

    最后还有一点非常重要的内容,构造器调用一定要是第一句,否则编译出错。在构造器中只能调用一次其他构造函数,不能调用两次,即无法再调用第三个构造函数。

    本人是初学者,还无法从JVM的角度分析问题,同时回应各位大神对文中的错漏进行指出。





    展开全文
  • 初学Java和C++一样,Java中如果有继承时,先调用父类的构造函数调用子类的构造函数, 如果某类的有类对象的成员,则在在调用该类的构造函数之前先要调用类成员变量的构造函数。eg.class A{ A() //构造函数 { ...

    初学Java

    和C++一样,Java中如果有继承时,先调用父类的构造函数再调用子类的构造函数, 如果某类的有类对象的成员,则在在调用

    该类的构造函数之前先要调用类成员变量的构造函数。

    eg.

    class A

    {

        A() //构造函数

        {

            System.out.println("class A Constructor!");

        }

    }


    class B

    {

        B() //构造函数

        {

            System.out.println("class B Constructor!");

         }

    }


    public class C extends A    //类A是类C的父类

    {

        B b = new B();   //类C中有B类对象作为成员变量

        C()

         {

            System.out.println("class C Constructor!");

         }

     

        public static void main(String args[])

        {

            C c = new C();

        }

    }

    输出结果

    Java中构造函数调用顺序 - 大灰狼 - 大灰狼 的博客

    首先进入public类,调用C构造函数之前先调用父类A构造函数,调用了父类的构造函数之后初始化成员变量,调用B类的构造函数,

    最后调用类C的成员函数。

     

     

     

    展开全文
  • java初始化构造函数调用顺序

    千次阅读 2015-03-06 09:51:19
    类初始化时构造函数调用顺序:  (1)初始化对象的存储空间为零或null值;  (2)调用父类构造函数;  (3)按顺序分别调用类成员变量和实例成员变量的初始化表达式;  (4)调用本身构造函数。 例子: ...

    原文链接:http://blog.sina.com.cn/s/blog_6caeccff0100q5wz.html


    类初始化时构造函数调用顺序:
      (1)初始化对象的存储空间为零或null值;
      (2)调用父类构造函数;
      (3)按顺序分别调用类成员变量和实例成员变量的初始化表达式;
      (4)调用本身构造函数

    例子:
    public class Dollar extends Money{
        Rmb r=new Rmb();
        
        public Dollar(){
         
         System.out.println("Dollar is construct!");
        
        }
        public static void main(String[] args){
         
         new Dollar();
         
        }
    }

    class Money{
     public Money(){
      System.out.println("Money isconstruct");
     }
    }

    class Rmb{
     public Rmb(){
      System.out.println("RMB isconstruct");
     }
    }

    输出结果:
    Money is construct
    RMB is construct
    Dollar is construct!

    在我们的程序中,实例化一个类对象的时候,运行顺序为:

     

    1.  静态块
    2.  父类构造器
    3.  本类中的块
    4.  本类的构造器 

    public class Dog {   

       public Dog() {  

         System.out.println("Dog");  

        }  

        static{   //静态块

            System.out.println("super static block");  

        }       

      {  

            System.out.println("super block");  

        }  

    }  

     public class Mastiff extends Dog {  

        public Mastiff() {  

            System.out.println("Mastiff");  

        }  

         {  

            System.out.println("block");  

           }   

       static {  

          System.out.println("static block");  

     }   

      public static void  main(String[] args){   

          Mastiff mastiff=new Mastiff();         //实例化一个对象

        }  

    }   

    输出结果:
    super staticblock
    staticblock
    superblock
    Dog
    block
    Mastiff

     也就是说此时的运行顺序为:

    1.   父类静态块
    2.   自身静态块
    3.   父类块
    4.   父类构造器
    5.   自身块
    6.   自身构造器

    展开全文
  • 1、首先调用父类的无参构造函数(这个构造han)
  • Java类中的初始化块,可以有静态和非静态两种。   静态初始化块中的语句,在类首次被加载时执行。   非静态初始化块中的语句,如同写在类的每一个...下面谈谈继承结构下的构造函数调用以及成员初始化。   J
  • 关于父类与子类的构造函数调用顺序
  • 本文摘抄自:http://blog.csdn.net/zhanghaotian2011/article/details/9040935对于JAVA中类的初始化是一个很基础的问题,其中的一些问题也是易被学习...不管基于什么原因,我认为,对于java类中的初始化问题,有必要深
  • Java构造函数调用父类构造函数

    万次阅读 2016-09-21 09:54:39
    子类可以通过super关键字来显式地调用父类的构造函数。 当父类没有提供无参数的构造函数时,子类的构造函数中必须显式的调用父类的构造函数; 如果父类提供了无参数的构造函数,此时子类的构造函数就可以不显式的...
  • 当一个复杂的对象被构造时,它的构造函数按下面的顺序调用(that the order of constructor calls for a complex object is as follows) 1.其基类(base-class)的构造函数调用,这个步骤以递归的方式重复,所以最...
  • java关于继承中构造函数调用顺序

    千次阅读 2014-03-27 23:00:10
    * 在java中用子类去创建一个对象的时候会首先调用父类的无参构造函数 * 然后再去调用自己的构造函数 * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub ...
  • JAVA构造函数调用方法函数 javastringclassfileimportdate 在构造器中调用多态方法进行初始化,也许会产生不可预料的结果。 [java] view plaincopy import java.io.FileWriter; import java.io....
  • Java构造方法调用顺序的理解

    千次阅读 2018-06-08 17:02:34
    ​ 之前对构造函数的调用顺序一直很迷,只知道很死板地记着“父类构造函数先于子类构造函数调用”,但是其中的原因并没有去深究。前几周大概看了一遍JAVA编程思想,真的是博大精深……但是对这个概念起码有了一点...
  • JAVA构造函数调用

    2016-02-17 17:06:08
    在说构造函数之前,必须要了解什么叫做重载。 重载是在同一个类中允许有重名的方法存在,但方法的参数必须不同。参数的个数不同或参数的类型不同或参数的顺序不,不能用方法的返回类型来决定方法的重载,重载经常...
  • java 构造函数 重载 递归调用

    千次阅读 2017-11-28 11:24:32
    1)有人写了个很好的初始化属性的构造函数,而你仅仅想要在其中添加另一些自己新建属性的初始化,这样在一个构造函数调用另外一个构造函数,可以避免重复的代码量,减少工作量; 2)在一个构造函数调用另外一...
  • 一个以前没有注意的问题:java构造函数的执行顺序 昨天在改一处代码时发现执行的过程和预想的不一样,仔细探究才发现是构造器执行顺序问题.(汗自己一下,基础不够扎实) 特地做了一些尝试然后把java构造器的执行...
  • 创建对象时,会先自动调用父类的构造函数,再自动调用子类的构造函数。 解释:super()表示父类的构造函数并会调用于参数相对应的父类中的构造函数。子类中,它在调用父类中空参数的构造函数。因为子类继承父类,会...
  • 如果一个类中没有构造函数的话编译器会默认为该类创建一个无参空构造器  如果子类自己没有构造方法,则它将继承父类的无参数构造方法作为自己的构造方法; 下面用一个例子验证下 public class Demo03 { ...
  • java 构造函数什么时候被调用执行

    千次阅读 2021-03-30 21:26:41
    java语言 中,构造函数又称构造方法。特殊性在于,与普通方法的区别是,他与类名相同,不返回结果也不加void返回值。构造函数的作用是初始化对象,即在创建对象时被系统调用(与普通方法不同,程序不能显示调用...
  • java构造函数在什么时候被调用及特点1 构造函数在什么时候被调用2 构造函数特点 1 构造函数在什么时候被调用 在java语言 中,构造函数又称构造方法。构造函数的作用是初始化对象,即在创建对象时被系统调用(与普通...
  • 每个构造函数执行都会经过三个阶段(注意这是一个类似递归的过程): 2.1 显式调用(super)父类的构造函数或者隐式调用父类的无参构造函数。如果是显示调用this构造函数,则这种调用链会一直执行到遇到某个显式...
  • 虚拟继承是C++语言中一个非常重要但是又比较生僻的存在,它的定义非常简单,但是对于理解C++的继承机制却是...意图是要设计一个不能被继承的类,类似java中的final。但是又可以生成栈对象,可以像一般的C++类一样使用。
  • 在初始化块上相比C++,java有一个独特的地方就是静态数据块,正常java调用顺序是先调用static静态数据块,然后再调用普通的初始化数据块,最后调用类的构造函数!下面是代码显示: class Animal{ static { System.out...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 177,196
精华内容 70,878
关键字:

java构造函数调用顺序

java 订阅