当前位置: 首页>编程语言>正文

Java和C++中构造函数的执行顺序

结论

C++

  1. 先执行静态成员的构造函数,如果静态成员只是在类定义中声明了,而没有实现,是不用构造的。必须初始化后才执行其构造函数。如:以下只有a会构建
class Test {
    static A a;
    static B b;
}

A Test::a;

  1. 优先执行虚拟继承的基类,任何虚拟继承的基类,构造函数按照它们被虚拟继承的顺序构造(不是初始化列表中的顺序)

  2. 构建其他父类,构造函数按照它们被继承的顺序构造(不是初始化列表中的顺序)

  3. 构建成员变量,任何成员对象的构造函数按照它们声明的顺序构造

  4. 类自己的构造函数

Java

  1. 先执行内部静态对象的构造方法,如果有多个按定义的先后顺序执行;静态对象在构造的时候也是也先执行其内部的静态对象
  2. 调用super(...)方法,也就是调用父类的构造方法(父类还有父类的话,从最开始的基类开始调用)。说明:如果没有明显指定调用父类自定义的构造方法,那么编译器会调用默认的父类构造方法super()。如果要调用父类自定义的构造方法,要在子类的构造方法中明确指定super(...)。
  3. 按声明顺序将成员引用对象变量初始化(其他成员变量初始化)
  4. 最后调用自身的构造方法。

测试程序

C++

#include <iostream>
#include <string>
using namespace std;
 
//抽象类A
class A
{
public:
    A()
    {
        cout<<"抽象类A的构造函数"<<endl;
    }
    //纯虚函数fun
    virtual void fun1() = 0;
};
 
//抽象类B
class B
{
public:
    B()
    {
        cout<<"抽象类B的构造函数"<<endl;
    }
    //纯虚函数fun
    virtual void fun2() = 0;
};
 
//普通类C
class C
{
public:
    C()
    {
        cout<<"类C的构造函数"<<endl;
    }
};
 
//普通类D
class D
{
public:
    D()
    {
        cout<<"类D的构造函数"<<endl;
    }
};
 
//普通类C
class E
{
public:
    E()
    {
        cout<<"类E的构造函数"<<endl;
    }
};
 
//普通类D
class F
{
public:
    F()
    {
        cout<<"类F的构造函数"<<endl;
    }
};
 
//普通类D
class G
{
public:
    G()
    {
        cout<<"类G的构造函数"<<endl;
    }
};
 
//普通类D
class H
{
public:
    H()
    {
        cout<<"类H的构造函数"<<endl;
    }
};
//普通类D
class M
{
public:
    M()
    {
        cout<<"类M的构造函数"<<endl;
    }
};
 
class Test: public A,public B,virtual public C,virtual public D,public E,public F
{
public:
    Test():B(),A(),D(),C(),F(),E()
    {
        cout<<"类Test的构造函数"<<endl;
    }
    void fun1()
    {
    }
    void fun2()
    {
    }
private:
    G g;
    static H h;
    static M m;
};
 
H Test::h;
 
int main(int argc, char* argv[])
{
    Test test;
    return EXIT_SUCCESS;
}
  • 结果
类H的构造函数
类C的构造函数
类D的构造函数
抽象类A的构造函数
抽象类B的构造函数
类E的构造函数
类F的构造函数
类G的构造函数
类Test的构造函数

Java

class Animal{
    String name;
    Animal() {
        System.out.println("class Animal");
    }
    Animal(String name){
        this.name = name;
        System.out.println(name + "  class Animal");
        printNumber();
    }
    
    public void printNumber(){
        
    }
}
 
class Fish extends Animal{
    Fish() {
        System.out.println("class Fish");
    }
}
 
class GoldFish extends Fish {
    GoldFish() {
        System.out.println("class GoldFish");
    }
}
 
class Cat {
    Cat(){
        System.out.println("class cat");
    }
}
 
class Rabbit {
    private static int number;
    private static Cat cat = new Cat();
    public Rabbit() {
        number++;
        System.out.println(number + "class rabbit");
    }
}
 
class Dog extends Animal{
    public int dogNumber;
    private GoldFish goldFish = new GoldFish();
    static  Rabbit blackRabbit = new Rabbit(); 
    static  Rabbit whiterabbit = new Rabbit(); 
    
    public Dog() {
        super("Tom");
        System.out.println("class Dog");
        dogNumber = 10;
        System.out.println("The dog's number is:" + dogNumber);
    }
    
    public void printNumber(){
        System.out.println("The dog's number is:" + dogNumber);
    }
}
 
public class TestInheritanceConstructor extends Animal {
    public static void main(String[] args){
        new Dog();  //Test the executive order of constructor 
    }
}
  • 结果
class cat 
1class rabbit
2class rabbit
Tom  class Animal
The dog's number is:0
class Animal
class Fish
class GoldFish
class Dog
The dog's number is:10

https://www.xamrdz.com/lan/5rt2016667.html

相关文章: