精华内容
下载资源
问答
  • 问题:子类继承父类,构造函数及公共属性的执行顺序是怎样的?  示例代码 <SPAN xss=removed>public class A extends C {  B b = new B();  static H h = new H();  static { ...
  • 子类继承父类,构造函数及公共属性的执行顺序是怎样的? 示例代码 public class A extends C { B b = new B(); static H h = new H(); static { System.out.println("this is static tack"); } static ...

    问题:

    子类继承父类,构造函数及公共属性的执行顺序是怎样的?

    示例代码

    public class A extends C {
    	B b = new B();
    	static H h = new H();
    	static {
    		System.out.println("this is static tack");
    	}
    
    	static void i() {
    		System.out.println("this is static metod");
    	}
    
    	public A() {
    		System.out.println("this is class A");
    
    	}
    
    	public static void main(String[] args) {
    		A a = new A();
    	}
    }
    
    class B {
    	public B() {
    		System.out.println("this is class B");
    	}
    }
    
    class C {
    	D d = new D();
    	static E e = new E();
    	final F e1 = new F();
    	static final G e2 = new G();
    
    	public C() {
    		System.out.println("this is class C");
    	}
    }
    
    class D {
    	public D() {
    		System.out.println("this is class D");
    	}
    }
    
    class E {
    	public E() {
    		System.out.println("this is class E");
    	}
    }
    
    class F {
    	public F() {
    		System.out.println("this is class F");
    	}
    }
    
    class G {
    	public G() {
    		System.out.println("this is class G");
    	}
    }
    
    class H {
    	public H() {
    		System.out.println("this is class H");
    	}
    }

    执行结果:

    this is class E
    this is class G
    this is class H
    this is static tack
    this is class D
    this is class F
    this is class C
    this is class B
    this is class A

    执行顺序:

    1、实现父类公共的静态属性或静态的块级代码

    2、实现本身的公共的静态属性

    3、实现父类公共属性

    4、执行父类的构造方法

    5、实现本身的公共属性

    6、执行本身的构造函数

    7、静态方法不执行

    补充:

    当父类有多个构造函数,若子类用super(参数信息)指明调用父类有参数的构造函数,则不执行无参数的构造方法


    展开全文
  • 【C++】简单的继承执行顺序

    千次阅读 2014-05-22 10:09:05
    我们分析一下:B b:构造一个类B的对象,因为它是继承于类A,所以先执行A中的构造函数,然后再执行自己的构造函数;A *a=&b:声明一个指向A类型的指针,并指向对象b;此时a->fun()执行的就是类B里面的fun();最后main...

    笔试里面考C++基础遇到了好几次这种题目。先上代码

    #include<iostream>
    using namespace std;


    class A
    {
    public:
    A()
    {
    printf("A\n");
    }
    ~A()
    {
    printf("~A\n");
    }
    virtual void fun()
    {
    printf("AA\n");
    }
    };


    class B :public A
    {
    public:
    B()
    {
    printf("B\n");
    }
    ~B()
    {
    printf("~B\n");


    }
    virtual void fun()
    {
    printf("BB\n");
    }
    };


    int main()
    {
    B b;
    A *a=&b;
    a->fun();
    return 0;
    }

    问执行之后的结果。若对C++的继承有所了解,答案应该很快就出来了。我们分析一下:B b:构造一个类B的对象,因为它是继承于类A,所以先执行A中的构造函数,然后再执行自己的构造函数;A *a=&b:声明一个指向A类型的指针,并指向对象b;此时a->fun()执行的就是类B里面的fun();最后main将要将要结束,要析构函数。那么是先析构谁呢?

    当然是B,因为B是A的子类,然后才再执行A的析构函数。因为从逻辑里面分析,构造的时候,要先有父亲才有儿子 先A后B,而析构的时候,要反过来,先从小的开始”删“。

    执行结果是:

    A

    B

    BB

    ~B

    ~A


    展开全文
  • Java继承类的执行顺序

    千次阅读 2016-09-06 14:14:36
    Java继承类的执行顺序

    最近答了一些笔试题,发现继承类的执行顺序这种题基本谁家都问。下面是结合网上其他总结后,自己做了更细致的试验。第一篇博文,话还说不太明白,但是我觉得如果想成为一名好的攻城狮就应该好好写博客,把话说明白了,自己也才能更清楚。我这人不够细心,还好还有点责任心,希望通过写博客来改掉这个坏毛病。

    class People {
        int age;
        String name;
    
        static{
            System.out.println("2、父类的静态代码段");
        }
    
        People(){
            System.out.println("5、父类的无参构造方法");
        }
    
        People(int age , String name){
            this.age = age;
            this.name = name;
            System.out.println("5、父类的有参构造方法");
        }
    
        void eat(){
            System.out.println("8、父类的方法:吃饭!");
        }
    
        {
            System.out.println("4、父类的非静态代码段");
        }
    
        void drink(){
            System.out.println("8、父类的方法:喝水!");
        }
    }
    
    class Student extends People {
        int grade;
        {
            System.out.println("6、子类的非静态代码段");
        }
    
        static{
            System.out.println("3、子类的静态代码段");
        }
    
        Student(){
            //super();运行子类的构造函数前,要先运行父类的构造函数,此处省略默认执行的父类构造函数
            System.out.println("7、子类的无参构造方法");
        }
    
        Student(int age , String name , int grade){
    
            super(age,name);//运行子类的有参构造函数前,要先运行父类的有参构造函数,若父类无有参的构造函数,则执行父类的无参的构造函数
            this.grade = grade;
            System.out.println("7、子类的有参构造方法 " + name + "," + age + "岁," + grade + "年级。");
        }
    
        void eat(){
            System.out.println("8、子类的方法:吃饭!");
        }
    }
    
    public class ExtendedClassOrder {
        public static void main(String[] args) {
            // TODO Auto-generated method stub
            System.out.println("1、main()方法");
    
            Student s1 = new Student();
            s1.eat();
            s1.drink();
            System.out.println("---------------");
            Student s2 = new Student(19, "LEE", 1);
            s2.eat();
            System.out.println("---------------");
            People s3 = new Student();
            s3.drink();
        }
    }

    执行结果:
    1、main()方法
    2、父类的静态代码段
    3、子类的静态代码段
    4、父类的非静态代码段
    5、父类的无参构造方法
    6、子类的非静态代码段
    7、子类的无参构造方法
    8、子类的方法:吃饭!
    8、父类的方法:喝水!
    ---------------
    4、父类的非静态代码段
    5、父类的有参构造方法
    6、子类的非静态代码段
    7、子类的有参构造方法 LEE,19岁,1年级。
    8、子类的方法:吃饭!
    ---------------
    4、父类的非静态代码段
    5、父类的无参构造方法
    6、子类的非静态代码段
    7、子类的无参构造方法
    8、父类的方法:喝水!

    试验发现:

    • 父类的方法都先于子类的执行,只有子类的静态代码段会紧跟父类的静态代码段先执行。 静态的代码段只执行一次。
    • 非静态的代码段每次创建对象的时候都会执行一次,且先于构造方法执行。
    • 子类执行普通方法是,如果是子类覆盖了父类的方法则执行子类方法,如果没有覆盖则执行父类方法。
    展开全文
  • 主要介绍了Python多重继承的方法解析执行顺序,结合实例形式分析了Python多重继承时存在方法命名冲突情况的解析执行顺序与相关原理,需要的朋友可以参考下
  • 一个派生类构造函数的执行顺序如下: 第一步执行:虚拟基类的构造函数(多个虚拟基类则按照继承的顺序执行构造函数)。 第二步执行:基类的构造函数(多个普通基类也按照继承的顺序执行构造函数)。 第三步执行:...

    这里先给出结论,在贴出代码与执行结果~

     

    一个派生类构造函数的执行顺序如下:

    第一步执行:虚拟基类的构造函数(多个虚拟基类则按照继承的顺序执行构造函数)。

    第二步执行:基类的构造函数(多个普通基类也按照继承的顺序执行构造函数)。

    第三步执行:类类型的成员对象的构造函数(按照初始化顺序)。

    第四部执行:派生类自己的构造函数。

     

    如果一个派生类不仅继承于一个基类,而且还有这个基类的成员对象,那么会进行两次构造函数的执行(一个用于初始化派生类中基类部分的内部成员,另一个是初始化派生类的基类类型成员变量的内部成员),详细看派生类Son2的执行结果。

    下面声明了A,B,C,D,Object1,Object2留个基类以及Son1Son2Son3Son4Son5Son5是一个错误的例子,编译不能通过)

    每个基类都有两个构造函数,默认的构造函数不接受参数,输出的Default+字符串

    带参数的输出的自己类的特有信息。

     

    (为了方便观看,我在后面会再贴一下结论)

    参考Son1:可以验证上述派生类构造函数的执行顺序;

    参考Son2:可以验证构造函数是严格照上面所说的顺序执行,与初始化的顺序无关。同时,如果不显示的执行基类构造函数的初始化,就会按照顺序调用默认的构造函数。

    参考Son3可以说明继承下执行的构造函数与类类型的成员变量的构造函数是占用两个不同的内存地址空间,二者不会相互影响。

    参考Son4:可以说明,无论是否显示的初始化类类型的成员变量,都会按照成员变量在类中的声明顺序执行构造函数。

    参考Son5:这个解决了我之前的疑问,如果在派生类的构造函数中初始化类类型的成员对象会怎么样,发现这样是不可取的,因为在类的声明中是不可以实际分配内存的,但是可以声明。

    (关于Son5的理解需要进一步阐明:这里可能涉及到了C++内存分配,拷贝赋值的原理,如果不是很懂的话这里我们暂且按我说的方式去理解。)


    classA
    {
    public:
    	A(intnum){Show();}
    	A(){cout<<"Defaultaaa"<<endl;}
    	voidShow(){cout<<"aaa"<<endl;} 
    };
    classB
    {
    public:
    	B(intnum){Show();}
    	B(){cout<<"Defaultbbb"<<endl;}
    	voidShow(){cout<<"bbb"<<endl;} 
    };
    classC
    {
    public:
    	C(intnum){Show();}
    	C(){cout<<"Defaultccc"<<endl;}
    	voidShow(){cout<<"ccc"<<endl;} 
    };
    classD
    {
    public:
    	D(intnum){Show();}
    	D(){cout<<"Defaultddd"<<endl;}
    	voidShow(){cout<<"ddd"<<endl;} 
    };
    classObject1
    {
    public:
    	Object1(intnum){Show();}
    	Object1(){cout<<"DefaultObject1"<<endl;}
    	voidShow(){cout<<"Object1"<<endl;} 
    };
    classObject2
    {
    public:
    	Object2(intnum){Show();}
    	Object2(){cout<<"DefaultObject2"<<endl;}
    	voidShow(){cout<<"Object2"<<endl;} 
    };
    classSon1:publicA,virtualpublicB,publicC,virtualpublicD
    {
    public:
    Son1():A(1),B(1),C(1),D(1),ob1(1),ob2(1){
    	cout<<"son1"<<endl;
    	}
    	Object1ob1;
    	Object2ob2;
    };
    classSon2:publicA,virtualpublicB,publicC,virtualpublicD
    {
    public:
    	Son2():C(1),A(1),ob1(1),ob2(1){     //结果仍然是先执行A的构造函数,其次是C的,证明与初始
    		cout<<"son2"<<endl;          //化的顺序无关
    	}
    	Object1ob1;
    	Object2ob2;
    };
    classSon3:publicA,virtualpublicB,publicC,virtualpublicD,virtualpublicObject1,publicObject2
    {
    public:
    	Son3():ob1(1),ob2(1){
    		cout<<"son3"<<endl;
    	}
    	Object1ob1;
    	Object2ob2;
    };
    classSon4:publicA,virtualpublicB,publicC,virtualpublicD,virtualpublicObject1,publicObject2
    {
    public:
    	Son4():ob2(1){ //注意,如果Object1没有默认构造函数,这里将无法编译通过
    		cout<<"son4"<<endl;
    	}
    	Object1ob1;
    	Object2ob2;
    };
    //class Son5:publicA,virtual public B,publicC,virtual public D
    //{
    //public:
    //	Son5():A(1),B(1),C(1),D(1){
    //		cout<<"son5"<<endl;
    //       ob2=ob1;  //这里编译不通过,没有与这些操作数匹配的”=”运算符(二者类型不同,需要重新定义‘=’)
    //		ob1(1);   
    //		ob2(2);   //这里编译不通过,在没有适当的operate()的情况下调用类类型对象
    //	}
    //	Object1 ob1(1);  // 这里编译不通过,因为类的成员声明不需要分配内存,这样写就相当于执行
                       //构造函数并分配内存了
    //	Object2 ob2;    
    //};
    int_tmain(intargc, _TCHAR* argv[])
    {
    cout<<"------------SON1------------"<<endl;
    	Son1son1;
    	cout<<"------------SON2------------"<<endl;
    	Son2son2;
    	cout<<"------------SON3------------"<<endl;
    	Son3son3;
    	cout<<"------------SON4------------"<<endl;
    	Son4 son4;
    	Object1obj;
    	//son4.ob1(1);  //这句话是错误的编译不通过,在没有适当的operate()的情况下调用类类型对象
    	son4.ob1=obj;
    	system("pause");  //这句只是为了让cmd停留显示,以免闪退(VS控制台程序需要)
    	return 0;
    }
    

    以上代码是在VS2012ConsoleApplication控制台下编译测试的,结果如下:


    再贴一遍:

    参考Son1:可以验证一开始介绍的派生类构造函数的执行顺序;

    参考Son2:可以验证构造函数是严格照上面所说的顺序执行,与初始化的顺序无关(尽管表面上C比A初始化的要早)。同时,如果不显示的执行基类构造函数的初始化,就会按照顺序调用默认的构造函数。

    参考Son3可以说明继承下执行的构造函数与类类型的成员变量的构造函数是占用两个不同的内存地址空间,二者不会相互影响。

    参考Son4:可以说明,无论是否显示的初始化类类型的成员变量,都会按照成员变量在类中的声明顺序执行构造函数。

    参考Son5:这个解决了我之前的疑问,如果在派生类的构造函数中初始化类类型的成员对象会怎么样,发现这样是不可取的,因为在类的声明中是不可以实际分配内存的,但是可以声明。



    展开全文
  • 继承中的构造方法执行顺序

    千次阅读 2019-04-17 09:25:57
    继承中的构造方法执行顺序 在子父类中,创建子类对象,调用子类的构造方法, 在子类的构造方法的第一行代码如果没有调用父类的构造或者没有调用子类的其他构造,则默认调用父类无参构造。 为什么要调用父类构造...
  • Java中继承执行顺序

    千次阅读 2017-01-15 14:59:48
    若类C继承类B,类B继承类A,则类C既有从类B那里继承下来的属性与方法,也有从类A那里继承下来的属性与方法,还可以有自己新定义的属性和方法。继承来的属性和方法尽管是隐式的,但仍是类C的属性和方法。继承是在一些...
  • java中子类继承父类程序执行顺序

    千次阅读 2018-01-15 15:35:49
    Java中,new一个类的对象,类里面的静态代码块、非静态代码、无参构造方法、有参构造方法、类的一般方法等部分,它们的执行顺序相对来说比较简单,用程序也很容易验证。比如新建一个测试父类。 public class ...
  • 2.要想继承父类的变量,需要执行父类的__init__(self)方法 3.下划线开头的变量或方法,会被认为是受保护的,不能直接点出来,但如果强制打出来的话也一样能用,只是会有警告 4.静态方法中不能使用self,用@...
  • 在java程序中, 在子类继承父类时, 执行顺序是怎样的呢? 代码实现: /** * super 子类通过super调用父类的成员,也可以super()调用父类构造方法 但是也是必须放在第一句 * */ public class TestExtends2 { ...
  • 1.MainService继承自BaseService 首次启动MainService与第二次启动MainService时onCreate、onStartCommand的执行顺序
  • 继承时构造函数和析构函数的执行顺序 单一继承:先调用父类构造函数,再调用子类的构造函数多重继承:调用基类构造函数的顺序是继承时的顺序
  • C++多继承构造函数执行顺序

    千次阅读 2012-11-29 22:14:56
    在C++的构造函数初始化列表里,类成员的初始化顺序与其声明顺序相同,而在类的多继承中,构造函数的执行顺序便与“继承声明”顺序相同了,详见代码:   #include using namespace std; class C{ public: C(){...
  • 2 多重继承构造器执行顺序 3 基于trait的AOP代码实战//这讲内容对做大型项目十分重要,trait本身可以有方法的实现,这样做大型工程的具体模块时,可以让这个模块混入很多不同trait,以实现这个模块功能的不同方面。...
  • C#继承执行顺序以及override关键字

    千次阅读 2018-08-06 09:14:21
    1.B继承A,请问a是A的实例还是B的实例啊? 答:B的实例 2.对象a可以调用A类中的方法吗?可以调用B的方法吗? 答:不一定,如果是虚拟方法,并且在B类重载了A的虚拟方法,a将会调用B的同名方法,普通方法会调用A的...
  • class 派生类名:继承方式1 基类名1,继承方式2 基类名2,.... {  //派生类成员定义 }; 对每个基类可以用不同的继承方式,默认继承方式为private。  在多重继承中,派生类的构造函数与单继承下...
  • 执行顺序,父类中的静态代码块,子类中的静态代码块,父类中的代码块,父类中的无参构造方法,子类中的代码块,子类中的无参构造方法   如查子类有参的构造函数 new Children(“a”,"b"); 执行顺序:...
  • Java学习之继承中的执行顺序详解

    千次阅读 2015-01-04 11:24:02
    代码块(理解) (1)用{}括起来的代码。 (2)分类: A:局部代码块 用于限定变量的生命周期,及早释放,提高内存利用率。 B:构造代码块 把多个构造方法中相同的代码可以放到...(3)静态代码块,构造代码块,构造方法的顺序问题?
  • java 子类继承父类各方法的执行顺序

    千次阅读 2018-05-01 18:24:03
    结论: java中子类继承父类各方法的执行顺序:(这里只写jvm自动调用的方法的顺序,包括静态代码块、代码块、构造方法) 1、第一次创建子类对象 父类静态代码块 子类静态代码块 父类代码块 父类构造方法 子类...
  • 个人在总结心得:对于继承中的构造函数和属性初始化的执行顺序:父前初始及子后,即先是进行父类的构造函数,在进行属性的初始化操作,最后是子类的构造函数 package com.sxt; public class A1 { //父类的...
  • java继承中new子类对象的执行顺序

    千次阅读 2017-05-13 19:55:10
    下面测试代码块,静态代码块,构造器的初始化顺序 public class TestExtends { public static void main(String[] args) { A a = new A(5); /*输出结果: * B constructor A.draw(), radius = 0 A constructor A....

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 377,959
精华内容 151,183
关键字:

继承执行顺序