C#教程之抽象类和抽象方法

当前位置:

首页 > Python基础教程 >

C#教程之抽象类和抽象方法

父类与子类相互转换

			
/// <summary>
   /// 动物类(父类)
   /// </summary>
    class Animal
   {
       public string Name { get; set; }//名字
       public string Color { get; set; }//颜色
       public string Kind { get; set; }//种类
       public string Favorite { get; set; }//喜好

       public Animal() { }
       public Animal(string name, string color, string kind)
       {
           this.Name = name; 
           this.Color = color;
           this.Kind = kind;
       }
       //自我介绍
       public void Introduce()
       {
           string info = string.Format("我是漂亮的{0},我的名字叫{1},身穿{2}的衣服,我爱吃{3}!", this.Kind, Name, Color, Favorite);
           Console.WriteLine(info);
       }
   }
			

给Cat和Dog分别添加Have()方法：

			
   /// <summary>
   /// 玩具猫类
   /// </summary>
   class Cat:Animal//继承Animal类
   {
       public Cat() { }//默认调用父类的无参构造函数，若此时父类并没有无参构造函数，则报错
       public Cat(string name, string color, string kind, string favorite) : base(name, color, kind)
       {
           this.Favorite = favorite;
       }
       //跳舞
       public void Dancing()
       {
           base.Introduce();//调用父类的方法
           Console.WriteLine("下面给大家表演，请大家鼓掌!");
       }

       public void Have()
       {
           Console.WriteLine("吃烤鱼!");
       }
			

			
/// <summary>
   /// 玩具狗类
   /// </summary>
   class Dog:Animal//继承Animal类
   {
       public Dog(string name, string color, string kind)
       {
           this.Name = name;//使用this关键字访问父类成员
           this.Color = color;
           this.Kind = kind;
       }

       public Dog() { }//隐式调用:默认调用父类的无参构造函数，若此时父类并没有无参构造函数，则出错。

       public Dog(string name, string color, string kind, string favorite) : base(name, color, kind)
       {//显示调用
           this.Favorite = favorite;
       }
       public void Race()
       {
           base.Introduce();//使用base关键字调用父类方法
           Console.WriteLine("下面给大家表演赛跑，请大家鼓掌!");
       }

       public override void Have()
       {
           Console.WriteLine("吃骨头!");
       }
   }
			

调用：

			
static void Main(string[] args)
       {
           //创建两个对象
           Cat objCat = new Cat("球球", "黄色", "小花猫", "小鱼");
           Dog objDog = new Dog("团团", "黑色", "小黑狗", "骨头");

           //将子类对象添加到父类集合
           List<Animal> list = new List<Animal>();

           //List<object> list1 = new List<object>();
           //添加时自动将子类转换为父类类型(父类类型可以添加子类对象，子类自动转换成父类类型)
           list.Add(objCat);
           list.Add(objDog);

           //取出对象（取出时必须判断属于哪一个子类对象，父类类型对象必须强制转换成对应子类对象，才能调用子类方法。）
           foreach (Animal obj in list)
           {
               if (obj is Cat)//判断原始类型
                   ((Cat)obj).Have();
               else
                   ((Dog)obj).Have();
           }

       }
			

从上述代码示例中我们可以看到,父类类型可以添加子类对象,子类自动转换成父类类型。而在取出对象时,需要判断对象的原始类型属于哪一个对象，然后强制转换成对应子类对象，才能调用子类的方法。下面介绍如何使用抽象类和抽象方法优化上述示例代码。

使用抽象类和抽象方法

在父类中定义一个抽象方法:

			
   /// <summary>
   /// 动物类(父类)
   /// </summary>
   abstract class Animal
   {
       public string Name { get; set; }//名字
       public string Color { get; set; }//颜色
       public string Kind { get; set; }//种类
       public string Favorite { get; set; }//喜好

       public Animal() { }
       public Animal(string name, string color, string kind)
       {
           this.Name = name; 
           this.Color = color;
           this.Kind = kind;
       }
       //自我介绍
       public void Introduce()
       {
           string info = string.Format("我是漂亮的{0},我的名字叫{1},身穿{2}的衣服,我爱吃{3}!", this.Kind, Name, Color, Favorite);
           Console.WriteLine(info);
       }

       /// <summary>
       /// 定义一个抽象方法
       /// </summary>
       public abstract void Have();
			

在子类中重写(override)父类未实现的方法(抽象方法)：

			
   /// <summary>
   /// 玩具猫类
   /// </summary>
   class Cat:Animal//继承Animal类
   {
       public Cat() { }//默认调用父类的无参构造函数，若此时父类并没有无参构造函数，则报错
       public Cat(string name, string color, string kind, string favorite) : base(name, color, kind)
       {
           this.Favorite = favorite;
       }
       //跳舞
       public void Dancing()
       {
           base.Introduce();//调用父类的方法
           Console.WriteLine("下面给大家表演，请大家鼓掌!");
       }

       /// <summary>
       /// 重写父类的Have()方法
       /// </summary>
       public override void Have()
       {
           Console.WriteLine("吃烤鱼!");
       }

   }
			

			
   /// <summary>
   /// 玩具狗类
   /// </summary>
   class Dog:Animal//继承Animal类
   {
       public Dog(string name, string color, string kind)
       {
           this.Name = name;//使用this关键字访问父类成员
           this.Color = color;
           this.Kind = kind;
       }

       public Dog() { }//隐式调用:默认调用父类的无参构造函数，若此时父类并没有无参构造函数，则出错。

       public Dog(string name, string color, string kind, string favorite) : base(name, color, kind)
       {//显示调用
           this.Favorite = favorite;
       }
       public void Race()
       {
           base.Introduce();//使用base关键字调用父类方法
           Console.WriteLine("下面给大家表演赛跑，请大家鼓掌!");
       }

       /// <summary>
       /// 重写父类的Have()方法
       /// </summary>
       public override void Have()
       {
           Console.WriteLine("吃骨头!");
       }
   }
			

调用:

			
   static void Main(string[] args)
       {
           //创建两个对象
           Cat objCat = new Cat("球球", "黄色", "小花猫", "小鱼");
           Dog objDog = new Dog("团团", "黑色", "小黑狗", "骨头");

           //将子类对象添加到父类集合
           List<Animal> list = new List<Animal>();

           //添加时自动将子类转换为父类类型
           list.Add(objCat);
           list.Add(objDog);

           //取出对象
           foreach (Animal obj in list)
           {
               obj.Have();//不再需要类型判断
           }

       }
			