抽象类和抽象方法
程序员文章站
2024-01-22 08:32:52
该随笔简单的展示了抽象类和抽象方法的定义和使用，使用继承体现面向对象"多态"…… ......
父类与子类相互转换
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 }
给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 }
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 }
调用：
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 }
从上述代码示例中我们可以看到,父类类型可以添加子类对象,子类自动转换成父类类型。而在取出对象时,需要判断对象的原始类型属于哪一个对象，然后强制转换成对应子类对象，才能调用子类的方法。下面介绍如何使用抽象类和抽象方法优化上述示例代码。
使用抽象类和抽象方法
在父类中定义一个抽象方法:
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();
在子类中重写(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 }
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 }
调用:
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 }
使用抽象类和抽象方法后，我们发现无需对取出对象进行类型判断，程序也能自动调用对应子类的实现方法(由虚拟机完成)。充分体现了面向对象编程的"多态"思想，使用"继承多态"机制很好地解决了系统扩展问题。
总结抽象类与抽象方法
抽象类的概念与使用要点:
1.使用关键字abstract修饰的类，称为抽象类。
2.抽象类只是用来列举一个类所具有的行为，不能单独通过创建对象来使用,如 animal animal=new animal() （×）。
3.抽象类中可以有抽象方法，也可以没有任何抽象方法。但是有抽象方法的类一定是抽象类。
4.抽象类不能是静态类(static)或密封类(sealed)。注:密封类不能被重写。
抽象方法的概念与使用要点:
1.再抽象类中使用abstract修饰的方法，称之为抽象方法。
2.抽象方法必须再抽象类中定义，不能再普通类中使用(即有抽象方法的类一定是抽象类)。
3.抽象方法只是一个方法的声明，不能有任何方法体。如：public abstract void have();
4.抽象方法仅仅表示一个应该具有的行为,具体实现由子类实现。
5.抽象方法再子类中被实现(重写)必须使用关键字override。
6.子类必须重写父类的所有抽象方法，除非子类本身也是抽象类。
上一篇： jq不传参是获取，传参是设置