面向对象三大特性之继承

什么是继承?

继承是将两个类中相同的属性及方法抽取出来,放到一个新的类中(父类),而这两个子类依然拥有这些属性和方法。抽象点的
说,每辆车子都能跑(拥有跑的方法),都有轮胎(有轮胎这个属性)。

使用继承编程的好处?

使用继承编程可以大大的减少代码冗余,增加代码复用。

如何使用继承?

以第一问为例做延伸:假若我们现在需要两个类,一个货车类,一个轿车类。代码如下
  1. /// <summary>
  2.     /// 货车类
  3.     /// </summary>
  4.     class Truck
  5.     {
  6.         //时速
  7.         public int Speed { get; set; }
  8.         //颜色
  9.         public string Colour { get; set; }
  10.         //购买价格
  11.         public double Price { get; set; }
  12.         
  13.         /// <summary>
  14.         /// 货运方法
  15.         /// </summary>
  16.         public void Cargo()
  17.         {
  18.             Console.WriteLine("运输货物");
  19.         }
  20.     }

  21.     /// <summary>
  22.     /// 轿车类
  23.     /// </summary>
  24.     class Sedan
  25.     {
  26.         //时速
  27.         public int Speed { get; set; }
  28.         //颜色
  29.         public string Colour { get; set; }
  30.         //购买价格
  31.         public double Price { get; set; }
  32.         
  33.         /// <summary>
  34.         /// 载客方法
  35.         /// </summary>
  36.         public void CarryPassengers()
  37.         {
  38.             Console.WriteLine("载客");
  39.         }
  40.     }

  41. 示例 : 未使用继承
复制代码
通过这段代码不难发现,货车类和轿车类拥有三个相同的属性,一个不同的方法。根据继承的特性,需要把相同的属性或方法抽
取出来。代码如下
  1. /// <summary>
  2.     /// 车辆类 父类
  3.     /// </summary>
  4.     class Vehicle
  5.     {
  6.         //时速
  7.         public int Speed { get; set; }
  8.         //颜色
  9.         public string Colour { get; set; }
  10.         //购买价格
  11.         public double Price { get; set; }
  12.     }

  13.     /// <summary>
  14.     /// 货车类 继承车辆类
  15.     /// </summary>
  16.     class Truck : Vehicle
  17.     {
  18.         /// <summary>
  19.         /// 货运方法
  20.         /// </summary>
  21.         public void Cargo()
  22.         {
  23.             Console.WriteLine("运输货物");
  24.         }
  25.     }

  26.     /// <summary>
  27.     /// 轿车类 继承车辆类
  28.     /// </summary>
  29.     class Sedan : Vehicle
  30.     {
  31.         /// <summary>
  32.         /// 载客方法
  33.         /// </summary>
  34.         public void CarryPassengers()
  35.         {
  36.             Console.WriteLine("载客");
  37.         }
  38.     }

  39. 示例 : 使用继承
复制代码
那么问题又来了,继承的特性-代码复用体现在哪里呢?下面我们简单地了解一下。
在第一段代码中,有两个类,如果我们想在创建对象时使用带参构造函数来初始化属性的话,要在两个类中都写上相同的一段代
码。(构造函数详解)
  1. /// <summary>
  2.     /// 货车类
  3.     /// </summary>
  4.     class Truck
  5.     {
  6.         //时速
  7.         public int Speed { get; set; }
  8.         //颜色
  9.         public string Colour { get; set; }
  10.         //购买价格
  11.         public double Price { get; set; }
  12.         public Truck(int speed, string colour, double price)
  13.         {
  14.             this.Speed = speed;
  15.             this.Colour = colour;
  16.             this.Price = price;
  17.         }
  18.         ...
  19.     }

  20.     /// <summary>
  21.     /// 轿车类
  22.     /// </summary>
  23.     class Sedan
  24.     {
  25.         //时速
  26.         public int Speed { get; set; }
  27.         //颜色
  28.         public string Colour { get; set; }
  29.         //购买价格
  30.         public double Price { get; set; }
  31.         public Truck(int speed, string colour, double price)
  32.         {
  33.             ...
  34.         }
  35.         ...
  36.     }

  37. 示例 : 冗余的代码
复制代码
显而易见,上面的重复代码很多。下面我们使用继承来简化一下上面的代码。
  1. /// <summary>
  2.     /// 车辆类 父类
  3.     /// </summary>
  4.     class Vehicle
  5.     {
  6.         //时速
  7.         public int Speed { get; set; }
  8.         //颜色
  9.         public string Colour { get; set; }
  10.         //购买价格
  11.         public double Price { get; set; }

  12.         /// <summary>
  13.         /// 带参构造函数
  14.         /// </summary>
  15.         /// <param name="speed"></param>
  16.         /// <param name="colour"></param>
  17.         /// <param name="price"></param>
  18.         public Vehicle(int speed, string colour, double price)
  19.         {
  20.             this.Speed = speed;
  21.             this.Colour = colour;
  22.             this.Price = price;
  23.         }
  24.     }

  25.     /// <summary>
  26.     /// 货车类 继承车辆类
  27.     /// </summary>
  28.     class Truck : Vehicle
  29.     {
  30.         /// <summary>
  31.         /// 子类使用父类构造函数
  32.         /// </summary>
  33.         public Truck(int speed, string colour, double price) :
  34.             base (speed,colour,price)
  35.         {

  36.         }
  37.         ...
  38.     }

  39.     /// <summary>
  40.     /// 轿车类 继承车辆类
  41.     /// </summary>
  42.     class Sedan : Vehicle
  43.     {
  44.         /// <summary>
  45.         /// 子类使用父类构造函数
  46.         /// </summary>
  47.         public Sedan(int speed, string colour, double price) :
  48.             base (speed,colour,price)
  49.         {

  50.         }
  51.         ...
  52.     }

  53. 示例 : 简化的代码
复制代码
用了继承之后,即使再多的派生类需要带参构造函数,也不怕了,只要一行代码即可完成。
Base关键字:
base关键字表示父类,可以用于访问父类的成员。例:base.父类成员。
除了上面通过base显示的调用父类带参构造函数外,创建子类对象时还会隐式的调用父类的无参构造函数。(创建子类对象时会先调用父类的无参构造函数。)

进一步了解和使用继承
继承的特性:

1.传递性:继承可以无限的向下派生,但是需要符合一个条件:子类可以出现在父类出现的地方并替换父类,即子类 拥有父类的全部特征和能够实现父类的全部方法。

2.单根性:一个子类只能继承自一个父类。不存在一个子类同时继承自两个或多个父类的情况。
is a关键字:
这个关键字用来判断对象是否属于给定的类型。返回值为bool类型。
例:
if (Vehicle is Truck)

{
                ...
            }

    sealed关键字:

用这个关键字修饰的类是不能被继承的,即密封类。常用的string类就是密封类。本文只做了解,后更示例。
至此,关于继承已经讲得差不多了,下面是本文用到的所有代码,希望可以帮到看到此处的你。
  1. class Program
  2.     {
  3.         static void Main(string[] args)
  4.         {
  5.             Demo demo = new Demo();
  6.             demo.Test();

  7.             Console.Read();
  8.         }
  9.     }

  10.     class Demo
  11.     {
  12.         List<Vehicle> vehicles = new List<Vehicle>();
  13.         
  14.         public void Test()
  15.         {
  16.             vehicles.Add(new Truck(50, "蓝色", 150000));
  17.             vehicles.Add(new Sedan(80, "黑色", 210000));
  18.             foreach (Vehicle item in vehicles)
  19.             {
  20.                 if (item is Truck)
  21.                 {
  22.                     Console.WriteLine("我是货车,时速{0},我是{1}的,价格{2}元。", item.Speed, item.Colour, item.Price);
  23.                     ((Truck)item).Cargo();
  24.                 }
  25.                 if (item is Sedan)
  26.                 {
  27.                     Console.WriteLine("我是轿车,时速{0},我是{1}的,价格{2}元。",item.Speed,item.Colour,item.Price);
  28.                     ((Sedan)item).CarryPassengers();
  29.                 }
  30.             }
  31.         }
  32.     }

  33.     /// <summary>
  34.     /// 车辆类 父类
  35.     /// </summary>
  36.     class Vehicle
  37.     {
  38.         //时速
  39.         public int Speed { get; set; }
  40.         //颜色
  41.         public string Colour { get; set; }
  42.         //购买价格
  43.         public double Price { get; set; }

  44.         /// <summary>
  45.         /// 带参构造函数
  46.         /// </summary>
  47.         /// <param name="speed"></param>
  48.         /// <param name="colour"></param>
  49.         /// <param name="price"></param>
  50.         public Vehicle(int speed, string colour, double price)
  51.         {
  52.             this.Speed = speed;
  53.             this.Colour = colour;
  54.             this.Price = price;
  55.         }
  56.     }

  57.     /// <summary>
  58.     /// 货车类 继承车辆类
  59.     /// </summary>
  60.     class Truck : Vehicle
  61.     {
  62.         /// <summary>
  63.         /// 子类使用父类构造函数
  64.         /// </summary>
  65.         public Truck(int speed, string colour, double price) :
  66.             base (speed,colour,price)
  67.         {

  68.         }

  69.         /// <summary>
  70.         /// 货运方法
  71.         /// </summary>
  72.         public void Cargo()
  73.         {
  74.             Console.WriteLine("我能运输货物");
  75.         }
  76.     }

  77.     /// <summary>
  78.     /// 轿车类 继承车辆类
  79.     /// </summary>
  80.     class Sedan : Vehicle
  81.     {
  82.         /// <summary>
  83.         /// 子类使用父类构造函数
  84.         /// </summary>
  85.         public Sedan(int speed, string colour, double price) :
  86.             base (speed,colour,price)
  87.         {

  88.         }
  89.         /// <summary>
  90.         /// 载客方法
  91.         /// </summary>
  92.         public void CarryPassengers()
  93.         {
  94.             Console.WriteLine("我可以载客");
  95.         }
  96.     }

  97. 完整代码
复制代码

结尾语:学到知识不与人分享,犹如衣锦夜行,毫无意义。


转自解放号社区:http://bbs.jointforce.com/topic/25682

发布了0 篇原创文章 · 获赞 14 · 访问量 18万+
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 编程工作室 设计师: CSDN官方博客

分享到微信朋友圈

×

扫一扫,手机浏览