精华内容
下载资源
问答
  • 构造函数顺序
    2019-09-08 09:50:57

    首先对基类进行构造,再对派生类中的对象进行构造,最后再对派生类进行够造。析构的话按照“先进后出”的原则进行析构。
    理解:就像盖房子一样,先将房子盖好(基类)然后再将必要设备装上,比如插排,水龙头等等(定义的对象),最后再根据自己的爱好再添加自己喜欢的东西(派生类的构造函数)。
    注意事项:构造的顺序只和定义的位置有关,与其在参数初始化表的位置无关!

    刚开始写博客,你的爱心,我的动力。希望哥哥姐姐点个赞呀!

    更多相关内容
  • ()方法,其中,成员变量的初始化在构造函数里的初始化动作之前。 public class Test { private String s = "1"; public Test() { s = "2"; } public static void main(String[] args) { Test t = ne

    1、Java虚拟机会将所有的初始化动作手机到<init>()方法中,在分配内存后,就开始调用<init>()方法,其中,成员变量的初始化在构造函数里的初始化动作之前。

    public class Test {
    
        private String s = "1";
    
        public Test() {
            s = "2";
        }
    
        public static void main(String[] args) {
            Test t = new Test();
            System.out.println(t.s); // 输出2
        }
    }

    2、对于有继承的情况,实例化子类时,子类的<init>()方法中第一步是调用父类的<init>()方法,<init>()方法中,成员变量初始化是在构造初始化之前,但是这个例子中由于多态特性,调用到了子类,此时子类的数据还没有初始化,所以输出是null。
     

    public class Base {
        private String baseName = "base";
    
        public Base() {
            callName();
        }
    
        public void callName() {
            System.out.println(baseName);
        }
    
        static class Sub extends Base {
            private String baseName = "sub";
    
            public void callName() {
                System.out.println(baseName);
            }
        }
    
        public static void main(String[] args) {
            Base b = new Sub(); // 输出null
        }
    }

    展开全文
  •  先看看构造函数的调用顺序规则,只要我们在平时编程的时候遵守这种约定,任何关于构造函数的调用问题都能解决;构造函数的调用顺序总是如下:  1.基类构造函数。如果有多个基类,则构造函数的调用顺序是某类在...
  • 主要介绍了C++构造函数初始化顺序详解,是对C++代码的运行机制深入探讨,需要的朋友可以参考下
  •  在说构造函数之前我们得先弄明白几个问题,首先是什么是类的构造函数,什么是类的成员对象,什么是基类,然后我们再来说构造函数的调用顺序。  1、 类的构造函数  构造函数的功能主要用于在类的对象创建时定义...
  • 1,静态变量、静态代码块、变量、普通代码块、mian方法、构造函数的执行顺序是:(静态变量、静态代码块)> main方法 >(变量、普通代码块)>构造函数。2,如果子类调用了父类,那么执行顺序是:(父类静态变量...

    1,静态变量、静态代码块、变量、普通代码块、mian方法、构造函数的执行顺序是:(静态变量、静态代码块)>    main方法 >(变量、普通代码块)>构造函数。

    2,如果子类调用了父类,那么执行顺序是:(父类静态变量、父类静态代码块)>(子类静态变量、子类静态代码块)> main方法 >(父类变量、父类代码块)> 父类构造方法 >(子类变量、子类代码块)> 子类构造方法

    3,子类继承父类简单举例说明:也就是说此时的运行顺序为:

    父类静态块

    自身静态块

    父类块

    父类构造器

    自身块

    自身构造器

    /**

    * 测试父类和子类代码执行顺序

    */

    public class Father1 {

    /**

    * 父类静态代码块

    */

    static {

    System.out.println("父类1静态代码块");

    }

    /**

    * 父类块

    */

    {

    System.out.println("父1类块");

    }

    /**

    * 父类构造方法

    */

    public Father1(){

    System.out.println("父1类构造方法");

    }

    }

    子类代码:

    /**

    * 测试父类和子类代码执行顺序

    */

    public class Child1 extends Father1{

    /**

    * 子类静态代码块

    */

    static {

    System.out.println("子1类静态代码块");

    }

    /**

    * 子类代码块

    */

    {

    System.out.println("子1类块");

    }

    /**

    * 子类构造方法

    */

    public Child1() {

    System.out.println("子1类构造方法");

    }

    public static void main(String args[]){

    System.out.println("main1方法");

    /**

    * 实例化

    */

    Child1 c = new Child1();

    }

    }

    执行结果是:

    父类1静态代码块

    子1类静态代码块

    main1方法

    父1类块

    父1类构造方法

    子1类块

    子1类构造方法

    4,子类2集成父类2,并且在类中实例化父类1。通过下面的例子可以知道静态变量和静态代码块的执行顺序,是按照他们在类中的顺序来执行的。那么执行顺序会是:父类2的静态--子类2的静态--main方法--父类2的常量--父类2的构造--子类2的常量--父类1的静态--父类1的常量-父类1的构造--子类2的构造。也就是说此时的运行顺序为:

    父类2静态块

    自身静态块

    父类2块

    父类2构造器

    自身块

    父类1静态块

    父类1块

    父类1构造器

    自身构造器

    父类:

    /**

    * 测试父类和子类代码执行顺序

    */

    public class Father2 {

    public static String F_STATIC_FILED = "父2类静态变量";

    public String F_FILED = "父2类普通变量";

    /**

    * 父类静态代码块

    */

    static {

    System.out.println(F_STATIC_FILED);

    System.out.println("父2类静态代码块");

    }

    /**

    * 父类块

    */

    {

    System.out.println(F_FILED);

    System.out.println("父2类块");

    }

    /**

    * 父类普通方法

    */

    public void f_method(){

    System.out.println("父2类普通方法");

    }

    /**

    * 父类构造方法

    */

    public Father2(){

    System.out.println("父2类构造方法");

    }

    }

    子类:

    /**

    * 测试父类和子类代码执行顺序

    */

    public class Child2 extends Father2{

    public static String C_STATIC_FILED = "子2类静态变量";

    public String C_FILED = "子2类普通变量";

    /**

    * 子类静态代码块

    */

    static {

    System.out.println(C_STATIC_FILED+"cccc");

    System.out.println("子2类静态代码块");

    }

    /**

    * 子类代码块

    */

    {

    System.out.println("子2类块");

    }

    /**

    * 子类构造方法

    */

    public Child2() {

    System.out.println("子2类构造方法");

    }

    public static void main(String args[]){

    System.out.println("main2方法");

    /**

    * 实例化

    */

    Child2 c = new Child2();

    }

    Father1 f2 = new Father1();

    }

    执行结果是:

    父2类静态变量

    父2类静态代码块

    子2类静态变量

    子2类静态代码块

    main2方法

    父2类普通变量

    父2类块

    父2类构造方法

    子2类块

    父类1静态代码块

    父1类块

    父1类构造方法

    子2类构造方法

    5:总结如下:

    类初始化时构造函数调用顺序:

    (1)初始化对象的存储空间为零或null值;

    (2)调用父类构造函数;

    (3)按顺序分别调用类成员变量和实例成员变量的初始化表达式;

    (4)调用本身构造函数。

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

    父类静态块

    父类构造器

    本类中的块

    本类的构造器

    展开全文
  • C++构造函数按下列顺序被调用:  (1)任何虚拟基类的构造函数按照它们被继承的顺序构造;  (2)任何非虚拟基类的构造函数按照它们被继承的顺序构造;  (3)任何成员对象的构造函数按照它们声明的顺序调用;  (4...
  • 继承构造函数调用顺序 C ++中带有继承的构造函数调用的顺序 (Order of Constructor Call with Inheritance in C++) Base class constructors are always called in the derived class constructors. Whenever you ...

    继承构造函数调用顺序

    Base class constructors are always called in the derived class constructors. Whenever you create derived class object, first the base class default constructor is executed and then the derived class's constructor finishes execution.

    基类构造函数总是在派生类构造函数中调用。 无论何时创建派生类对象,都将首先执行基类的默认构造函数,然后派生类的构造函数完成执行。

    要记住的要点 (Points to Remember)

    1. Whether derived class's default constructor is called or parameterised is called, base class's default constructor is always called inside them.

      无论是调用派生类的默认构造函数还是参数化,都始终在它们内部调用基类的默认构造函数。



    2. To call base class's parameterised constructor inside derived class's parameterised constructo, we must mention it explicitly while declaring derived class's parameterized constructor.

      要在派生类的参数化构造函数内部调用基类的参数化构造函数,必须在声明派生类的参数化构造函数时显式地提及它。

    派生类构造函数中的基类Default构造函数 (Base class Default Constructor in Derived class Constructors)

    Default constructor is present in all the classes. In the below example we will see when and why Base class's and Derived class's constructors are called.

    所有类中都存在默认构造函数。 在下面的示例中,我们将看到何时以及为什么调用基类和派生类的构造函数。

    class Base
    { 
        int x;
        public:
        // default constructor
        Base() 
        { 
            cout << "Base default constructor\n"; 
        }
    };
    
    class Derived : public Base
    { 
        int y;
        public:
        // default constructor
        Derived() 
        { 
            cout << "Derived default constructor\n"; 
        }
        // parameterized constructor
        Derived(int i) 
        { 
            cout << "Derived parameterized constructor\n"; 
        }
    };
    
    int main()
    {
        Base b;        
        Derived d1;    
        Derived d2(10);
    }

    Base default constructor Base default constructor Derived default constructor Base default constructor Derived parameterized constructor

    基本默认构造函数基本默认构造函数派生的默认构造函数基本默认构造函数派生的参数化构造函数

    You will see in the above example that with both the object creation of the Derived class, Base class's default constructor is called.

    在上面的示例中,您将看到在Derived类的两个对象创建过程中,都调用了Base类的默认构造函数。

    派生类构造函数中的基类参数化构造函数 (Base class Parameterized Constructor in Derived class Constructor)

    We can explicitly mention to call the Base class's parameterized constructor when Derived class's parameterized constructor is called.

    我们可以明确提到在调用派生类的参数化构造函数时调用基类的参数化构造函数。

    class Base
    { 
        int x;
        public:
        // parameterized constructor
        Base(int i)
        { 
            x = i;
            cout << "Base Parameterized Constructor\n";
        }
    };
    
    class Derived : public Base
    { 
        int y;
        public:
        // parameterized constructor
        Derived(int j):Base(j)
        { 
            y = j;
            cout << "Derived Parameterized Constructor\n";
        }
    };
    
    int main()
    {
        Derived d(10) ;
    }

    Base Parameterized Constructor Derived Parameterized Constructor

    基本参数化构造函数派生参数化构造函数

    为什么在派生类内部调用基类构造函数? (Why is Base class Constructor called inside Derived class?)

    Constructors have a special job of initializing the object properly. A Derived class constructor has access only to its own class members, but a Derived class object also have inherited property of Base class, and only base class constructor can properly initialize base class members. Hence all the constructors are called, else object wouldn't be constructed properly.

    构造函数有适当的初始化对象的特殊工作。 派生类构造函数只能访问其自己的类成员,但是派生类对象也具有基类的继承属性,并且只有基类构造函数才能正确初始化基类成员。 因此,将调用所有构造函数,否则将无法正确构造对象。

    C ++中的多重继承中的构造方法调用 (Constructor call in Multiple Inheritance in C++)

    Its almost the same, all the Base class's constructors are called inside derived class's constructor, in the same order in which they are inherited.

    几乎相同,所有基类的构造函数都在派生类的构造函数内部被调用,其继承顺序相同。

    class A : public B, public C ;

    In this case, first class B constructor will be executed, then class C constructor and then class A constructor.

    在这种情况下,将首先执行B类构造函数,然后是C类构造函数,然后是A类构造函数。

    翻译自: https://www.studytonight.com/cpp/order-of-constructor-call.php

    继承构造函数调用顺序

    展开全文
  • C++构造函数处理顺序

    2018-08-22 21:18:26
    C++构造函数处理顺序如下: 1、为传入的非引用实参通过拷贝构造函数建立临时变量,引用实参省略这一步。 2、调用基类构造函数。 3、处理成员变量的初始化工作,按照成员变量定义的顺序进行初始化。初始化列表里的...
  • 构造函数的执行次序如下: ...1,调用基类构造函数,调用顺序按照他们的继承时声明的顺序。 2,调用内嵌成员对象的构造函数,调用顺序按照他们在类中声明的 顺序。 3,派生类的构造函数体中的内容。
  • c++中构造函数的调用顺序

    千次阅读 2020-12-16 17:59:39
    c++中构造函数的调用顺序 C++中调用构造函数按照如下顺序: 一:先调用虚拟基类的构造函数。并且按照它们的被继承的顺序进行构造。 二:调用非虚拟基类的构造函数,也是按照它们被继承的顺序构造。 三:调用类中成员...
  • 新建子类对象时一定会调用父类的无参构造函数 子类调用有参构造函数前会调用父类的无参构造函数 子类调用无参构造函数前会调用父类的无参构造函数 若父类定义了有参构造函数而没有定义无参构造函数,则报错 若父类...
  • 构造函数的调用顺序详解

    千次阅读 2021-03-03 13:51:53
    构造函数的调用顺序 子类会默认调用父类的无参构造方法; 子类的有参构造函数中没有super()方法时,不管子类是有参还是无参调用构造方法,都会先默认调用父类的无参构造方法; 有super()方法时会取消默认调用父类的...
  • 子类与父类构造函数调用顺序

    千次阅读 2021-02-22 17:12:06
    子类与父类构造函数调用顺序 构造函数 当创建子类对象时, 构造函数的调用顺序: 静态数据成员的构造函数 -> 父类的构造函数 -> 非静态的数据成员的构造函数 -> 自己的构造函数 注意: 无论创建几个对象, ...
  • 在使用构造函数和析构函数时,需要特别注意对它们的调用时间和调用顺序。在一般情况下,调用析构函数的次序正好与调用构造函数的次序相反:最先被调用的构造函数,其对应的(同一对象中的)析构函数最后被调用,而最后...
  • 构造函数和析构函数的调用顺序

    千次阅读 2019-09-03 15:47:29
    目录构造函数和析构函数构造函数复制构造函数析构函数构造函数与析构函数的调用顺序单继承多继承 构造函数和析构函数 构造函数 构造函数是特殊的成员函数,与类同名,没有返回类型,而且允许重载。如果没有为类显式...
  • JAVA注入与构造函数顺序 @autowired 与构造函数 @Autowired一定要等本类构造完成后,才能从外部引用设置进来。所以@Autowired的注入时间一定会晚于构造函数的执行时间,在构造函数中使用通过@Autowired注入的Bean会...
  • 派生类的构造函数执行顺序

    千次阅读 2020-11-06 21:54:00
    构造函数的执行顺序 1,调用基类构造函数顺序按照它们被继承时声明的顺序(从左向右)。 2,对初始化列表中的成员进行初始化。 顺序按照它们在类中定义的顺序。 对象成员初始化时自动调用其所属类的构造函数。由...
  • 派生类构造函数的参数初始化列表,为什么不能初始化基类的成员? 例如下面的是不可以的 class Rectangle : public Shape { public: Rectangle () : id(1234), name("Rectangle") { // id: 父类Shape...
  • 构造函数执行顺序

    千次阅读 2018-11-17 19:32:18
    通过示例说明: #include class Base ...但是,如果是在Base的构造函数中调用,因为此时Devied还没构造,对象还不是Devied类型,所以调用的是Base::f(),这个查看构造函数中的函数调用可以看出。
  • 1.必须这样做:如果我们有一个类成员,它本身是一个类或者是一个结构,而且这个成员它只有一个带参数的构造函数,而没有默认构造函数,这时要对这个类成员进行初始化,就必须调用这个类成员的带参数的构造函数,如果...
  • 构造函数、析构函数的执行顺序

    千次阅读 2021-03-03 16:33:38
    1) 构造函数顺序 ① 基类构造函数。如果有多个基类,则构造函数的调用顺序是某类在类派生表中出现的顺序,而不是它们在成员初始化表中的顺序。 ② 成员类对象构造函数。如果有多个成员类对象则构造函数的调用顺序...
  • C++多层派生时的构造函数顺序问题

    千次阅读 2014-09-15 15:28:02
    在上面叙述的基础上,不难写出在多级派生情况下派生类的构造函数。 通过例下面的程序,读者可以了解在多级派生情况下怎样定义派生类的构造函数。相信大家完全可以自己看懂这个程序。 [例11.7] 多级派生情况下...
  • 主要介绍了C++类成员构造和析构顺序示例,看了这个例子大家就可以明白c++构造析构的奥秘
  • 继承下构造函数的执行顺序

    千次阅读 2015-09-15 22:41:21
    第一步执行:虚拟基类的构造函数(多个虚拟基类则按照继承的顺序执行构造函数)。 第二步执行:基类的构造函数(多个普通基类也按照继承的顺序执行构造函数)。 第三步执行:类类型的成员对象的构造函数(按照初始...
  • C++构造函数调用顺序

    千次阅读 多人点赞 2019-06-24 09:49:26
    C++构造函数按下列顺序被调用: (1)任何虚拟基类的构造函数按照它们被继承的顺序构造; (2)任何非虚拟基类的构造函数按照它们被继承的顺序构造; (3)任何成员对象的构造函数按照它们声明的顺序调用; (4)类自己...
  • 创建派生类对象时,构造函数的执行顺序是:基类构造函数、派生类对象成员构造函数、派生类本身的构造函数。对象创建时,代码的加载顺序是:静态代码、非静态代码、构造方法。创建派生类对象时,构造函数的执行顺序是...
  • 构造函数和析构函数顺序

    千次阅读 2021-09-29 18:37:22
    1、构造顺序: 创建一个子类对象,则父类、子类的构造方法都执行,且是 先父类 构造方法,再子类构造方法 派生类的构造顺序:先父类,后子类,因为子类很有可能会用到从父类继承来的成员 2、析构顺序 子类成员先被...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 518,832
精华内容 207,532
关键字:

构造函数顺序