精华内容
下载资源
问答
  • 我们先来建立一个父类,一个子类,一个子类子类 class BaseClass { private string name = "BaseClass"; public BaseClass() { Console.WriteLine(name); } } clas...

     

    我们先来建立一个父类,一个子类,一个子类的子类

    
        class BaseClass
        {
            private string name = "BaseClass";
    
            public BaseClass()
            {
                Console.WriteLine(name);
            }
        }
    
    
        class SubClass1:BaseClass
        {
            private string name = "SubClass1";
    
            public SubClass1()
            {
                Console.WriteLine(name);
            }
        }
    
        class SubClass1_1:SubClass1
        {
            private string name = "SubClass1_1";
    
            public SubClass1_1()
            {
                Console.WriteLine(name);
            }
        }

    在构造函数中分别输出对应类内建立的私有变量name

    在主函数中,输入

                BaseClass bc=new SubClass1_1();

    然后,运行

     

    先 想 一 想 输 入 是 什 么 ……

     

    5

    4

    3

    2

    1

     

    揭晓答案

    我们看到,首先输出了父类BaseClass的变量值,然后是SubClass1,最后才是SubClass1_1的。

     

    实例化父类时,可以通过new子类来实例化父类,执行构造函数的顺序为:先执行父类的构造函数,再执行子类的构造函数

     

     

    再见

    展开全文
  • 关于父类与子类构造函数调用顺序

    废话不多说先上代码:
    父类:

    class People{
    
        String name;
        public People(){
            System.out.printf("1");
        }
    
        public People(String name){
            System.out.printf("2");
            this.name=name;
        }
    
    }
    

    子类:

    class Child extends People{
    
        People father;
    
        public Child(String name){
            System.out.printf("3");
            this.name=name;
            father=new People(name+"F");
        }
    
        public Child(){
            System.out.printf("4");
        }
    
    }
    

    测试类:

    public class Test {
        public static void main(String[] args) {
    
            Child c=new Child("mike");
    
        }
    }
    

    执行结果为:132
    由此可以看出Java中,子类的构造过程中必须调用其父类的构造函数,因为继承关系,子类必须把父类的内容继承下来。但如果父类有多个构造函数时,该如何选择调用呢?
    1.子类的构造过程中,必须 调用其父类的构造方法。一个类,如果我们不写构造方法,那么编译器会默认帮我们加上一个默认的构造方法(就是没有参数的构造方法),如果你自己写了构造方法,那么编译器就不会给你添加了,所以有时候当你new一个子类对象的时候,肯定调用了子类的构造方法,但是如果在子类构造方法中我们并没有显示的调用基类的构造方法,如:super();这样就会调用父类没有参数的构造方法。从上面测试类中我们可以看出我们调用的是子类中有参数的构造方法,而且该构造方法并没有显示的调用基类的构造方法,所以默认会调用基类中没有参数的构造方法,所以执行结果为:132

                如果将子类有参数的构造方法改为:        
    
                public Child(String name){
                    super(name);
                    System.out.printf("3");
                    this.name=name;
                    father=new People(name+"F");
                }
    

    执行结果为:232
    2.如果子类的构造方法中既没有显示的调用基类构造方法,而基类中又没有无参的构造方法,则编译出错,所以,通常我们需要显示的:super(参数列表),来调用父类有参数的构造函数,此时无参的构造函数就不会被调用。
    总之,一句话:子类没有显示调用父类构造函数,不管子类构造函数是否带参数都默认调用父类无参的构造函数,若父类没有则编译出错。

    展开全文
  • 子类与父类构造函数调用顺序 构造函数 当创建子类对象时, 构造函数的调用顺序: 静态数据成员的构造函数 -> 父类的构造函数 -> 非静态的数据成员的构造函数 -> 自己的构造函数 注意: 无论创建几个对象, ...

    子类与父类构造函数调用顺序

    构造函数

    • 当创建子类对象时, 构造函数的调用顺序:

      静态数据成员的构造函数 -> 父类的构造函数 -> 非静态的数据成员的构造函数 -> 自己的构造函数

      注意:

      无论创建几个对象, 该类的静态成员只构建一次, 所以静态成员的构造函数只调用1次!!!

    析构函数

    子类的析构函数的调用顺序,和子类的构造函数的调用顺序相反!!!

    记住,相反即可。

    #include <iostream>
    #include <Windows.h>
    
    using namespace std;
    
    class M {
    public:
    	M() {
    		cout << __FUNCTION__ << endl;
    	}
    
    	~M() {
    		cout << __FUNCTION__ << endl;
    	}
    };
    
    class N {
    public:
    	N() {
    		cout << __FUNCTION__ << endl;
    	}
    
    	~N() {
    		cout << __FUNCTION__ << endl;
    	}
    };
    
    class A {
    public:
    	A() {
    		cout << __FUNCTION__ << endl;
    	}
    
    	~A() {
    		cout << __FUNCTION__ << endl;
    	}
    };
    
    class B : public A {
    public:
    	B() {
    		cout << __FUNCTION__ << endl;
    	}
    
    	~B() {
    		cout << __FUNCTION__ << endl;
    	}
    private:
    	M m1;
    	M m2;
    	static N ms;
    };
    
    N B::ms;  //静态成员
    
    int main(void) {
    	{
    		B b;
    		cout << endl;
    	}
    
    	system("pause");
    }
    

    执行:
    //调用构造
    N::N
    A::A
    M::M
    M::M
    B::B

    //调用析构
    B::~B
    M::~M
    M::~M
    A::~A
    静态对象在程序终止时被销毁,所以:
    静态成员的析构函数,在程序结束前,是不会被调用的!

    展开全文
  • 子类父类构造函数调用顺序

    千次阅读 2017-01-18 20:43:48
    子类继承和调用父类的构造方法 1.如果子类没有定义构造方法,则调用父类的无参数的构造方法,. 2.如果子类定义了构造方法,不论是无参数还是带参数,在创建子类的对象的时候,首先执行父类无参数的构造方法,然后...
    子类继承和调用父类的构造方法

    1.如果子类没有定义构造方法,则调用父类的无参数的构造方法,.

    2.如果子类定义了构造方法,不论是无参数还是带参数,在创建子类的对象的时候,首先执行父类无参数的构造方法,然后执行自己的构造方法。

    3.如果子类调用父类带参数的构造方法,可以通过super(参数)调用所需要的父类的构造方法,切该语句做为子类构造方法中的第一条语句

    4.如果某个构造方法调用类中的其他的构造方法,则可以用this(参数),切该语句放在构造方法的第一条.

    说白了:原则就是,先调用父亲的.(没有就默认调,有了就按有的调,反正只要有一个就可以了.

    子父类中的构造函数。

    在对子类对象进行初始化时,父类的构造函数也会运行,
    那是因为子类的构造函数默认第一行有一条隐式的语句 super();
    super():会访问父类中空参数的构造函数。而且子类中所有的构造函数默认第一行都是super();

    为什么子类一定要访问父类中的构造函数。

    因为父类中的数据子类可以直接获取。所以子类对象在建立时,需要先查看父类是如何对这些数据进行初始化的。
    所以子类在对象初始化时,要先访问一下父类中的构造函数。
    如果要访问父类中指定的构造函数,可以通过手动定义super语句的方式来指定。

    注意:super语句一定定义在子类构造函数的第一行。

     

    子类的实例化过程。

    结论:
    子类的所有的构造函数,默认都会访问父类中空参数的构造函数。
    因为子类每一个构造函数内的第一行都有一句隐式super();

    当父类中没有空参数的构造函数时,子类必须手动通过super语句形式来指定要访问父类中的构造函数。

    当然:子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数。
    子类中至少会有一个构造函数会访问父类中的构造函数


    展开全文
  • #include #include using namespace std;... int main(){ //子类调用父类构造函数顺序 //静态类成员 父类成员 非静态成员 子类自己 //静态类成员 只调用一次 B b; cout ; B b2; system("pause"); return 0; }
  • 调用基类的构造函数,再调用派生类的构造函数 就像盖楼的时候先从地基开始,然后第一层,第二层。 如果是析构,那么先调用派生类的析构函数,再调用基类的析构函数 就像拆楼的时候想从最高层开始拆,然后往下...
  • c++中 子类父类的构造函数调用顺序

    千次阅读 2014-03-18 21:50:00
    问题:创建一个对象调用构造函数的时候是从子类向父类调用还是从父类向子类调用 回答:1、对于构造函数,先调用基类的构造函数,再调用派生类的构造函数。就像盖楼的时候先从地基开始,然后第一层,第二层。。。 ...
  • 因为构造函数是公有的,所以理所当然地会被子类继承。 程序1: #include &lt;iostream&gt; using namespace std; class Shape { public: Shape() { cout &lt;&lt; "Shape's ...
  • 创建对象时,会先自动调用父类的构造函数,再自动调用子类构造函数。 解释:super()表示父类的构造函数并会调用于参数相对应的父类中的构造函数子类中,它在调用父类中空参数的构造函数。因为子类继承父类,会...
  • Python—子类构造函数调用super().__init__()

    万次阅读 多人点赞 2018-10-15 19:25:22
    如果子类(Puple_Init)继承父类(Person)做了初始化,且不调用super初始化父类构造函数,那么子类(Puple_Init)不会自动继承父类的属性(name)。 如果子类(Puple_super)继承父类(Person)做了初始化,且调用了super初始...
  • C++构造函数调用顺序

    千次阅读 2019-06-24 09:49:26
    C++构造函数按下列顺序调用: (1)任何虚拟基类的构造函数按照它们被继承的顺序构造; (2)任何非虚拟基类的构造函数按照它们被继承的顺序构造; (3)任何成员对象的构造函数按照它们声明的顺序调用; (4)类自己...
  • C++中类的构造函数调用顺序

    千次阅读 2015-09-23 17:02:28
    当建立一个对象时,首先调用基类的构造函数,然后调用下一个派生类的构造函数,依次类推,直至到达派生类次数最多的派生次数最多的类的构造函数为止。简而言之,对象是由“底层向上”开始构造的。因为,构造函数一...
  • Java构造函数调用顺序

    千次阅读 2015-04-27 21:46:40
    使用super调用父类构造器的语句必须是子类构造器的第一条语句,如果子类构造器没有显式地调用父类的构造器,则将自动调用父类的默认(没有参数)的构造器。如果父类没有不带参数的构造器,并且在子类的构造器中又...
  • 构造函数调用顺序

    2006-09-25 21:30:00
    1.构造函数调用顺序(多层继承中):子类构造函数一定会调用父类的构造函数。这个步骤会反复递归,使继承阶层的根源最先被建构,然后使次一层的derived class,直至最末一层的derived class为止。
  • 初学Java和C++一样,Java中如果有继承时,先调用父类的构造函数调用子类构造函数, 如果某类的有类对象的成员,则在在调用该类的构造函数之前先要调用类成员变量的构造函数。eg.class A{ A() //构造函数 { ...
  • 直接举例说明,看下面程序和结果。... //父类构造函数 public HelloA() { System.out.println("HelloA"); } //父类块 {System.out.println("I am A");} //父类静态块 static { System.out.pr
  • Java:简述父类与子类构造函数调用次序 一、题目: 下列代码在执行new Child(“test”)的时候,输出结果是什么呢? class People { String name; public People() { System.out.println(1); } public ...
  • 继承与派生,多继承,函数重载,构造函数调用顺序
  • ②:子类构造过程中,必定会调用其父类的构造方法,就算我们没有写,编译器也会隐式的帮助我们使用super()来调用父类的无参构造方法。 所以在这里进行子类的new时,会先打印父类的无参构造的...
  • 1.实例化父类时,可以通过new子类来实例化父类,执行构造函数顺序为:先执行父类的构造函数,再执行子类构造函数。 2.实例化子类时,只可以new子类,执行顺序同上。 3.父类实例化后,只能执行父类的方法,获得...
  • 子类和父类的构造函数调用顺序 当创建子类对象时, 构造函数调用顺序: 静态数据成员的构造函数 -> 父类的构造函数 -> 非静态的数据成员的构造函数 -> 自己的构造函数 注意: 无论创建几个对象, 该类的...
  • 父类B静态代码块->子类A静态代码块->父类B非静态代码块->父类B构造函数->子类A非静态代码块->子类构造函数
  • Java类中的初始化块,可以有静态和非静态两种。   静态初始化块中的语句,在类首次被加载时执行。   非静态初始化块中的语句,如同写在类的每一个...下面谈谈继承结构下的构造函数调用以及成员初始化。   J
  • 一 super调用父类构造器 子类构造器总会调用父类构造器。 如果子类构造器没有显示使用super调用...二 构造器调用顺序示例 1 代码示例 class Creature { public Creature() { System.out.println("Creature
  • 1、首先调用父类的无参构造函数(这个构造han)

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 116,814
精华内容 46,725
关键字:

子类构造函数调用顺序