实现多态的手段

1、虚方法
步骤：将父类的方法标记为虚方法，使用关键字virtual，这个方法可以被子类重新写一遍。（重写）
将子类的方法使用override —-（重写）

  1. using System;
  3. namespace _081_多态之虚方法
  4. {
  5.     class Program
  6.     {
  7.         static void Main(string[] args)
  8.         {
  9.             //概念：让一个对象能够表现出多种的状态（类型）   
  10.             //实现多态的三种方法：1、虚方法  2、抽象类   3、接口
  12.             Chinese cn1 = new Chinese("傻逼");
  13.             Chinese cn2 = new Chinese("笨蛋");
  14.             Japanese j1 = new Japanese("波多野结衣");
  15.             Japanese j2 = new Japanese("冲田杏梨");
  16.             Korea k1 = new Korea("金智秀");
  17.             Korea k2 = new Korea("金秀智");
  18.             American a1 = new American("Saber");
  19.             American a2 = new American("WeXiao");
  20.             //Person[] pers = new Person[8];
  21.             Person[] pers = { cn1, cn2, j1, j2, k1, k2, a1, a2 };
  23.             for (int i = 0; i < pers.Length; i++)
  24.             {
  25.                 //if(pers[i] is Chinese)
  26.                 //{
  27.                 //    ((Chinese)pers[i]).SayHello();
  28.                 //}
  29.                 //else if (pers[i] is Japanese)
  30.                 //{
  31.                 //    ((Japanese)pers[i]).SayHello();
  32.                 //}
  33.                 //else if (pers[i] is Korea)
  34.                 //{
  35.                 //    ((Korea)pers[i]).SayHello();
  36.                 //}
  37.                 //else //if (pers[i] is American)
  38.                 //{
  39.                 //    ((American)pers[i]).SayHello();
  40.                 //}
  42.                 pers[i].SayHello();
  43.             }
  44.             Console.ReadKey();
  45.         }
  46.     }
  47. }
  49. using System;
  50. using System.Collections.Generic;
  51. using System.Text;
  53. namespace _081_多态之虚方法
  54. {
  55.     class Person
  56.     {
  57.         private string _name;
  58.         public string Name
  59.         {
  60.             get { return _name; }
  61.             set { _name = value; }
  62.         }
  63.         public Person(string name)
  64.         {
  65.             this._name = name;
  66.         }
  67.         public virtual void SayHello()
  68.         {
  69.             Console.WriteLine("我是人类,我的名字是{0}", Name);
  70.         }
  71.     }
  72. }
  74. using System;
  75. using System.Collections.Generic;
  76. using System.Text;
  78. namespace _081_多态之虚方法
  79. {
  80.     class Korea:Person
  81.     {
  82.         public Korea(string name) : base(name)
  83.         { }
  84.         public override void SayHello()
  85.         {
  86.             Console.WriteLine("我是韩国还是朝鲜,我的名字是{0}", Name);
  87.         }
  88.     }
  89. }
  91. using System;
  92. using System.Collections.Generic;
  93. using System.Text;
  95. namespace _081_多态之虚方法
  96. {
  97.     class Japanese : Person
  98.     {
  99.         public Japanese(string name) : base(name)
  100.         {
  101.         }
  102.         public override void SayHello()
  103.         {
  104.             Console.WriteLine("我是小日本,我的名字是{0}", Name);
  105.         }
  106.     }
  107. }
  110. using System;
  111. using System.Collections.Generic;
  112. using System.Text;
  114. namespace _081_多态之虚方法
  115. {
  116.     class English:Person
  117.     {
  118.         public English(string name) : base(name)
  119.         { }
  120.         public override void SayHello()
  121.         {
  122.             Console.WriteLine("English");
  123.         }
  124.     }
  125. }
  128. using System;
  129. using System.Collections.Generic;
  130. using System.Text;
  132. namespace _081_多态之虚方法
  133. {
  134.     class Chinese : Person
  135.     {
  136.         public Chinese(string name) : base(name)
  137.         {
  138.         }
  139.         public override void SayHello()
  140.         {
  141.             Console.WriteLine("我是中国人,我的名字是{0}", Name);
  142.         }
  143.     }
  144. }
  147. using System;
  148. using System.Collections.Generic;
  149. using System.Text;
  151. namespace _081_多态之虚方法
  152. {
  153.     class American : Person
  154.     {
  155.         public American(string name) : base(name)
  156.         { }
  157.         public override void SayHello()
  158.         {
  159.             Console.WriteLine("我是米国人,我的名字是{0}", Name);
  160.         }
  161.     }
  162. }

练习：

  1. using System;
  3. namespace _082_虚方法练习
  4. {
  5.     class Program
  6.     {
  7.         static void Main(string[] args)
  8.         {
  9.             Duck duck=new Duck();
  10.             RealDuck realDuck = new RealDuck();
  11.             RubberDuck rubberDuck = new RubberDuck();
  12.             WoodenDuck woodenDuck = new WoodenDuck();
  13.             DeadDuck deadDuck = new DeadDuck();
  14.             Duck[] ducks = { duck, realDuck, rubberDuck, woodenDuck, deadDuck };
  15.             for (int i = 0; i < ducks.Length; i++)
  16.             {
  17.                 ducks[i].Bark();
  18.             }
  20.             Console.ReadKey();
  21.         }
  22.     }
  23. }
  25. using System;
  26. using System.Collections.Generic;
  27. using System.Text;
  29. namespace _082_虚方法练习
  30. {
  31.     class Duck
  32.     {
  33.         public virtual void Bark()
  34.         {
  35.             Console.WriteLine("鸭子叫");
  36.         }
  37.     }
  38. }
  40. using System;
  41. using System.Collections.Generic;
  42. using System.Text;
  44. namespace _082_虚方法练习
  45. {
  46.     class RealDuck : Duck
  47.     {
  48.         public override void Bark()
  49.         {
  50.             Console.WriteLine("真的鸭子嘎嘎叫");
  51.         }
  52.     }
  53. }
  54. using System;
  55. using System.Collections.Generic;
  56. using System.Text;
  58. namespace _082_虚方法练习
  59. {
  60.     class RubberDuck : Duck
  61.     {
  62.         public override void Bark()
  63.         {
  64.             Console.WriteLine("橡胶鸭子唧唧叫");
  65.         }
  66.     }
  67. }
  69. using System;
  70. using System.Collections.Generic;
  71. using System.Text;
  73. namespace _082_虚方法练习
  74. {
  75.     class DeadDuck : Duck
  76.     {
  77.         public override void Bark()
  78.         {
  79.             Console.WriteLine("死的鸭子不会叫");
  80.         }
  81.     }
  82. }
  84. using System;
  85. using System.Collections.Generic;
  86. using System.Text;
  88. namespace _082_虚方法练习
  89. {
  90.     class WoodenDuck : Duck
  91.     {
  92.         public override  void Bark()
  93.         {
  94.             Console.WriteLine("木头鸭子吱吱叫");
  95.         }
  96.     }
  97. }

2、抽象类
当父类中的方法不知道如何去实现时，可以考虑将父类写成抽象类，将方法写成抽象方法。（抽象方法没有方法体）
特点：
1、抽象成员必须标记为abstract，并且不能有任何实现。
2、抽象成员必须在抽象类中。
3、抽象类不能被实例化。
4、子类继承抽象类后，必须把父类中的所有抽象成员都重写。
（除非子类也是一个抽象类，则可以不用重写）
5、抽象成员的访问修饰符不能是private。
6、在抽象类中可以包含实例成员，并且抽象类的实例成员可以不被子类实现。
7、抽象类是有构造函数的，虽然不能被实例化。
image.png

抽象类练习

image.png

  1. using System;
  3. namespace _084_抽象类练习
  4. {
  5.     class Program
  6.     {
  7.         static void Main(string[] args)
  8.         {
  9.             //1|使用多态求矩形和圆的面积和周长
  10.             Console.WriteLine("输入圆的半径：");
  11.             double radius = Convert.ToDouble(Console.ReadLine());
  12.             Shape circle = new Circle(radius);
  13.             double circleArea = circle.Area();
  14.             double circlePerimeter = circle.Perimeter();
  15.             Console.WriteLine("圆的面积为：{0}，圆的周长为：{1}", circleArea, circlePerimeter);
  17.             Console.WriteLine("请输入矩形的长和宽：");
  18.             double length = Convert.ToInt32(Console.ReadLine());
  19.             double width = Convert.ToInt32(Console.ReadLine());
  20.             Shape rectangle = new Rectangle(length, width);
  21.             double rectangleArea = rectangle.Area();
  22.             double rectanglePerimeter = rectangle.Perimeter();
  23.             Console.WriteLine("矩形的面积为：{0}，矩形的周长为：{1}", rectangleArea, rectanglePerimeter);
  25.             //2、模拟移动硬盘、U盘、MP3插到电脑上读写数据
  27.             //通过Computer含参数方法实现
  28.             //1、
  29.             //MobileDisk md = new MobileDisk();
  30.             //UDisk ud = new UDisk();
  31.             MP3 mp3 = new MP3();
  32.             //Computer c = new Computer();
  33.             //c.CpuRead(md);
  34.             //c.CpuWrite(md);
  35.             mp3.PlayMusic();
  37.             //2、
  38.             //MobileStorage ms = new UDisk();
  39.             //Computer cpu = new Computer();
  40.             //cpu.CpuRead(ms);
  41.             //cpu.CpuWrite(ms);
  43.             MobileStorage ms = new UDisk();
  44.             Computer cpu = new Computer();
  45.             cpu.Ms = ms;
  46.             cpu.CpuRead();
  47.             cpu.CpuWrite();
  49.             Console.ReadKey();
  50.         }
  51.     }
  52. }

练习一的类：

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Text;
  5. namespace _084_抽象类练习
  6. {
  7.     abstract  class Shape
  8.     {
  9.         public abstract double Perimeter();
  10.         public abstract double  Area();
  11.     }
  12. }
  14. using System;
  15. using System.Collections.Generic;
  16. using System.Text;
  18. namespace _084_抽象类练习
  19. {
  20.     class Circle : Shape
  21.     {
  22.         private double _radius;
  23.         public double Radius
  24.         {
  25.             get { return _radius; }
  26.             set { _radius = value; }
  27.         }
  28.         public Circle(double r)
  29.         {
  30.             this._radius = r;
  31.         }
  33.         public override double Area()
  34.         {
  35.             return Math.PI * this._radius * this._radius;
  36.         }
  38.         public override double Perimeter()
  39.         {
  40.             return Math.PI * this._radius * 2;
  41.         }
  42.     }
  43. }
  45. using System;
  46. using System.Collections.Generic;
  47. using System.Text;
  49. namespace _084_抽象类练习
  50. {
  51.     class Rectangle : Shape
  52.     {
  53.         private double _length;
  54.         public double Length
  55.         {
  56.             get { return _length; }
  57.             set { _length = value; }
  58.         }
  59.         private double _width;
  60.         public double Width
  61.         {
  62.             get { return _width; }
  63.             set { _width = value; }
  64.         }
  65.         public Rectangle(double l,double w)
  66.         {
  67.             this.Length = l;
  68.             this.Width = w;
  69.         }
  70.         public override double  Area()
  71.         {
  72.             return this.Length * this.Width;
  73.         }
  75.         public override double  Perimeter()
  76.         {
  77.             return (this.Length + this.Width) * 2;
  78.         }
  79.     }
  80. }

练习二的类：

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Text;
  5. namespace _084_抽象类练习
  6. {
  7.     abstract  class MobileStorage
  8.     {
  9.         public abstract void Read();
  10.         public abstract void Write();
  11.     }
  12. }
  14. using System;
  15. using System.Collections.Generic;
  16. using System.Text;
  18. namespace _084_抽象类练习
  19. {
  20.     class MobileDisk : MobileStorage
  21.     {
  22.         public override void Read()
  23.         {
  24.             Console.WriteLine("移动硬盘在读取数据");
  25.         }
  27.         public override void Write()
  28.         {
  29.             Console.WriteLine("移动硬盘在写入数据");
  30.         }
  31.     }
  32. }
  34. using System;
  35. using System.Collections.Generic;
  36. using System.Text;
  38. namespace _084_抽象类练习
  39. {
  40.     class UDisk : MobileStorage
  41.     {
  42.         public override void Read()
  43.         {
  44.             Console.WriteLine("U盘在读取数据");
  45.         }
  47.         public override void Write()
  48.         {
  49.             Console.WriteLine("U盘在写入数据");
  50.         }
  51.     }
  52. }
  54. using System;
  55. using System.Collections.Generic;
  56. using System.Text;
  58. namespace _084_抽象类练习
  59. {
  60.     class MP3 : MobileStorage
  61.     {
  62.         public override void Read()
  63.         {
  64.             Console.WriteLine("MP3在读取数据");
  65.         }
  67.         public override void Write()
  68.         {
  69.             Console.WriteLine("MP3在写入数据");
  70.         }
  71.         public void PlayMusic()
  72.         {
  73.             Console.WriteLine("MP3在放音乐");
  74.         }
  75.     }
  76. }
  78. using System;
  79. using System.Collections.Generic;
  80. using System.Text;
  82. namespace _084_抽象类练习
  83. {
  84.     class Computer
  85.     {
  86.         private MobileStorage _ms;
  87.         public MobileStorage Ms
  88.         {
  89.             get { return _ms; }
  90.             set { _ms = value; }
  91.         }
  93.         public void CpuRead()
  94.         {
  95.             Ms.Read();
  96.         }
  97.         public void CpuWrite()
  98.         {
  99.             Ms.Write();
  100.         }
  103.         //使用方法来实现
  104.         //public void CpuRead(MobileStorage ms)
  105.         //{
  106.         //    ms.Read();
  107.         //}
  108.         //public void CpuWrite(MobileStorage ms)
  109.         //{
  110.         //    ms.Write();
  111.         //}
  112.     }
  113. }