C#继承的执行顺序

  自己对多态中构造函数、函数重载执行顺序和过程一直有些不理解,经过测试,对其中的运行顺序有了一定的了解,希望对初学者有些帮助。

eg1:

public  class A
    {
        public A()
        {
            Console.WriteLine(‘A‘);
        }
        public virtual void Fun()
        {
            Console.WriteLine("A.Fun()");
        }
    }

    public class B : A
    {
        public B()
        {
            Console.WriteLine(‘B‘);
        }
        public void Fun()
        {
            Console.WriteLine("B.Fun()");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            A a = new A();
            a.Fun();
            Console.ReadLine();
        }
    }

上述Main方法中在new A对象时,程序首先进入class A中,执行class A的构造函数A(),然后执行class A中的Fun()方法,故运行结果为:

eg2:

 public  class A
    {
        public A()
        {
            Console.WriteLine(‘A‘);
        }
        public void Fun()
        {
            Console.WriteLine("A.Fun()");
        }
    }

    public class B : A
    {
        public B()
        {
            Console.WriteLine(‘B‘);
        }
        public void Fun()
        {
            Console.WriteLine("B.Fun()");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            B b = new B();
            b.Fun();
            Console.ReadLine();
        }
    }

上述Main方法中在new B对象时,由于B:A先执行父类的构造函数,所以先执行A中的构造函数A(),然后在执行B中的构造函数B(),故运行结果为:

eg3:

 public  class A
    {
        public A()
        {
            Console.WriteLine(‘A‘);
        }
        public void Fun()
        {
            Console.WriteLine("A.Fun()");
        }
    }

    public class B : A
    {
        public B()
        {
            Console.WriteLine(‘B‘);
        }
        public void Fun()
        {
            Console.WriteLine("B.Fun()");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            /*   B b = new A();  错误
             * A是父类,不能new一个父类对象指向子类,例:中国人是人类的对象,人类的对象不一定是中国人*/
            A a = new B();
            a.Fun();
            Console.ReadLine();
        }
    }

上述Main方法中先new B对象,先执行A中的构造函数A(),然后在执行B中的构造函数B(),最后调用class A的Fun()方法,故运行结果为:

eg4:

public  class A
    {
        public A()
        {
            Console.WriteLine(‘A‘);
        }
        public virtual void Fun()
        {
            Console.WriteLine("A.Fun()");
        }
    }

    public class B : A
    {
        public B()
        {
            Console.WriteLine(‘B‘);
        }
        public override void Fun()
        {
            Console.WriteLine("B.Fun()");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            A a = new B();
            a.Fun();
            Console.ReadLine();
        }
    }

上述Main方法同样是先new B对象,先执行A中的构造函数A(),然后在执行B中的构造函数B(),但是子方法中使用了override关键字“覆盖”,使得子类中方法覆盖了父类中的方法,无法再访问父类中原始方法。(要重写方法,父类方法必须有virtual关键字),所以其运行结果为:

eg5:

public  class A
    {
        public A()
        {
            Console.WriteLine(‘A‘);
        }
        public virtual void Fun()
        {
            Console.WriteLine("A.Fun()");
        }
    }

    public class B : A
    {
        public B()
        {
            Console.WriteLine(‘B‘);
        }
        public new void Fun()
        {
            Console.WriteLine("B.Fun()");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            A a = new B();
            a.Fun();
            Console.ReadLine();
        }
    }

上述Main方法同样是先new B对象,先执行A中的构造函数A(),然后在执行B中的构造函数B(),但是子方法中使用了new关键字,由于其仍是a是A类型对象,所以仍然调用A中的方法,其运行结果如下:

时间: 2024-10-23 09:07:37

C#继承的执行顺序的相关文章

java 静态、main、继承 的执行顺序

静态块:用static申明,JVM加载类时执行,仅执行一次 构造块:类中直接用{}定义,每一次创建对象时执行 public class Study_static { public static char text = 'a'; //静态对象 public Study_static(){ //构造函数 System.out.println('c'); } { //构造块 System.out.println('b'); } static{ //静态块 System.out.println(text

含有虚继承的多继承构造函数执行顺序

1 #include<iostream> 2 using namespace std; 3 4 class Base1 5 { 6 public: 7 Base1() 8 { 9 cout << "class Base1" << endl; 10 } 11 }; 12 13 class Base2 14 { 15 public: 16 Base2() 17 { 18 cout << "class Base2" <

java类与继承的执行顺序

1.子类 public class TestClassLife extends TestClassLifeSuper { public TestClassLife() { System.out.println("3.构造行数被访问"); } { System.out.println("2.初始化块被访问"); } static { System.out.println("1.静态初始化块被访问"); } public void Go() { Sy

类代码块的执行顺序

1.执行 执行结果: 2.继承的执行顺序 .执行结果: 原文地址:https://www.cnblogs.com/jljg/p/12195554.html

java中子类继承父类程序执行顺序问题

Java中,new一个类的对象,类里面的静态代码块.非静态代码.无参构造方法.有参构造方法.类的一般方法等部分,它们的执行顺序相对来说比较简单,用程序也很容易验证.比如新建一个测试父类. public class FatherTest { private String name; FatherTest(){ System.out.println("--父类的无参构造函数--"); } FatherTest(String name){ this.name=name; System.out

继承构造函数的执行顺序

转自:http://blog.csdn.net/daheiantian/article/details/6438782 Code: #include <iostream> using namespace std; class A { public: A() { cout<<"int A::A()"<<endl; } A(A &a) { cout<<"int A::A(A &a)"<<endl

继承中代码的执行顺序

在继承中代码的执行顺序为:1.父类静态对象和静态代码块   2.子类静态对象和静态代码块 3.父类非静态对象和非静态代码块  4.父类构造函数 5.子类非静态对象和非静态代码块  6.子类构造函数 1.对于本题来说:在只想new Sub(5)的时候,父类先初始化了 int flag = 1,然后执行父类的构造函数Super(),父类构造函数中执行的test()方法,因子类是重写了test()方法的,因此父类构造函数中的test()方法实际执行的是子类的test()方法,所以输出为Sub.test

【Java基础】继承中的代码块和构造方法的执行顺序探索

本文讲述有关一个类的静态代码块,构造代码块,构造方法的执行流程问题.首先来看一个例子 /** * Created by lili on 15/10/19. */ class Person{ static { System.out.println("执行Person静态代码块"); } { System.out.println("执行Person构造代码块"); } public Person(){ System.out.println("执行Person构

Java子类继承父类,当实例化子类对象时的执行顺序

子类继承父类,当实例化子类对象时,执行顺序如下:     父类层级静态块      自身静态块     父类块      父类构造器     自身块      自身构造器 由于继承,肯定应该先加载父类再加载子类,加载类自然会调用静态块,然后是调用父类的构造函数和子类的构造函数,不过构造函数调用前肯定要先调用域或块,这样才能正确创建对象. ················································赋值顺序如下:     父类的静态变量赋值     自身的静态变