结论
C++
- 先执行静态成员的构造函数，如果静态成员只是在类定义中声明了，而没有实现，是不用构造的。必须初始化后才执行其构造函数。如：以下只有
a会构建
class Test {
static A a;
static B b;
}
A Test::a;
优先执行虚拟继承的基类，任何虚拟继承的基类，构造函数按照它们被虚拟继承的顺序构造（不是初始化列表中的顺序）
构建其他父类，构造函数按照它们被继承的顺序构造（不是初始化列表中的顺序）
构建成员变量，任何成员对象的构造函数按照它们声明的顺序构造
类自己的构造函数
Java
- 先执行内部静态对象的构造方法，如果有多个按定义的先后顺序执行；静态对象在构造的时候也是也先执行其内部的静态对象
- 调用super(...)方法，也就是调用父类的构造方法（父类还有父类的话，从最开始的基类开始调用）。说明：如果没有明显指定调用父类自定义的构造方法，那么编译器会调用默认的父类构造方法super()。如果要调用父类自定义的构造方法，要在子类的构造方法中明确指定super(...)。
- 按声明顺序将成员引用对象变量初始化（其他成员变量初始化）
- 最后调用自身的构造方法。
测试程序
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
