.NET继承本质论

之前对于.NET的继承理解的不是很深刻,通过以下小例子让我们加强一下这方面的掌握.高手就算了,呵呵.
1. 引言

关于继承，你是否驾熟就轻，关于继承，你是否了如指掌。

本文不讨论继承的基本概念，我们回归本质，从编译器运行的角度来揭示.NET继承中的运行本源，来发现子类对象是如何实现了对父类成员与方法的继承，以最为简陋的示例来揭示继承的实质，阐述继承机制是如何被执行的，这对于更好的理解继承，是必要且必然的。

2. 分析

下面首先以一个简单的动物继承体系为例，来进行说明：

    public abstract class Animal
    {
        public abstract void ShowType();
        public void Eat()
        {
            Console.WriteLine("Animal always eat.");
        }
    }
    public class Bird: Animal
    {
        private string type = "Bird";
        public override void ShowType()
        {
            Console.WriteLine("Type is {0}", type);
        }
        private string color;
        public string Color
        {
            get { return color; }
            set { color = value; }
        }
    }
    public class Chicken : Bird
    {
        private string type = "Chicken";
        public override void ShowType()
        {
            Console.WriteLine("Type is {0}", type);
        }
        public void ShowColor()
        {
            Console.WriteLine("Color is {0}", Color);
        }
    }


然后，在测试类中创建各个类对象，由于Animal为抽象类，我们只创建Bird对象和Chicken对象。

    public class TestInheritance
    {
        public static void Main()
        {
            Bird bird = new Bird();
            Chicken chicken = new Chicken();
        }
    }


下面我们从编译角度对这一简单的继承示例进行深入分析，从而了解.NET内部是如何实现我们强调的继承机制。

（1）我们简要的分析一下对象的创建过程：

            Bird animal = new Bird();

Bird bird创建的是一个Bird类型的引用，而new Bird()完成的是创建Bird对象，分配内存空间和初始化操作，然后将这个对象赋给bird引用，也就是建立bird引用与Bird对象的关联。

（2）我们从继承的角度来分析在编译器编译期是如何执行对象的创建过程，因为继承的本质就体现于对象的创建过程。

在此我们以Chicken对象的创建为例，首先是字段，对象一经创建，会首先找到其父类Bird，并为其字段分配存储空间，而Bird也会继续找到其父类Animal，为其分配存储空间，依次类推直到递归结束，也就是完成System.Object内存分配为止。我们可以在编译器中单步执行的方法来大致了解其分配的过程和顺序，因此，对象的创建过程是按照顺序完成了对整个父类及其本身字段的内存创建，并且字段的存储顺序是由上到下排列，object类的字段排在最前面，其原因是如果父类和子类出现了同名字段，则在子类对象创建时，编译器会自动认为这是两个不同的字段而加以区别。

然后，是方法列表的创建，必须明确的一点是对象的创建是在运行时，而方法列表的创建是在编译时，在运行时创建对象的过程只是为方法列表加一个指向的指针，将对象与其动态方法列表相关联起来，因此方法列表是先于对象而存在的。类似于字段的创建过程，在编译期方法列表的编译也是父类在先子类在后，原因是显而易见的，类Chicken生成方法列表时，首先将Bird的所有方法拷贝一份，然后和Chicken本身的方法列表做以对比，如果有覆写的虚方法则以子类方法覆盖同名的父类方法，同时添加子类的新方法，从而创建完成Chicken的方法列表。这种创建过程也是逐层递归到Object类，并且方法列表中也是按照顺序排列的，父类在前子类在后，其原因和字段大同小异，留待读者自己体味。

结合我们的分析过程，现在将对象创建的过程以简单的图例来揭示其在内存中的分配情形，如下：

从我们的分析，和上面的对象创建过程可见，对继承的本质我们有了更明确的认识，对于以下的问题就有了清晰明白的答案：

  • 继承是可传递的，子类是对父类的扩展，必须继承父类方法，同时可以添加新方法。
  • 子类可以调用父类方法和字段，而父类不能调用子类方法和字段。
  • 虚方法如何实现覆写操作，使得父类指针可以指向子类对象成员。
  • new关键字在虚方法继承中的阻断作用。

你是否已经找到了理解继承、理解动态编译的不二法门。

3. 思考

通过上面的讲述与分析，我们基本上对.NET在编译期的实现原理有了大致的了解，但是还有以下的问题，一定会引起一定的疑惑，那就是：

            Bird bird2 = new Chicken();

这种情况下，bird2.ShowType应该返回什么值呢？而bird2.type有该是什么值呢？有两个原则，是.NET专门用于解决这一问题的：

  • 关注对象原则：调用子类还是父类的方法，取决于创建的对象是子类对象还是父类对象，而不是它的引用类型。例如Bird bird2 = new Chicken()时，我们关注的是其创建对象为Chicken类型，因此子类将继承父类的字段和方法，或者覆写父类的虚方法，而不用关注bird2的引用类型是否为Bird。引用类型不同的区别决定了不同的对象在方法表中不同的访问权限。

 

注意

根据关注对象原则，那么下面的两种情况又该如何区别呢？

            Bird bird2 = new Chicken();
            Chicken chicken = new Chicken();
根据我们上文的分析，bird2对象和chicken对象在内存布局上是一样的，差别就在于其引用指针的类型不同：bird2为Bird类型指针，而chicken为Chicken类型指针。以方法调用为例，不同的类型指针在虚拟方法表中有不同的附加信息作为标志来区别其访问的地址区域，称为offset。不同类型的指针只能在其特定地址区域内进行执行，子类覆盖父类时会保证其访问地址区域的一致性，从而解决了不同的类型访问具有不同的访问权限问题。
 
  • 执行就近原则：对于同名字段或者方法，编译器是按照其顺序查找来引用的，也就是首先访问离它创建最近的字段或者方法，例如上例中的bird2，是Bird类型，因此会首先访问Bird_type（注意编译器是不会重新命名的，在此是为区分起见），如果type类型设为public，则在此将返回“Bird”值。这也就是为什么在对象创建时必须将字段按顺序排列，而父类要先于子类编译的原因了。

 

思考

1. 上面我们分析到bird2.type的值是“Bird”，那么bird2.ShowType()会显示什么值呢？答案是“Type is Chicken”，根据本文上面的分析，想想到底为什么？

2. 关于new关键字在虚方法动态调用中的阻断作用，也有了更明确的理论基础。在子类方法中，如果标记new关键字，则意味着隐藏基类实现，其实就是创建了与父类同名的另一个方法，在编译中这两个方法处于动态方法表的不同地址位置，父类方法排在前面，子类方法排在后面。
 
在.NET中，如果创建一个类，则该类总是在继承。这缘于.NET的面向对象特性，所有的类型都最终继承自共同的根System.Object类。可见，继承是.NET运行机制的基础技术之一，一切皆为对象，一切皆于继承。本文从基础出发，深入本质探索本源，分析疑难比较鉴别。对于什么是继承这个话题，希望每个人能从中寻求自己的答案，理解继承、关注封装、玩转多态是理解面向对象的起点，希望本文是这一旅程的起点。

以上转自http://blog.csdn.net/cheng_feng001/archive/2007/11/29/1906727.aspx

说一下我的体会:

就近原则很有用,比如        
   Bird bird1 = new Chicken();
   bird1.ShowType();

这个时候,new Chicken后,先找到父类Bird ,发现ShowType方法是可重写的,所以执行Chicken类的ShowType方法.结果为:Type is Chicken

考虑一个问题,如果这时候把Chicken类中的定义改为:        public new void ShowType(),结果会是怎么样的.
答案为输出  bird类.ShowType方法
.结果为:Type is Bird

因为c#是单继承,呵.我的理解就是.先找到父类.看方法是如何定义的,再定本身类的定义.就像上面说的那样.如果父类方法定义为virtual,再看子类,如果子类同名方法定义为override了.那么就调用子类的方法
如
 1public  class Bird
 2    {
 3        private  string type = "Bird父类";
 4        public virtual void ShowType()
 5        {
 6            Console.WriteLine("Type is {0}", type);
 7        }
 8        private string color;
 9        public string Color
10        {
11            get { return color; }
12            set { color = value; }
13        }
 
 1   public class Chicken:Bird
 2    {
 3        private string type = "Chicken子类";
 4        public   override void  ShowType()
 5        {
 6            Console.WriteLine("Type is {0}", type);
 7        }
 8        public void ShowColor()
 9        {
10            Console.WriteLine("Color is {0}", Color);
11        }
12
13    }
 
           Bird bird1 = new Chicken();
           bird1.ShowType();
输出结果为:Type is Chicken子类


如果Bird父类方法定义不变,再看子类,修改Chicken子类如下:那么就调用父类的方法
 1        private string type = "Chicken子类";
 2        public   new virtual void  ShowType()
 3        {
 4            Console.WriteLine("Type is {0}", type);
 5        }
 6        public void ShowColor()
 7        {
 8            Console.WriteLine("Color is {0}", Color);
 9        }
10
11    }
输出结果为:Type is Bird父类



用例下载
https://files.cnblogs.com/pbwf/newabstract.rar

posted on 2008-03-27 15:42  书生  阅读(1106)  评论(1)  编辑  收藏  举报

导航