【C#学习笔记】二、面向对象编程

2.1 抽象类与接口

1）概念

抽象类是特殊的类，只是不能被实例化；除此以外，具有类的其他特性；重要的是抽象类可以包括抽象方法，这是普通类所不能的。抽象方法只能声明于抽象类中，且不包含任何实现，派生类必须覆盖它们。另外，抽象类可以派生自一个抽象类，可以覆盖基类的抽象方法也可以不覆盖，如果不覆盖，则其派生类必须覆盖它们。接口是引用类型的，接口和抽象类实现了oop中的一个原则，把可变的与不可变的分离。抽象类和接口就是定义为不可变的，而把可变的作为子类去实现，接口和抽象类的相似之处有三点：

²        不能实例化；

²        包含未实现的方法声明；

²        派生类必须实现未实现的方法，抽象类是抽象方法，接口则是所有成员（不仅是方法包括其他成员）；

2）抽象类和接口的区别

²        类是对对象的抽象，可以把抽象类理解为把类当作对象，抽象成的类叫做抽象类.而接口只是一个行为规范或规定

²        接口基本上不具备继承的任何具体特点,它仅仅承诺了能够调用的方法

²        一个类一次可以实现若干个接口,但是只能扩展一个父类

²        接口除了可以包含方法之外，还可以包含属性、索引器、事件，而且这些成员都被定义为公有的。除此之外，不能包含任何其他的成员，例如：常量、域、构造函数、析构函数、静态成员。一个类可以直接继承多个接口，但只能直接继承一个类（包括抽象类）。

3）抽象类和接口的使用：

²       如果预计要创建组件的多个版本，则创建抽象类。抽象类提供简单的方法来控制组件版本。

²       如果创建的功能将在大范围的全异对象间使用，则使用接口。如果要设计小而简练的功能块，则使用接口。

²       如果要设计大的功能单元，则使用抽象类.如果要在组件的所有实现间提供通用的已实现功能，则使用抽象类。   

²       抽象类主要用于关系密切的对象；而接口适合为不相关的类提供通用功能。

 以下是我在网上看到的几个形象比喻,真的非常不错,呵呵:
1.飞机会飞，鸟会飞，他们都继承了同一个接口“飞”；但是F22属**机抽象类，鸽子属于鸟抽象类。
2. 就像铁门木门都是门（抽象类），你想要个门我给不了（不能实例化），但我可以给你个具体的铁门或木门（多态）；  

而且只能是门，你不能说它是窗（单继承）；一个门可以有锁（接口）也可以有门铃（多实现）。 门（抽象类）定义了你是什么，接口（锁）规定了你能做什么（一个接口最好只能做一件事，你不能要求锁也能发出声音吧（接口污染））。

2.2 接口多态性

假定不使用基类提供EatFood()方法，而是把该方法放到接口IConsume上，Cow和Chicken类也支持这个接口（Cow和Chicken类必须提供EatFood()方法的执行代码），接着就可以使用下述代码访问该方法：

Cow myCow=new Cow();

Chicken myChicken=new Chicken();

IConsume consumeInterface;

consumeInterface=myConw;

consumeInterface.EatFood();

consumeInterface=myChicken;

consumeInterface.EatFood;

2.3 Window应用程序中的OOP（P180）

【例子1】

private void button1_Click(objectsender,System.EventArgs e)

{

((CButton)sender).Text=”Clicked!”;  

ButtonnewButton=new Button();

newButton.Text=”NewButton!”;

newButton.Click+=newEventHandler(newButton_Click);

Controls.Add(newButton);

}

private void newButton_Click(objectsender,System.EventArgs e)

{

   ((Button)sender).Text=”Clicked!”;

}

2.4 类的定义（P184）

C#中只能有一个基类，如果继承了一个抽象类，就必须实现所继承的所有抽象成员(除非派生类也是抽象的)。一个类可指定多个接口，如：

public class MyClass: MyBase, IMyInterface,IMySecondInterface

{

}

关键字abstract和sealed不能在接口中使用，因为这两个修饰符在接口定义中无意义(接口不包含执行代码，所以不能直接实例化，且必须是可以继承的)。接口可使用多个基接口，如：

public interface IMyInterface:IMyBaseInterface, IMyBaseInterface2

{

}

2.5 构造函数执行顺序(P192)

public class MyBaseClass

{

publicMyBaseClass(){}

publicMyBaseClass(int i){}

}

public class MyDerivedClass: MyBaseClass

{

publicMyDerivedClass(){}

publicMyDerivedClass(int i){}

public MyDerivedClass(inti, int j){}

}

MyDerivedClass myObj=new MyDerivedClass();

l        执行System.Object.Object()构造函数。

l        执行MyBaseClass.MyBaseClass()构造函数。

l        执行MyDerivedClass.MyDerivedClass()构造函数。

MyDerivedClass myObj=new MyDerivedClass(4);

l        执行System.Object.Object()构造函数。

l        执行MyBaseClass.MyBaseClass(int i)构造函数。

l        执行MyDerivedClass.MyDerivedClass(int i)构造函数。

MyDerivedClass myObj=newMyDerivedClass(4,8);

l        执行System.Object.Object()构造函数。

l        执行MyBaseClass.MyBaseClass()构造函数。

l        执行MyDerivedClass.MyDerivedClass(int i,int j)构造函数。

若MyDerivedClass的定义做如下修改：

public class MyDerivedClass:MyBaseClass

{

….

publicMyDerivedClass(int i, int j) : base(i)

{}

}

则MyDerivedClassmyObj=new MyDerivedClass(4,8);其执行顺序如下：

l        执行System.Object.Object()构造函数。

l        执行MyBaseClass.MyBaseClass(i)构造函数。

l        执行MyDerivedClass.MyDerivedClass(int i,int j)构造函数。

若MyDerivedClass定义作如下修改：

public class MyDerivedClass:MyBaseClass

{

publicMyDerivedClass():this(5,6)

{}

publicMyDerivedClass(int i, int j) :base(i)

}

则MyDerivedClassmyObj=new MyDerivedClass();的执行顺序如下：

l        执行System.Object.Object()构造函数。

l        执行MyBaseClass.MyBaseClass(i)构造函数。

l        执行MyDerivedClass.MyDerivedClass(int i,int j)构造函数。

l        执行MyDerivedClass.MyDerivedClass()构造函数。

2.6 定义类成员（P209）

1）成员修饰符

public:   成员可以由任何代码范围

private:   成员只能由类中的代码访问(如果没有使用任何关键字,就默认使用这个关键字)

internal:  成员只能由定义它的项目(程序集)内部的代码访问

protected:成员只能由类或派生类中的代码访问

2）方法修饰符

static: 只能通过类访问,不能通过对象实例化来访问

abstract: 方法必须在非抽象的派生类中重写(只用于抽象类中)

virtual: 方法可以重写

override: 方法重写了一个基类方法(如果方法被重写,就必须使用该关键字)

extern:  方法定义放在其它地方

【例子1】字段、属性与方法

public class MyClass

{

    //使用readonly修饰,只能声明或构造函数中赋值

    publicreadonly stringName;

private intintVal;

//属性Val的访问器属性为protect所以不能直接在main中使用,但可在其派生类中使用

    publicint Val

    {

        protectedget

        {

             returnintVal+1;

         }

         //不能同时设置两个访问器的权限

         set

         {

             if (value >= 0 && value <= 10)

                 intVal = value;

             else

                 //使用throw抛出异常

throw (new ArgumentOutOfRangeException("Val",value,"Val 必须是0~10"));

         }  

     }

     //重写了Object类的ToString方法,所以要用override修饰符

     publicoverride stringToString()

     {

         return"Name:" + Name + "\nVal:" + Val;

      }

      //使用this关键字调用自身的MyClass(string newName)构造函数

      privateMyClass(): this("DefaultName"){}

      publicMyClass(string newName)

      {

          Name = newName;

          intVal = 0;

       }

}

public class MyClass2 : MyClass

{

     Internalint myVal;

     //构造函数中使用base关键字调用基类的构造函数

     publicMyClass2() : base("MyClass2"){}

     //由于基类的Val属性的get访问器修饰符为protected,只能在类或派生类代码中访问

     publicint Val

     {

         //派生类代码中可直接使用基类中Val属性的get和set访问器

         get{return base.Val;}

         set{base.Val = value;}

     }

}

class Program

{

static void Main(string[] args)

    {

        MyClass2 obj2=new MyClass2();

        Console.WriteLine(obj2.ToString());

        obj2.myVal = 20;

        Console.WriteLine("obj2.myVal={0}", obj2.myVal);

        for(int i = 0; i <= 11; i++)

        {

            obj2.Val = i;

            Console.WriteLine("intVal={0}", obj2.Val);

         }

         Console.ReadKey();

}

}

【例子2】类中的静态字段和静态方法(Ch09Ex03)

 classProgram

 {

    static voidMain(string[]args)

     {

          //实例化时只能调用非静态函数及非静态字段，类调用时只能调用静态函数和静态字段

          MyExternalClassmyClass = new MyExternalClass(2);

          myClass.ShowIntVal();

          MyExternalClass.strName= "My Static Name";

          MyExternalClass.ShowName();

          Console.ReadKey();

      }

 }

public class MyExternalClass

{

private intmyIntVal;

    publicstatic stringstrName;

    publicstatic voidShowName()

    {

        Console.WriteLine(strName);

}

//使用构造函数来为私有变量myIntVal赋值

public MyExternalClass(int nVal)

    {

        myIntVal = nVal;

    }

    publicvoid ShowIntVal()

    {

        Console.WriteLine("MyIntVal={0}", myIntVal);

     }

}

2.7 隐藏基类方法（P219）

class Program

{

    staticvoid Main(string[] args)

    {

        DerivedClass1C1 = new DerivedClass1();

        DerivedClass2C2 = new DerivedClass2();

        C1.DoSomething1();

        C2.DoSomething2();

        BaseClassC0;

        C0 = C1;

        C0.DoSomething1();   //执行基类的代码，输出 DoSomething1 In Base Class

        C0=C2;

        C0.DoSomething2();   //执行继承类的代码，输出DoSomething2 In DerivedClass2

    }

}

class BaseClass

{

    internalvoid DoSomething1()

    {

        Console.WriteLine("DoSomething1 In Base Class");

}

//使用virtual修饰,表示方法可以被重写

    virtualinternal voidDoSomething2()

    {

        Console.WriteLine("DoSomething2 In Base Class");

    }

}

class DerivedClass1 : BaseClass

{

    newinternal voidDoSomething1()

    {

        Console.WriteLine("DoSomething1 In DerivedClass1");

}

}

class DerivedClass2 : BaseClass

{

    //override会重写基类代码

    internaloverride voidDoSomething2()

    {

        Console.WriteLine("DoSomething2 In DerivedClass2");

    }

}

原标题：【C#学习笔记】二、面向对象编程

关键词：C#