你的位置:首页 > ASP.net教程

[ASP.net教程]【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

{

}

修饰符

                          含义

无或internal

类只能在当前项目中访问

public

类可以在任何地方访问

abstract或internal abstract

类只能在当前项目中访问,不能实例化,只能继承

public abstract

类可以在任何地方访问,不能实例化,只能继承

sealed 或internal sealed

类只能在当前项目中访问,不能派生,只能实例化

public sealed

类可以在任何地方访问,不能派生,只能实例化

 

关键字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");

    }

}