码迷,mamicode.com
首页 > Windows程序 > 详细

C#面向对象核心之二:继承

时间:2015-07-29 11:43:29      阅读:205      评论:0      收藏:0      [点我收藏+]

标签:

面向对象的三大特性之一的封装,解决了将对同一对象所能操作的所有信息放在一起,实现统一对外调用,实现了同一对象的复用,降低了耦合。

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

     有另一个对象苹果树(AppleTree)它也是果树,具有果树所有特性,那么我们在编程的时候,定义了一个苹果树对象,假如再有一个桔子树(OrangeTree)、桃树(PeachTree)呢,我们不能一直复制这个对象改名字实现吧?这里就要用到面向对象的第二个特性:继承。

1.什么是继承

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

继承相关的概念:

(1) 当一个类A能够获取另一个类B中所有非私有的数据和操作的定义作为自己的部分或全部成分时,就称这两个类之间具有继承关系。

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

2.继承的特点

上面的例子,假如苹果树继承自果树,那么苹果树除了具有果树所有的属性(叶子,根、花)和方法(生长)之外,苹果树还有自己特有的一些属性,比如有自己的果实苹果(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.当两个对象是“has a”关系时,不宜使用继承(比如手是人的一部分,不能让手继承人);

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

     作为面向对象的三大特性之一:继承,可以说是学好面向对象编程的重中之重。

要点:

1:父类中的私有成员,派生类是绝不能访问;

2:C#要求一个类只能有一个直接基类;

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

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

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

6:继承需要合理使用才能发挥最佳效果,一般情况下适用于“is a”关系,不适用“has a”关系。

 

C#面向对象核心之二:继承

标签:

原文地址:http://www.cnblogs.com/qinyi173/p/4685425.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!