[.net 面向对象编程基础] (12) 面向对象三大特性——继承

时间 2019-11-17

原文原文链接

[.net 面向对象编程基础] (12) 面向对象三大特性——继承html

上节咱们说了面向对象的三大特性之一的封装，解决了将对同一对象所能操做的全部信息放在一块儿，实现统一对外调用，实现了同一对象的复用，下降了耦合。编程

但在实际应用中，有好多对象具备相同或者类似的属性，好比有一个对象果树（FruitTree）,它有成员属性叶子（Leaf），会开花(Flower)，有树干(Stem)，有树根(Root),它还会生长(Growth方法)。app

有另外一个对象苹果树(AppleTree)它也是果树，具备果树全部特性，那么咱们在编程的时候，定义了一个苹果树对象，假如再有一个桔子树(OrangeTree)、桃树（PeachTree）呢，咱们不能一直复制这个对象更名字实现吧？这里就要用到面向对象的第二个特性：继承。

函数

1.什么是继承ui

上面的果树(FruitTree) 和桔树(OrangeTree)之间是一个“ is-a ”的关系，即咱们能够说 “桔树是果树”。在面向对象编程中，咱们把这种关系称为 “继承”，即桔树继承自果树。或者说，桔树类是果树类的派生类；也能够说果树是父类，桔树是子类。一样的苹果树也能够继承果树，那么苹果树也能够说是果树的子类。在这里咱们发现一个类能够有多个派生类，也就是一个类能够被多个类继承.this

经过上面的实例，咱们总结一下继承相关的概念：spa

(1) 当一个类A可以获取另外一个类B中全部非私有的数据和操做的定义做为本身的部分或所有成分时，就称这两个类之间具备继承关系。.net

(2) 被继承的类B称为父类或基类，继承了父类的类A称为子类或派生类.

code

2.继承的特色htm

上面的例子，假如苹果树继承自果树，那么苹果树除了具备果树全部的属性(叶子，根、花)和方法（生长）以外，苹果树还有本身特有的一些属性，好比有本身的果实苹果（Apple）; 一样桃树有本身的果实桃子(Peach),所以继承的子类能够有本身独有的成员（属性或方法等）。

特色一：派生类除了继承父类的特性外，还能够有本身独有特性

上面说到的父类果树(FruitTree)除了有叶子、根、花这些公有的成员以外，也能够有本身的私有成员，好比种类（落叶果树、常绿果树），而“种类”这个成员，并非它的子类苹果树（AppleTree）和桔树(OrangeTree)所具备的,所以是私有成员，子类继承父类后，并不能拥有父类的私有成员。

特色二：子类不能拥有父类的私有成员

仍是上面的例子，假若是树有一个公有方法生长（Growth），它有两个子类桃树和苹果树，那么子类也同时拥有生长这个方法，可是桃树和苹果树的生长过程是不一样的，咱们能够修改这个方法以适应不一样种类果树的生长。

特色三：子类能够以本身的方式实现父类的功能（即方法重写,这个在后面专门介绍）

3．继承的实现

经过上面的例子，咱们已经对继承很熟悉了，抛开概念。简单的说，继承一词本就来源于生活，有财产继承，精神继承。面向对象编程只不过就是把这些概念抽象化而已，通俗来讲就是“苹果树是一颗果树”

代码实现上面的例子

  1     /// <summary>
  2     /// 果树类
  3     /// </summary>
  4     class FruitTree
  5     {
  6         /// <summary>
  7         /// 名称
  8         /// 说明：修饰符 protected 保护访问。只限于本类和子类访问，实例不能访问。
  9         /// </summary>
 10         protected string name;
 11         /// <summary>
 12         /// 构造函数
 13         /// </summary>
 14         public FruitTree()
 15         {
 16             this.name = "无名";
 17         }
 18         /// <summary>
 19         /// 构造函数二
 20         /// </summary>
 21         /// <param name="name"></param>
 22         public FruitTree(string name)
 23         {
 24             this.name = name;
 25         }
 26         object _leaf;
 27         object _root;
 28         object _flower;
 29         string _type;
 30         /// <summary>
 31         /// 叶子（公有属性）
 32         /// </summary>
 33         public object leaf
 34         {
 35             get { return _leaf; }
 36             set { _leaf = value; }
 37         }
 38         /// <summary>
 39         /// 根（公有属性）
 40         /// </summary>
 41         public object root
 42         {
 43             get { return _root; }
 44             set { _root = value; }
 45         }
 46         /// <summary>
 47         /// 花（公有属性）
 48         /// </summary>
 49         public object flower
 50         {
 51             get { return _flower; }
 52             set { _flower = value; }
 53         }
 54         /// <summary>
 55         /// 类别（不定义修饰符，默认为私有）
 56         /// </summary>
 57         string type
 58         {
 59             get { return _type; }
 60             set { _type = value; }
 61         }
 62   
 63     }
 64 
 65     /// <summary>
 66     /// 苹果树类
 67     /// 继承自：果树类
 68     /// </summary>
 69     class AppleTree:FruitTree
 70     {
 71         string _myName;
 72         /// <summary>
 73         /// 构造函数
 74         /// 说明：子类调用父类一样的构造函数，须要使用 :base()
 75         /// </summary>
 76         public AppleTree():base()
 77         {          
 78         }
 79         /// <summary>
 80         /// 构造函数二
 81         /// 说明：子类调用父类一样的构造函数，须要使用 :base(name)
 82         /// </summary>
 83         /// <param name="name"></param>
 84         public AppleTree(string name):base(name)
 85         {
 86             _myName = name;
 87         }             
 88 
 89         /// <summary>
 90         /// 返回果实的名字
 91         /// </summary>
 92         /// <returns></returns>
 93         public string MyFruitName()
 94         {
 95             return "我是：" + _myName + "；个人果实叫：苹果";
 96         }
 97     }
 98     /// <summary>
 99     /// 桔树类
100     /// 继承自：果树类
101     /// </summary>
102     class OrangeTree : FruitTree
103     {
104         string _myName;
105         /// <summary>
106         /// 构造函数
107         /// 说明：子类调用父类一样的构造函数，须要使用 :base()
108         /// </summary>
109         public OrangeTree(): base()
110         {
111         }
112         /// <summary>
113         /// 构造函数二
114         /// 说明：子类调用父类一样的构造函数，须要使用 :base(name)
115         /// </summary>
116         /// <param name="name"></param>
117         public OrangeTree(string name): base(name)
118         {
119             _myName = name;
120         }
121 
122         /// <summary>
123         /// 返回果实的名字
124         /// </summary>
125         /// <returns></returns>
126         public string MyFruitName()
127         {
128             return "我是："+_myName+"；个人果实叫：桔子";
129         }
130     }

调用子类：

//调用子类
AppleTree appleTree = new AppleTree("苹果树");
string myName = appleTree.MyFruitName();
//返回结果为：我是：苹果树；个人果实叫：苹果

//调用子类
OrangeTree orangeTree = new OrangeTree("桔子树"); 
string myName = orangeTree. MyFruitName (); 
//返回结果为：我是：桔子树；个人果实叫：桔子

通这段代码，咱们能够看到有了基类果树，那么咱们再有几百种树，只须要一个继承就能够了，对于子类AppleTree.MyFruitName()返回名字这个方法,在不一样子类中能够特有，就是继承的特色，能够增长特有成员。虽然对于独有特色须要在每一个子类中单独定义，可是共享父类成员已经让咱们省去很多工做量了，最重要的程序的结构更加清晰、易于维护了。

4.继承的缺点

看到这个标题，小伙伴们也许很惊讶，既然说了这么多面向对象继承特性的好处，原来还有缺点。固然，世界上没有完美的东西，继承也是。

缺点一：父类变化，子类不得不变；

缺点二：继承破坏了包装，父类的细节暴露给了子类。

前一节说了封装的独立特性，是减小了耦合性，而继承其为了实现复用却增长了耦合性。

说到这里小伙伴们纠结了，那么到底要不要使用继承，答案是确定的，它的优势和光芒掩盖了缺点，也就是说好处更多一些。这里说明它的缺点，就是提醒咱们在使用过程当中尽可能避免它的缺点所带来的后果。

那么要如何才能很好的使用继承呢？咱们应该注意这么几点:

a.当两个对象间是“is a”关系时，可使用继承（好比苹果树是树）；b.当两个对象是“as a”关系时，不宜使用继承（好比手是人的一部分，不能让手继承人）;

对于继承的优缺点，咱们记住一点：要合理使用继承，才能发挥最佳效果，而不是盲目使用。

做为面向对象的三大特性之一：继承，能够说是学好面向对象编程的重中之重，因些本节能够说是这个系列的重点，没有之一。

小伙伴们，又是凌晨了，明天继续写。最后按惯例写几点使用继承须要注意的地方。

要点：

1：父类中的私有成员，派生类是毫不能访问；

2：C#要求一个类只能有一个直接基类；

3：被“sealed”关键字修饰的类将不能被继承；

4：被“protected”修饰的成员或者数据能够直接被派生类访问，属于“能够在家族里分享的秘密”。

5：善用“base”关键字，显示调用合适的自定义基类构造函数而不是使用默认构造函数。

6：继承须要合理使用才能发挥最佳效果，通常状况下适用于“is a”关系，不适用“has a”关系。

==============================================================================================

返回目录

<若是对你有帮助，记得点一下推荐哦，有不明白的地方或写的不对的地方，请多交流>

==============================================================================================