深入理解OOP(二):多态和继承(继承)

本文是深入浅出OOP第二篇，主要说说继承的话题。

继承的介绍

在OOP中，继承有如下的定义：

  • 继承是一种OOP的机制，用于派生继承预定义的类
  • 在这个继承关系中，预定义的类是基类，新类是子类
  • 继承常常用于实现代码重用
  • 继承允许子类复用基类非private的的数据和方法

继承的实现

创建一个Console工程，命名为InheritanceAndPolymorphism。添加ClassA、ClassB类，并拷贝下面的代码：

ClassA:

   class ClassA
     {

     }

ClassB:

    class ClassB
    {
        public int x = 100;
        public void Display1()
        {
            Console.WriteLine("ClassB Display1");
        }
        public void Display2()
        {
            Console.WriteLine("ClassB Display2");
        }
    }

在Program.cs中，调用ClassA

class Program
    {
        static void Main(string[] args)
        {

            ClassA a = new ClassA();
            a.Display1();
        }
    }

如果运行，肯定会报错的。

Error: ‘InheritanceAndPolymorphism.ClassA‘ does not contain a definition for ‘Display1‘ and no extension method ‘Display1‘ accepting a first argument of type ‘InheritanceAndPolymorphism.ClassA‘ could be found

因为我们在ClassA中未定义Display1的方法。 下面我们重写，使ClassA继承自ClassB。

ClassA:

  class ClassA:ClassB
    {

    }

ClassB:

class ClassB
    {
        public int x = 100;
        public void Display1()
        {
            Console.WriteLine("ClassB Display1");
        }
        public void Display2()
        {
            Console.WriteLine("ClassB Display2");
        }
    }

再次运行，结果如下：

ClassB Display1

ClassA已经可以访问其基类的Display1函数了，这个简单的实例说明了继承可复用基类的妙处，下面这张图以父子财产继承关系说明了继承的意义。

再来看另外一个场景，假设ClassA也有一个Display1函数，签名和其基类一样的：

class ClassA:ClassB
    {
        public void Display1()
        {
            System.Console.WriteLine("ClassA Display1");
        }
    }

ClassB:

class ClassB
    {
        public int x = 100;
        public void Display1()
        {
            Console.WriteLine("ClassB Display1");
        }
        public void Display2()
        {
            Console.WriteLine("ClassB Display2");
        }
    }

执行后结果如下：

ClassA Display1

看起来结果是对的，ClassA默认调用了自己的Display1函数，但是Visual Studio有一个警告：

Warning: ‘InheritanceAndPolymorphism.ClassA.Display1()‘ hides inherited member ‘InheritanceAndPolymorphism.ClassB.Display1()‘. Use the new keyword if hiding was intended.

C#中对方法的调用首先是查询ClassA自己中有无Display1函数，再查询其基类有无Display1函数。在基类和子类出现同样函数的情况现实项目中是存在的，可能是基类代码过于陈旧了，子类既想用同签名的函数，又无法停止基类的同签名函数，故会出现这样的警告---尽管逻辑正确，但是这种设计还是有一些瑕疵的。

我们再试试在CalssA中通过base调用基类同名方法的情况：

ClassA:

  class ClassA:ClassB
    {
        public void Display1()
        {
            Console.WriteLine("ClassA Display1");
            base.Display1();
        }
    }

ClassB:

class ClassB
    {
        public int x = 100;
        public void Display1()
        {
            Console.WriteLine("ClassB Display1");
        }
        public void Display2()
        {
            Console.WriteLine("ClassB Display2");
        }
    }

执行结果如下：

ClassA Display1

ClassB Display1

这个实验说明C#提供了base关键词，用于在继承中子类调用基类的函数或者变量(非private类型)。

同样的，在ClassA.Display1中调用其基类的Display2也是可以的，代码如下所示：

/// <summary>
   /// ClassB: acting as base class
   /// </summary>
   class ClassB
    {
        public int x = 100;
        public void Display1()
        {
            Console.WriteLine("ClassB Display1");
        }
        public void Display2()
        {
            Console.WriteLine("ClassB Display2");
        }
    }

    /// <summary>
    /// ClassA: acting as derived class
    /// </summary>
    class ClassA : ClassB
    {
        public void Display1()
        {
            Console.WriteLine("ClassA Display1");
            base.Display2();
        }
    }

    /// <summary>
    /// Program: used to execute the method.
    /// Contains Main method.
    /// </summary>
    class Program
    {
        static void Main(string[] args)
        {
            ClassA a = new ClassA();
            a.Display1();
            Console.ReadKey();
        }
    }

执行结果如下：

ClassA Display1

ClassB Display2

那么可否通过基类调用其子类的函数呢？

/// <summary>
   /// ClassB: acting as base class
   /// </summary>
   class ClassB
    {
        public int x = 100;
        public void Display1()
        {
            Console.WriteLine("ClassB Display1");
        }
    }

    /// <summary>
    /// ClassA: acting as derived class
    /// </summary>
    class ClassA : ClassB
    {
        public void Display2()
        {
            Console.WriteLine("ClassA Display2");
        }
    }

    /// <summary>
    /// Program: used to execute the method.
    /// Contains Main method.
    /// </summary>
    class Program
    {
        static void Main(string[] args)
        {
            ClassB b = new ClassB();
            b.Display2();
            Console.ReadKey();
        }
    }

运行报错：

Error: ‘InheritanceAndPolymorphism.ClassB‘ does not contain a definition for ‘Display2‘ and no extension method ‘Display2‘ accepting a first argument of type ‘InheritanceAndPolymorphism.ClassB‘ could be found

原因是继承无法实现逆向调用，既基类无法调用子类。

除了构造函数和析构函数，子类继承了其基类的一些(包括private的成员变量和成员函数，只是无法访问)。

在C#中，一个类默认继承的是object类型，object是C#所有引用类型的基类；同时，继承具有传递性，如ClassC继承自ClassB，ClassB继承自ClassA，则ClassC可完全复用ClassA的数据和函数---ClassC继承了ClassA。

C#中所有的类型都可被继承吗？

public class ClassW : System.ValueType
   {
   }

   public class ClassX : System.Enum
   {
   }

   public class ClassY : System.Delegate
   {
   }

   public class ClassZ : System.Array
   {
   }

执行结果：

‘InheritanceAndPolymorphism.ClassW‘ cannot derive from special class ‘System.ValueType‘

‘InheritanceAndPolymorphism.ClassX‘ cannot derive from special class ‘System.Enum‘

‘InheritanceAndPolymorphism.ClassY‘ cannot derive from special class ‘System.Delegate‘

‘InheritanceAndPolymorphism.ClassZ‘ cannot derive from special class ‘System.Array‘

运行的结果让人抓狂

在C#中，自定义类无法继承自C#内置的一些类，如System.ValueType, System.Enum, System.Delegate, System.Array, etc。

下面这个例子我们再看看C++中的多类继承是否可在C#中实现：

 public class ClassW
 {
 }

 public class ClassX
 {
 }

 public class ClassY : ClassW, ClassX
 {
 }

执行结果：

Compile time Error: Class ‘InheritanceAndPolymorphism.ClassY‘ cannot have multiple base classes: ‘InheritanceAndPolymorphism.ClassW‘ and ‘ClassX‘.

执行结论是：C#仅支持单类继承，不支持C++的这种星型继承关系。 要使用星型继承关系，请用接口实现。

那么可否实现循环依赖继承呢？

public class ClassW: ClassY
    {
    }

    public class ClassX: ClassW
    {
    }

    public class ClassY :  ClassX
    {
    }

代码逻辑很简单，ClassW继承自ClassY，ClassX继承自ClassW, ClassY继承自ClassX。

但是编译后报错了：

Error: Circular base class dependency involving ‘InheritanceAndPolymorphism.ClassX‘ and ‘InheritanceAndPolymorphism.ClassW‘.

我们得出一个结论，C#中不许环形依赖继承。

实例对象的是否可赋值

ClassB:
public class ClassB
    {
        public int b = 100;
    }

ClassA:

    public class ClassA
    {
        public int a = 100;
    }

Program.cs 代码如下

public class Program
    {
        private static void Main(string[] args)
        {
            ClassB classB = new ClassB();
            ClassA classA = new ClassA();
            classA = classB;
            classB = classA;
        }
    }

我们尝试判断ClassA、ClassB的对象是否可赋值。

编译的结果是：报错了

Cannot implicitly convert type ‘InheritanceAndPolymorphism.ClassB‘ to ‘InheritanceAndPolymorphism.ClassA‘ Cannot implicitly convert type ‘InheritanceAndPolymorphism.ClassA‘ to ‘InheritanceAndPolymorphism.ClassB‘

尽管ClassA和ClassB里面的数据成员变量a数据一致，都为100，但是这里用等号比较的是类型--引用地址，故无法进行赋值。

我们再来试试继承关系的：

public class ClassB
    {
        public int b = 100;
    }

    public class ClassA:ClassB
    {
        public int a = 100;
    }

    /// <summary>
    /// Program: used to execute the method.
    /// Contains Main method.
    /// </summary>
    public class Program
    {
        private static void Main(string[] args)
        {
            ClassB classB = new ClassB();
            ClassA classA = new ClassA();
            classA = classB;
            classB = classA;
        }
    }

ClassA继承自ClassB，我们希望可以直接赋值其实例对象。

运行结果如下：

Error: Cannot implicitly convert type ‘InheritanceAndPolymorphism.ClassB‘ to ‘InheritanceAndPolymorphism.ClassA‘.

运行结论：C#中子类对象可直接赋值给基类对象，基类对象需要往下强转。代码修改如下：

public class ClassB
    {
        public int b = 100;
    }

    public class ClassA:ClassB
    {
        public int a = 100;
    }

    /// <summary>
    /// Program: used to execute the method.
    /// Contains Main method.
    /// </summary>
    public class Program
    {
        private static void Main(string[] args)
        {
            ClassB classB = new ClassB();
            ClassA classA = new ClassA();
            classB=classA;
            classA = (ClassA)classB;
        }
    }

这样编译就通过了。

如果ClassA不继承自ClassB，则这种强转在C#中是会报错的：

Cannot convert type ‘InheritanceAndPolymorphism.ClassA‘ to ‘InheritanceAndPolymorphism.ClassB‘

Cannot convert type ‘InheritanceAndPolymorphism.ClassB‘ to ‘InheritanceAndPolymorphism.ClassA‘

本节结论

  • 无法阻止子类覆盖基类同签名方法
  • 继承关系是子类的同签名方法先查找，再查找其基类的
  • base关键字被C#用于在子类中调用基类函数、变量
  • 继承关系不可逆转
  • 除了构造函数、析构函数，子类继承了基类的一些
  • 自定义类默认继承自Object类型，但是C#的这些类型不能被继承：System.ValueType, System.Enum, System.Delegate, System.Array, etc.
  • C#不支持从多类继承
  • C#不支持循环继承
  • 子类对象可直接赋值给基类，反之需要强转

译文地址：http://www.cnblogs.com/powertoolsteam/p/Diving-in-OOP-Polymorphism-and-Inheritance-Part.html

原文地址：Diving in OOP (Day 2): Polymorphism and Inheritance (Inheritance)

时间： 2025-01-16 03:41:25

深入理解OOP(二):多态和继承(继承)的相关文章

【转】java提高篇(二)-----理解java的三大特性之继承

[转]java提高篇(二)-----理解java的三大特性之继承 原文地址:http://www.cnblogs.com/chenssy/p/3354884.html 在<Think in java>中有这样一句话:复用代码是Java众多引人注目的功能之一.但要想成为极具革命性的语言,仅仅能够复制代码并对加以改变是不够的,它还必须能够做更多的事情.在这句话中最引人注目的是"复用代码",尽可能的复用代码使我们程序员一直在追求的,现在我来介绍一种复用代码的方式,也是java三大

（1） 深入理解Java面向对象三大特性 封装 继承 多态

转眼已经工作快6年了,最开始做了2年J2EE:然后整了2年的数据仓库,主要是Cognos的报表开发:现在从事4G LTE核心网的开发,用的语言任然是Java,但写代码的机会不多,基本都是看代码找BUG,偶尔做点new feature也是在比较成熟的框架上复制.粘贴.修改,大部分时间还是在理解业务,钱多.事少.离家近,当时来这家公司图的是后面2点,2年过去了,英文水平有所提升,对敏捷开放也有一定的了解,但技术方面明显退步了或者说没有进步吧,本来以前也不怎么好,因为工作上用不到,自己也没怎么学习,所

js oop中的三种继承方法

JS OOP 中的三种继承方法: 很多读者关于js opp的继承比较模糊,本文总结了oop中的三种继承方法,以助于读者进行区分. <继承使用一个子类继承另一个父类,子类可以自动拥有父类的属性和方法.(继承的两方,发生在两个类之间)> 一.通过object实现继承 1:定义父类 function Parent(){} 2:定义子类 funtion Son(){} 3:通过原型给Object对象添加一个扩展方法. Object.prototype.customExtend = function(p

十二周（摩托车继承自行车和机动车）

/* *copyright(c) 2015,烟台大学计算机学院 *All rights reserved. *文件名称:十二周(摩托车继承自行车和机动车) *作者:王忠 *完成日期:2015.5.27 *版本号:v1.0 * *问题描述: *输入描述: *程序输出: #include <iostream> #include<conio.h> #include <windows.h> using namespace std; enum vehicleStaus {rest

c/c++ 继承与多态 容器与继承3

c/c++ 继承与多态 容器与继承2 巩固了容器里放智能指针的用法,但是有个问题,对于使用Basket类的用户来说,必须添加的是智能指针,如果能直接添加一个普通的类的对象的话,用起来就方便的多了,所以改进一下Basket类的add_item接口. 新的接口:一个是拷贝给定的对象,另一个是移动对象. void add_item(const Quote& sale);//左值拷贝 void add_item(Quote&& sale);//右值移动 关键点: 1,由于类Quote没有自

12：面向对象三大特性（封装、继承、多态）之继承

本小节知识点: 继承基本概念 OC中的继承关系 OC中如何实现继承 1.继承基本概念 现实生活中的继承 交通工具类是一个基类(也称做父类),通常情况下所有交通工具所共同具备的特性,如速度与额定 载人的数量 按照生活常规,我们来继续给交通工具来细分类的时候,我们会分别想到有汽车类和飞机类等 等,汽车类和飞机类同样具备速度和额定载人数量这样的特性,而这些特性是所有交通工具所共有的,那么就可以让汽车或飞机类继承交通工具类,这样当建立汽车类和飞机类的时候我们无需再定义交通工具类(基类)中已经有的成员和方

简单理解OOP——面向对象编程

OOP:面向对象编程 一. 什么是OOP 面向对象编程:Object-oriented Programming,OOP,面向对象程序设计. 面向对象编程是一种计算机编程架构,他的一条基本原则是计算机程序是由单个能够起到子程序作用的单元或对象组合而成. OOP使得程序更有重用性.灵活性和扩展性.OOP的核心思想是:封装.继承.多态(重点是类和对象). 不同于POP(面向过程编程)的以过程为中心的编程思想,面向对象编程的中心思想是通过调用对象来实现想要实现的目的. 面向对象的思想: 是一种更符合我们

Java基础十二--多态是成员的特点

Java基础十二--多态是成员的特点 一.特点 1,成员变量. 编译和运行都参考等号的左边. 覆盖只发生在函数上,和变量没关系. Fu f = new Zi();System.out.println(f.num);//是父类,答案是3 2,成员函数(非静态). 编译看左边,运行看右边. 因为成员函数存在覆盖特性. Fu f = new Zi();//f.show();输出的是子类里面的show方法 3,静态函数. 编译和运行都看左边. 静态函数不具备多态性,多态性是对象的多态性,然后静态函数不涉

OC学习笔记十二 多态

一.多态概念 多态的前提,必须存在继承关系,在代码中的表现形式就是父类类型保存子类类型,即父类的指针指向子类对象. 二.多态特性 在OC中,调用方法是,会检测对象的真实类型,称为动态绑定. 父类保存子类指针,在调用方法时,有以下步骤: 1).在编译的时候,会检查 父类指向子类的指针 调用的方法,在父类中是否存在,如果有,编译通过 2).在运行时,会动态检测 初始对象 的真实类型 三.多态用途 提供动态绑定特性,减少不必要的程序冗余.在方法中,把父类当成参数,使该方法具备调用所有子类同样方法的能力