C# OOP

面向对象的三大特征

(1). 封装：将一些行为以类为单位进行包裹起来，然后通过类进行调用（如People类），可以利用private、public、protected灵活控制属性的可访问性。

好处：

　　①：保证数据安全（灵活使用private、public、protected进行控制）

　　②：屏蔽细节，只要方法名不变，可以随意扩展。

　　③：代码重用

(2). 继承：通过继承，子类可以拥有父类的一切动作（如Student类继承People类）

(3). 多态：多态有很多种。，

（补充“老杨”的经典语录：父类类型的变量可以指向子类类型的对象，调用方法的时候调用的是子类对象的实现。里氏替换原则是多态的另一种叫法，如下面的例子④）

　　①：通过不同子类继承同一个父类，实现多态（类似的还有子类继承抽象类、或者实现接口）

　　②：方法的重载本身就是一种多态

　　③：利用默认参数实现方法多态（利用命名参数实现方法的重载，即方法的多态）

　　④：运行时的多态（里氏替换原则，声明父类对象，调用虚方法，在子类覆写或者不覆写的情况下，分别调用子类方法或父类方法《只有在运行的时候才知道》）

　继承多态

1. 下面新建一个BasePhone类，该类中有属性、字段、委托、抽象方法、普通方法、虚方法、泛型抽象方法。

 

 1   public abstract class BasePhone
 2     {
 3         //1.属性
 4         public string id { get; set; }
 5         public string name { get; set; }
 6         //2.字段
 7         public string userPwd = "maru";
 8         //3.委托
 9         public delegate void DoNothing();
10         //4.抽象方法
11         public abstract void Brand();
12         public abstract void System();
13         public abstract void Call();
14         //5.普通方法(继承的子类无法对其进行覆写，可以对其进行重写)
15         public void show()
16         {
17             Console.WriteLine("这是父类show方法");
18         }
19         //6.虚方法(可以被任何继承他的子类所覆写)
20         public virtual void ShowVirtual()
21         {
22             Console.WriteLine("这是父类showVirtual方法");
23         }
24         //7.泛型方法抽象方法
25         public abstract void Do<T>();
26     }

 

 

 2. 新建一个iphone类，该类继承了BasePhone类，则继承了该类的属性、字段、和方法，同时必须对其抽象方法(包括泛型抽象方法)进行覆写，虚方法可以覆写也可以不进行覆写。

 

 1  public class iphone : BasePhone
 2     {
 3         /// <summary>
 4         /// 下面四个方法为对BasePhone中四个抽象方法的覆写
 5         /// </summary>
 6         public override void Brand()
 7         {
 8             Console.WriteLine("iphone品牌");
 9         }
10 
11         public override void System()
12         {
13             Console.WriteLine("iphone系统");
14         }
15 
16         public override void Call()
17         {
18             Console.WriteLine("iphone电话");
19         }
20 
21         public override void Do<T>()
22         {
23             Console.WriteLine("iphone做的事情");
24         }
25         /// <summary>
26         /// 下面的ITunes方法为子类特有的方法
27         /// </summary>
28         public void ITunes()
29         {
30             Console.WriteLine("iphone连接到ITunes上");
31         }
32         /// <summary>
33         /// 下面的ShowVirtual方法覆写父类中的虚方法
34         /// </summary>
35         public override void ShowVirtual()
36         {
37             Console.WriteLine("这是子类的showVirtual方法");
38         }
39         /// <summary>
40         /// 下面的show和父类中的一模一样，但是覆盖不了
41         /// </summary>
42         public void show()
43         {
44             Console.WriteLine("这是子类中的show方法");
45         }
46     
47     }

 

 3. 利用面向抽象的编程思想和里氏替换原则实例化一个iphone实例，该实例可以调用子类中4个覆写父类中的抽象方法；可以调用子类对父类虚方法覆写的方法；但对普通方法show，即使在子类中重新声明了，无论加没加new关键字（重写 ），均是调用父类的方法；该实例不能调用子类中单独新增的方法。

 

 1  {
 2                 Console.WriteLine("------------------------------ 一.抽象类的使用和特点 ---------------------------------------");
 3                 //面向抽象编程
 4                 BasePhone iphone = new iphone();   //里氏替换原则
 5                 //1. iphone类中四个覆写的抽象方法
 6                 iphone.Brand();
 7                 iphone.System();
 8                 iphone.Call();
 9                 iphone.Do<iphone>();
10                 //2. BasePhone中的两个方法
11                 iphone.show();     //调用的是父类中的方法
12                 iphone.ShowVirtual();  //调用的是子类覆写以后的方法
13                 //3. 调用子类特有的方法(调用不了)
14                 // iphone.ITunes();
15 }

 

结果：

 

　　对比父类中的虚方法(virtual)和抽象方法(abstract)的区别：

　　　　(1). 抽象方法没有方法体，其继承子类必须对其进行覆写(override).

            (2). 虚方法有方法体，其继承子类可以对其进行覆写(override)，可以不进行覆写。若进行覆写，调用的则是子类中覆写后的方法；若不进行覆写，则调用的是父类     中的方法。

　　　　(3). 抽象方法的关键字是abstract，且必须存在于抽象类中；虚方法的关键字是virtual，可以存在于任何类中。

接口多态

　　接口是包含一组虚方法的抽象类型，其中每一种方法都有其名称、参数、返回值。接口方法不能包含任何实现，CLR允许接口可以包含事件、属性、索引器、静态方法、静态字段、静态构造函数以及常数。但是接口不能包含任何静态成员。一个类可以实现多个接口，当一个类实现某个接口时，它不仅要实现该接口定义的所有方法，还要实现该接口从其他接口中继承的所有方法。

 　　接口的特点：

　　　　(1). 接口不是类，里面可以包含属性、方法、事件，但不能包括字段和静态成员。

　　　　(2). 接口只能包含没有实现的方法。

　　　　(3). 子类实现接口，必须要实现该接口定义的所有方法，还要实现该接口从其他接口中继承的所有方法。

　　　　(4). 接口不能被直接实例化，声明的对象只能使用接口中的方法，不能使用子类新增的方法。

　　　　(5). 同一个类可以实现多个接口。

1. 下面新建两个接口IExtend和IPay，分别包含没有实现的方法Game和Play。

 

1   public interface IExtend
2     {
3         void Game();
4     }
5    public interface IPay
6     {
7         void Play();
8     }

 

2. 下面新建一个iphone子类，实现接口IExtend和IPay，则必须实现这两个接口中的所有方法。

 

 1   public class iphone :  IExtend, IPay
 2     {
 3         /// <summary>
 4         /// 下面两个方法为显式的实现接口中的方法
 5         /// </summary>
 6         public void Play()
 7         {
 8             Console.WriteLine("这是子类显式实现了接口中的Play方法");
 9         }
10 
11         public void Game()
12         {
13             Console.WriteLine("这是子类显式实现了接口中的Game方法");
14         }
15     }

 

3. 下面分别用面向接口编程的方式和正常方式进行调用

 

 1 {
 2                 Console.WriteLine("------------------------------ 二.接口的使用和特点 ---------------------------------------");
 3                 //1.面向接口编程
 4                 Console.WriteLine("------------------------------ 1.面向接口编程 ---------------------------------------");
 5                 IExtend iphone = new iphone();   
 6                 iphone.Game();
 7                 IPay iphone2 = new iphone();
 8                 iphone2.Play();
 9                 //2.正常编程
10                 Console.WriteLine("------------------------------ 2.正常编程 ---------------------------------------");
11                 iphone iphone3 = new iphone();
12                 iphone3.Play();
13                 iphone3.Game();
14  }

 

运行结果：