.Net之继承

　　继承是OOP的一个方面，好处在于促进代码重用。代码重用分为两类：经典继承--“is-a”以及包含/委托模型--“has-a”。

　　首先“is-a”，在两个或两个以上的类类型之间构造依赖关系，新的类可以利用既有类的功能。

　　以下是一个“is-a”的例子：

　　 

 1         class Car
 2         {
 3             protected readonly int maxSpeed;
 4             private int currSpeed;
 5             private int cost;
 6             private DateTime dateInProduced;
 7             private string model;
 8 
 9             protected Car(int max, int cos, DateTime date, string mod)
10             {
11                 currSpeed = max;
12                 cost = cos;
13                 dateInProduced = date;
14                 model = mod;
15             }
16 
17             protected Car()
18             {
19                 currSpeed = 55;
20             }
21 
22 
23 
24             public DateTime Date
25             {
26                 get { return dateInProduced; }
27                 set { dateInProduced = value; }
28             }
29 
30             public int Speed
31             {
32                 get { return currSpeed; }
33                 set
34                 {
35                     currSpeed = value;
36                     if (currSpeed > maxSpeed)
37                     {
38                         currSpeed = maxSpeed;
39                     }
40                 }
41             }
42 
43             public int Cost
44             {
45                 get { return cost; }
46                 set { cost = value; }
47             }
48             private int price;
49 
50             public int Price
51             {
52                 get { return price; }
53                 set { price = value; }
54             }
55 
56             public string Model
57             {
58                 get { return model; }
59                 set { model = value; }
60             }
61         }
62 
63         class MiniVan : Car
64         {
65             public MiniVan(int speed, int cost, DateTime date, string mod,int sale)
66                 : base(speed, cost, date, mod)
67             {
68                 SaleNumber = sale;
69             }
70 
71 
72             public int SaleNumber
73             {
74                 get;
75                 set;
76             }
77         }
78 
79         static void Main(string[] args)
80         {
81             MiniVan myVan = new MiniVan(10,100,DateTime.Now,"Mini",10000);
82             myVan.Speed = 10;
83             Console.WriteLine("My van is {0}|{1}|{2}|{3}|{4}", myVan.Speed, myVan.Cost, myVan.Date, myVan.Model, myVan.SaleNumber);
84             Console.ReadLine();
85         }

 

 

 　　注意几个问题， 第一：父类中的私有成员，派生类是绝不能访问；

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

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

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

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

　　针对上一段中第四点要补充一下，可以把一个类里面的属性理解为套在数据或成员外面的一层壳，也就是说凡是属性，它必然就是“public”。父类中的属性如果是“protected”，那么其派生类依然不能访问这个属性。如以下代码：

        class Car
        {
            protected readonly int maxSpeed;
            private int currSpeed;

            protected Car(int max)
            {
                currSpeed = max;
            }

            protected Car()
            {
                currSpeed = 55;
            }

            /// <summary>
            /// 此时会编译错误！！！！！
          　　/// </summary>
            protected int Speed
            {
                get { return currSpeed; }
                set 
                { 
                    currSpeed = value;
                    if (currSpeed > maxSpeed)
                    {
                        currSpeed = maxSpeed;
                    }
                }
            }

 　　针对上一段中第五点要说明一下，在C#下，一般基类的默认构造函数会在派生类构造函数执行之前被自动调用，所以用“base”关键字可以显示调用基类特定构造函数而不是默认构造函数，这样可以减少对基类的访问。

　　

 　　下面是一个“has-a”的例子：

　　

 1        class Car
 2         {
 3             private int currSpeed;
 4             private int cost;
 5             private DateTime dateInProduced;
 6             private string model;
 7 
 8             public Car(int max, int cos, DateTime date, string mod)
 9             {
10                 currSpeed = max;
11                 cost = cos;
12                 dateInProduced = date;
13                 model = mod;
14             }
15 
16             public Car()
17             {
18                 currSpeed = 55;
19             }
20 
21             /// <summary>
22 　　　　　　　/// 每辆车子都会有保险
23 　　　　　　　/// </summary>
24             public class BenefitPackage
25             {
26                 /// <summary>
27 　　　　　　　　　 /// 保险会有不同的档次，这里用一个枚举类
28 　　　　　　　　   /// </summary>
29                 public enum BenefitPackageLevel
30                 {
31                     Standard,Gold,Platinum
32                 }
33 
34                 /// <summary>
35 　　　　　　　　　 /// 根据不同档次获取保险费
36 　　　　　　　　　 /// </summary>
37 　　　　　　　　　 /// <param name="Level"></param>
38 　　　　　　　　　 /// <returns></returns>
39                 public double ComputePayDeduction(BenefitPackageLevel Level)
40                 {
41                     switch (Level)
42                     {
43                         case BenefitPackageLevel.Standard:
44                             return 100.00;
45                         case BenefitPackageLevel.Gold:
46                             return 150.00;
47                         case BenefitPackageLevel.Platinum:
48                             return 200.00; 
49                         default :
50                             return 0;
51                     }
52                 }
53             }
54 
55 
56             public DateTime Date
57             {
58                 get { return dateInProduced; }
59                 set { dateInProduced = value; }
60             }
61 
62             public int Cost
63             {
64                 get { return cost; }
65                 set { cost = value; }
66             }
67             private int price;
68 
69             public int Price
70             {
71                 get { return price; }
72                 set { price = value; }
73             }
74 
75             public string Model
76             {
77                 get { return model; }
78                 set { model = value; }
79             }
80         }
81 
82         static void Main(string[] args)
83         {
84             Car.BenefitPackage.BenefitPackageLevel BenefitLevel = Car.BenefitPackage.BenefitPackageLevel.Platinum;
85             Car.BenefitPackage myBenefit=new Car.BenefitPackage();
86             double money=myBenefit.ComputePayDeduction(BenefitLevel);
87             Console.WriteLine(money.ToString());
88             Console.ReadLine();
89         }

　　所谓“has-a”其实就是类与类之间产生嵌套关系，每个车子都会有它自己的保险类型和保险金数额，但BenefitPackage与Car肯定不可能是“is-a”的关系，这是“has-a”就显得非常合适了。

　　尽管语法很简洁，例子也很简单，但嵌套类这项技术是很有思考余地的：

1）通过嵌套类可以完全控制内部类型的访问级别，也就是可以声明为私有（非嵌套类不能私有）。

2）由于嵌套类是包含类的成员，所以它可以访问包含类的私有成员。

3）嵌套类型只是用于包含类的辅助方法，不是为外部世界所准备的。

　　用两个简单的例子把自己理解的继承说明一下，.Net很多技术都是完全基于面向对象思想产生的，理解这些技术要用面向对象的思想，也通过理解这些技术更好的领悟面向对象的思想，总之将面向对象进行到底。

　　本人也不是大牛，只是本着加深印象和交流为目的写博客。欢迎高手、大牛多多指正，本人不胜感激。

　　感恩ing，谦卑ing。