说说抽象类接口

一、抽象类/抽象方法

1、抽象方法用abstract修饰。

2、抽象方法不能有方法体(大括弧也不能有)。

Eg：

1 abstract class Person
2 
3 {
4 
5 public abstract void SayHi();
6 
7 }

3、抽象方法必须在抽象类中。

4、抽象类不能实例化，因为抽象成员，抽象成员是没有方法体的。

5、子类必须重写父类的抽象方法。

6、在子类中无法通过base关键字调用父类的抽象方法。

7、抽象方法是“光说不做”，只是定义了有这样的行为，但是具体的实现，交给子类。

8、抽象类中可以拥有非抽象成员，为了继承给它的子类。

9、抽象类中可以拥有虚方法。

10、抽象类使用场合：1）子类必须覆写父类的方法。2）父类没有必要实例化。

11、抽象类是被继承的，继承为了多态。

12、抽象成员，不能是私有的，因为子类没办法方法就没办法重写。

Eg1：

  1 //可移动存储设备
  2 
  3 abstract class RemoveableDevices
  4 
  5 {
  6 
  7    public abstract void Read();
  8 
  9    public abstract void Write();
 10 
 11 }
 12 
 13 //U盘类
 14 
 15 class UDisk：RemoveableDevices
 16 
 17 {
 18 
 19    public override void Read()
 20 
 21    {
 22 
 23       Console.WriteLine("U盘读数据中...");
 24 
 25    }
 26 
 27    public override void WriteLine()
 28 
 29    {
 30 
 31       Console.WriteLine("U盘写数据...");
 32 
 33     }
 34 
 35 }
 36 
 37 //手机类
 38 
 39 class SmartPhone：RemoveableDevices
 40 
 41 {
 42 
 43    public override void Read()
 44 
 45    {
 46 
 47       Console.WriteLine("手机读数据中...");
 48 
 49    }
 50 
 51    public override void WriteLine()
 52 
 53    {
 54 
 55       Console.WriteLine("手机写数据...");
 56 
 57     }
 58 
 59 }
 60 
 61 //计算机类
 62 
 63 class Computer：RemoveableDevices
 64 
 65 {
 66 
 67    public void ReadData(RemoveableDevices device)
 68 
 69    {
 70 
 71       device.Read();
 72 
 73    }
 74 
 75    public void Write(RemoveableDevices device)
 76 
 77    {
 78 
 79        device.Write();
 80 
 81    }
 82 
 83 }
 84 
 85 
 86 class Program
 87 
 88 {
 89 
 90    static void Main(string[] args)
 91 
 92    {
 93 
 94      Computer c=new Computer();
 95 
 96      UDisk=new UDisk();
 97 
 98      c.ReadData(u);
 99 
100      Console.ReadKey();
101 
102    }
103 
104 }
View Code

Eg2:

 1 //笔记本类
 2 
 3 abstract class NoteBook
 4 
 5 {
 6 
 7  public abstract void ShowBrand();
 8 
 9 }
10 
11 //DELL类
12 
13 class Dell:NoteBook
14 
15 {
16 
17    public override void ShowBrand()
18 
19    {
20 
21       Console.WriteLine("我是戴尔电脑");
22 
23    }
24 
25 }
26 
27 //HP类
28 
29 class HP:NoteBook
30 
31 {
32 
33     public override void ShowBrand()
34 
35    {
36 
37       Console.WriteLine("我是惠普电脑");
38 
39    }
40 
41 
42 }
43 
44 class Program
45 
46 {
47 
48   static void Main(string[] args)
49 
50   {
51 
52      Console.WriteLine("你要什么电脑");
53 
54      string str=Console.ReaLine();
55 
56      NoteBook book=GetANoteBook(str);
57 
58      book.ShowBrand();
59 
60      Console.ReadKey();
61 
62   }
63 
64   //简单工厂模式
65 
66   static NoteBook GetANoteBook(string type)
67 
68   {
69 
70    if(type=="dell")
71 
72    {
73 
74     returu new Dell();
75 
76    }
77 
78    else if(type=="hp")
79 
80    {
81 
82     return new HP();
83 
84    }
85 
86    else
87 
88    return null;
89 
90   }
91 
92 }
View Code


二、说说ToString/Equals方法

Eg：

 1 class Person
 2 
 3 {
 4 
 5   public string Name{get;set;}
 6 
 7   public override string ToString()
 8 
 9   {
10 
11     return this.Name;
12   }
13 
14 }
15 
16 class Program
17 
18 {
19 
20   static void Main(string[] agrs)
21 
22   {
23 
24      Person p=new Person(){Name="小明"};
25 
26      Person p1=new Person(){Name="韩梅梅"};
27 
28      bool b=p.Equals(p1);//object 类里面的Equals方法是比较两个对象的引用地址
29 
30      //通过Reflector可以看到，调用了Console.writeLine(object value) ,里面实际上是执行了value.ToString()方法，实际上是调用了object类里面的ToString方法，
31 
32     //object类里面的ToString方法是一个虚方法，这个ToString方法里面，实际上是执行this.GetType().ToString();
33 
34      Console.WriteLine(p);//结果为小明
35 
36      Console.WriteLine(b);//结果为false，如果要使Equals比较的是Name的值，则需要重写Equals方法。
37 
38  
39 
40      string str0="abc";
41 
42      string str1="abc";
43 
44      b=str0.Equals(str1);//调用string类型的Equals方法，Equals(string str)比较的是两个字符串对象的内容
45 
46      Console.WriteLine(b);//结果为true
47 
48   }
49 
50 }
View Code

 三、接口

1、用interface定义接口，它是一个特殊的抽象类，不能实例化。

2、里面的成员不需要再加abstract，也不需要加访问修饰符，默认就是public abstract.

3、接口只能定义属性、方法、索引器、事件。

4、实现接口的类，必须要实现接口中的所有成员。

5、实现类在实现接口的成员的时候，不需要写override关键字。

6、接口就是为了纯粹的为了规范实现类的。

7、可以找到父类并且希望通过父类继承给子类一些成员，用抽象类。多个类具有相同的方法，但是找不出父类，就可以将方法定义在接口中，让这些类去实现。

8、一个类只能继承一个父类，但是可以实现多个接口，父类要写在第一个位置，一定程度上解决了类的单根性的问题。

9、接口可以继承接口。

10、接口中的成员，可以实现为抽象方法或者虚方法，让实现类的子类去实现。

11、显示实现接口，是为了解决方法名冲突的问题，显示实现的接口的方法是私有的，所以不能通过对象的变量来调用。

12、显示实现接口，这个接口的实现方法，只能通过接口变量来调用。

Eg：

 1 //鸟类
 2 
 3 class Bird
 4 
 5 {
 6 
 7 string name;
 8 
 9 public string Name
10 
11 {
12 
13 get{return name;}
14 
15 set{name=value;}
16 
17 }
18 
19 public void Eat()
20 
21 {
22 
23 }
24 
25 }
26 
27 //飞接口
28 
29 interface IFlyable
30 
31 {
32 
33 void Fly();
34 
35 }
36 
37 //麻雀类
38 
39 class MaQue:Bird,IFlyable
40 
41 {
42 
43  public void Fly()
44 
45  {
46 
47  ....
48 
49  }
50 
51 }
52 
53 //鸵鸟类
54 
55 class TuoNiao:Bird,IFlyable
56 
57 {
58 
59  public void Fly()
60 
61  {
62 
63  ....
64 
65  }
66 
67 }
68 
69 //鹰类
70 
71 class Ying:Bird,IFlyable
72 
73 {
74 
75  public void Fly()
76 
77  {
78 
79  ....
80 
81  }
82 
83 }
View Code

 

posted @ 2013-10-05 18:27  蜡笔小新111  阅读(603)  评论(0)  编辑  收藏  举报