标签：
1）概念
抽象类是特殊的类，只是不能被实例化；除此以外，具有类的其他特性；重要的是抽象类可以包括抽象方法，这是普通类所不能的。抽象方法只能声明于抽象类中，且不包含任何实现，派生类必须覆盖它们。另外，抽象类可以派生自一个抽象类，可以覆盖基类的抽象方法也可以不覆盖，如果不覆盖，则其派生类必须覆盖它们。接口是引用类型的，接口和抽象类实现了oop中的一个原则，把可变的与不可变的分离。抽象类和接口就是定义为不可变的，而把可变的作为子类去实现，接口和抽象类的相似之处有三点：
² 不能实例化；
² 包含未实现的方法声明；
² 派生类必须实现未实现的方法，抽象类是抽象方法，接口则是所有成员（不仅是方法包括其他成员）；
2）抽象类和接口的区别
² 类是对对象的抽象，可以把抽象类理解为把类当作对象，抽象成的类叫做抽象类.而接口只是一个行为规范或规定
² 接口基本上不具备继承的任何具体特点,它仅仅承诺了能够调用的方法
² 一个类一次可以实现若干个接口,但是只能扩展一个父类
² 接口除了可以包含方法之外，还可以包含属性、索引器、事件，而且这些成员都被定义为公有的。除此之外，不能包含任何其他的成员，例如：常量、域、构造函数、析构函数、静态成员。一个类可以直接继承多个接口，但只能直接继承一个类（包括抽象类）。
3）抽象类和接口的使用：
² 如果预计要创建组件的多个版本，则创建抽象类。抽象类提供简单的方法来控制组件版本。
² 如果创建的功能将在大范围的全异对象间使用，则使用接口。如果要设计小而简练的功能块，则使用接口。
² 如果要设计大的功能单元，则使用抽象类.如果要在组件的所有实现间提供通用的已实现功能，则使用抽象类。
² 抽象类主要用于关系密切的对象；而接口适合为不相关的类提供通用功能。
以下是我在网上看到的几个形象比喻,真的非常不错,呵呵:
1.飞机会飞，鸟会飞，他们都继承了同一个接口“飞”；但是F22属于飞机抽象类，鸽子属于鸟抽象类。
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;
【例子1】
private void button1_Click(object sender,System.EventArgs e)
{
((CButton)sender).Text=”Clicked!”;
Button newButton=new Button();
newButton.Text=”New Button!”;
newButton.Click+=new EventHandler(newButton_Click);
Controls.Add(newButton);
}
private void newButton_Click(object sender,System.EventArgs e)
{
((Button)sender).Text=”Clicked!”;
}
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
{
}
public class MyBaseClass
{
public MyBaseClass(){}
public MyBaseClass(int i){}
}
public class MyDerivedClass: MyBaseClass
{
public MyDerivedClass(){}
public MyDerivedClass(int i){}
public MyDerivedClass(int i, 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=new MyDerivedClass(4,8);
l 执行System.Object.Object()构造函数。
l 执行MyBaseClass.MyBaseClass()构造函数。
l 执行MyDerivedClass.MyDerivedClass(int i,int j)构造函数。
若MyDerivedClass的定义做如下修改：
public class MyDerivedClass:MyBaseClass
{
….
public MyDerivedClass(int i, int j) : base(i)
{}
}
则MyDerivedClass myObj=new MyDerivedClass(4,8);其执行顺序如下：
l 执行System.Object.Object()构造函数。
l 执行MyBaseClass.MyBaseClass(i)构造函数。
l 执行MyDerivedClass.MyDerivedClass(int i,int j)构造函数。
若MyDerivedClass定义作如下修改：
public class MyDerivedClass:MyBaseClass
{
public MyDerivedClass():this(5,6)
{}
public MyDerivedClass(int i, int j) :base(i)
}
则MyDerivedClass myObj=new MyDerivedClass();的执行顺序如下：
l 执行System.Object.Object()构造函数。
l 执行MyBaseClass.MyBaseClass(i)构造函数。
l 执行MyDerivedClass.MyDerivedClass(int i,int j)构造函数。
l 执行MyDerivedClass.MyDerivedClass()构造函数。
1）成员修饰符
public: 成员可以由任何代码范围
private: 成员只能由类中的代码访问(如果没有使用任何关键字,就默认使用这个关键字)
internal: 成员只能由定义它的项目(程序集)内部的代码访问
protected: 成员只能由类或派生类中的代码访问
2）方法修饰符
static: 只能通过类访问,不能通过对象实例化来访问
abstract: 方法必须在非抽象的派生类中重写(只用于抽象类中)
virtual: 方法可以重写
override: 方法重写了一个基类方法(如果方法被重写,就必须使用该关键字)
extern: 方法定义放在其它地方
【例子1】字段、属性与方法
public class MyClass
{
//使用readonly修饰,只能声明或构造函数中赋值
public readonly string Name;
private int intVal;
//属性Val的访问器属性为protect所以不能直接在main中使用,但可在其派生类中使用
public int Val
{
protected get
{
return intVal+1;
}
//不能同时设置两个访问器的权限
set
{
if (value >= 0 && value <= 10)
intVal = value;
else
//使用throw抛出异常
throw (new ArgumentOutOfRangeException("Val",value,"Val 必须是0~10"));
}
}
//重写了Object类的ToString方法,所以要用override修饰符
public override string ToString()
{
return "Name:" + Name + "\nVal:" + Val;
}
//使用this关键字调用自身的MyClass(string newName)构造函数
private MyClass(): this("Default Name"){}
public MyClass(string newName)
{
Name = newName;
intVal = 0;
}
}
public class MyClass2 : MyClass
{
Internal int myVal;
//构造函数中使用base关键字调用基类的构造函数
public MyClass2() : base("MyClass2"){}
//由于基类的Val属性的get访问器修饰符为protected,只能在类或派生类代码中访问
public int 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)
class Program
{
static void Main(string[] args)
{
//实例化时只能调用非静态函数及非静态字段，类调用时只能调用静态函数和静态字段
MyExternalClass myClass = new MyExternalClass(2);
myClass.ShowIntVal();
MyExternalClass.strName = "My Static Name";
MyExternalClass.ShowName();
Console.ReadKey();
}
}
public class MyExternalClass
{
private int myIntVal;
public static string strName;
public static void ShowName()
{
Console.WriteLine(strName);
}
//使用构造函数来为私有变量myIntVal赋值
public MyExternalClass(int nVal)
{
myIntVal = nVal;
}
public void ShowIntVal()
{
Console.WriteLine("MyIntVal={0}", myIntVal);
}
}
class Program
{
static void Main(string[] args)
{
DerivedClass1 C1 = new DerivedClass1();
DerivedClass2 C2 = new DerivedClass2();
C1.DoSomething1();
C2.DoSomething2();
BaseClass C0;
C0 = C1;
C0.DoSomething1(); //执行基类的代码，输出 DoSomething1 In Base Class
C0=C2;
C0.DoSomething2(); //执行继承类的代码，输出DoSomething2 In DerivedClass2
}
}
class BaseClass
{
internal void DoSomething1()
{
Console.WriteLine("DoSomething1 In Base Class");
}
//使用virtual修饰,表示方法可以被重写
virtual internal void DoSomething2()
{
Console.WriteLine("DoSomething2 In Base Class");
}
}
class DerivedClass1 : BaseClass
{
new internal void DoSomething1()
{
Console.WriteLine("DoSomething1 In DerivedClass1");
}
}
class DerivedClass2 : BaseClass
{
//override会重写基类代码
internal override void DoSomething2()
{
Console.WriteLine("DoSomething2 In DerivedClass2");
}
}
标签：
原文地址：http://www.cnblogs.com/meditatorBlog/p/OOOP.html
