当前位置： 移动技术网 > IT编程>开发语言>.net > 抽象类和抽象方法

抽象类和抽象方法

2019年03月08日  | 移动技术网IT编程  | 我要评论

求平均速度,问病网,博辛瓦怒踹贝纳永

父类与子类相互转换

 1 /// <summary>
 2     /// 动物类(父类)
 3     /// </summary>
 4      class animal
 5     {
 6         public string name { get; set; }//名字
 7         public string color { get; set; }//颜色
 8         public string kind { get; set; }//种类
 9         public string favorite { get; set; }//喜好
10 
11         public animal() { }
12         public animal(string name, string color, string kind)
13         {
14             this.name = name; 
15             this.color = color;
16             this.kind = kind;
17         }
18         //自我介绍
19         public void introduce()
20         {
21             string info = string.format("我是漂亮的{0},我的名字叫{1},身穿{2}的衣服,我爱吃{3}!", this.kind, name, color, favorite);
22             console.writeline(info);
23         }
24     }
view code

给cat和dog分别添加have()方法：

 1     /// <summary>
 2     /// 玩具猫类
 3     /// </summary>
 4     class cat:animal//继承animal类
 5     {
 6         public cat() { }//默认调用父类的无参构造函数，若此时父类并没有无参构造函数，则报错
 7         public cat(string name, string color, string kind, string favorite) : base(name, color, kind)
 8         {
 9             this.favorite = favorite;
10         }
11         //跳舞
12         public void dancing()
13         {
14             base.introduce();//调用父类的方法
15             console.writeline("下面给大家表演，请大家鼓掌!");
16         }
17 
18         public void have()
19         {
20             console.writeline("吃烤鱼!");
21         }
view code
 1 /// <summary>
 2     /// 玩具狗类
 3     /// </summary>
 4     class dog:animal//继承animal类
 5     {
 6         public dog(string name, string color, string kind)
 7         {
 8             this.name = name;//使用this关键字访问父类成员
 9             this.color = color;
10             this.kind = kind;
11         }
12 
13         public dog() { }//隐式调用:默认调用父类的无参构造函数，若此时父类并没有无参构造函数，则出错。
14 
15         public dog(string name, string color, string kind, string favorite) : base(name, color, kind)
16         {//显示调用
17             this.favorite = favorite;
18         }
19         public void race()
20         {
21             base.introduce();//使用base关键字调用父类方法
22             console.writeline("下面给大家表演赛跑，请大家鼓掌!");
23         }
24 
25         public override void have()
26         {
27             console.writeline("吃骨头!");
28         }
29     }
view code

调用：

 1 static void main(string[] args)
 2         {
 3             //创建两个对象
 4             cat objcat = new cat("球球", "黄色", "小花猫", "小鱼");
 5             dog objdog = new dog("团团", "黑色", "小黑狗", "骨头");
 6 
 7             //将子类对象添加到父类集合
 8             list<animal> list = new list<animal>();
 9 
10             //list<object> list1 = new list<object>();
11             //添加时自动将子类转换为父类类型(父类类型可以添加子类对象，子类自动转换成父类类型)
12             list.add(objcat);
13             list.add(objdog);
14 
15             //取出对象（取出时必须判断属于哪一个子类对象，父类类型对象必须强制转换成对应子类对象，才能调用子类方法。）
16             foreach (animal obj in list)
17             {
18                 if (obj is cat)//判断原始类型
19                     ((cat)obj).have();
20                 else
21                     ((dog)obj).have();
22             }
23 
24         }
view code

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

 

使用抽象类和抽象方法

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

 1     /// <summary>
 2     /// 动物类(父类)
 3     /// </summary>
 4     abstract class animal
 5     {
 6         public string name { get; set; }//名字
 7         public string color { get; set; }//颜色
 8         public string kind { get; set; }//种类
 9         public string favorite { get; set; }//喜好
10 
11         public animal() { }
12         public animal(string name, string color, string kind)
13         {
14             this.name = name; 
15             this.color = color;
16             this.kind = kind;
17         }
18         //自我介绍
19         public void introduce()
20         {
21             string info = string.format("我是漂亮的{0},我的名字叫{1},身穿{2}的衣服,我爱吃{3}!", this.kind, name, color, favorite);
22             console.writeline(info);
23         }
24 
25         /// <summary>
26         /// 定义一个抽象方法
27         /// </summary>
28         public abstract void have();
view code

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

 1     /// <summary>
 2     /// 玩具猫类
 3     /// </summary>
 4     class cat:animal//继承animal类
 5     {
 6         public cat() { }//默认调用父类的无参构造函数，若此时父类并没有无参构造函数，则报错
 7         public cat(string name, string color, string kind, string favorite) : base(name, color, kind)
 8         {
 9             this.favorite = favorite;
10         }
11         //跳舞
12         public void dancing()
13         {
14             base.introduce();//调用父类的方法
15             console.writeline("下面给大家表演，请大家鼓掌!");
16         }
17 
18         /// <summary>
19         /// 重写父类的have()方法
20         /// </summary>
21         public override void have()
22         {
23             console.writeline("吃烤鱼!");
24         }
25 
26     }
view code
 1     /// <summary>
 2     /// 玩具狗类
 3     /// </summary>
 4     class dog:animal//继承animal类
 5     {
 6         public dog(string name, string color, string kind)
 7         {
 8             this.name = name;//使用this关键字访问父类成员
 9             this.color = color;
10             this.kind = kind;
11         }
12 
13         public dog() { }//隐式调用:默认调用父类的无参构造函数，若此时父类并没有无参构造函数，则出错。
14 
15         public dog(string name, string color, string kind, string favorite) : base(name, color, kind)
16         {//显示调用
17             this.favorite = favorite;
18         }
19         public void race()
20         {
21             base.introduce();//使用base关键字调用父类方法
22             console.writeline("下面给大家表演赛跑，请大家鼓掌!");
23         }
24 
25         /// <summary>
26         /// 重写父类的have()方法
27         /// </summary>
28         public override void have()
29         {
30             console.writeline("吃骨头!");
31         }
32     }
view code

调用:

 1     static void main(string[] args)
 2         {
 3             //创建两个对象
 4             cat objcat = new cat("球球", "黄色", "小花猫", "小鱼");
 5             dog objdog = new dog("团团", "黑色", "小黑狗", "骨头");
 6 
 7             //将子类对象添加到父类集合
 8             list<animal> list = new list<animal>();
 9 
10             //添加时自动将子类转换为父类类型
11             list.add(objcat);
12             list.add(objdog);
13 
14             //取出对象
15             foreach (animal obj in list)
16             {
17                 obj.have();//不再需要类型判断
18             }
19 
20         }
view code

使用抽象类和抽象方法后，我们发现无需对取出对象进行类型判断，程序也能自动调用对应子类的实现方法(由虚拟机完成)。充分体现了面向对象编程的"多态"思想，使用"继承多态"机制很好地解决了系统扩展问题。

 

总结抽象类与抽象方法

抽象类的概念与使用要点:

　　1.使用关键字abstract修饰的类，称为抽象类。

　　2.抽象类只是用来列举一个类所具有的行为，不能单独通过创建对象来使用,如 animal animal=new animal()  （×）。

　　3.抽象类中可以有抽象方法，也可以没有任何抽象方法。但是有抽象方法的类一定是抽象类。

　　4.抽象类不能是静态类(static)或密封类(sealed)。注:密封类不能被重写。

 

抽象方法的概念与使用要点:

　　1.再抽象类中使用abstract修饰的方法，称之为抽象方法。

　　2.抽象方法必须再抽象类中定义，不能再普通类中使用(即有抽象方法的类一定是抽象类)。

　　3.抽象方法只是一个方法的声明，不能有任何方法体。如：public abstract void have();

　　4.抽象方法仅仅表示一个应该具有的行为,具体实现由子类实现。

　　5.抽象方法再子类中被实现(重写)必须使用关键字override。

　　6.子类必须重写父类的所有抽象方法，除非子类本身也是抽象类。

您可能感兴趣的文章:

如对本文有疑问，请在下面进行留言讨论，广大热心网友会与你互动！！ 点击进行留言回复

相关文章:

验证码：
最近更新的文章
大家感兴趣的文章
移动技术网