抽象类（abstract class）是一个什么概念？能举个例子吗？

Question

不必建立实例就能使用的类。
public abstract class clsTest
{
   public int GetInt()
   { return 1; }
}
使用时：
int i = clsTest.GetInt();
而一般的类要用：
clsTest t = new clsTest();
int i = t.GetInt();

Answer 1

抽象类是子类共同点的抽象，抽象类中可以定主abstract的方法，因为抽象类不能够实例化，所以必须在子类中实现所有的抽象方法。
如:
//祖
public abstract class animal {
  public abstract void eat(Food afood) {
    //具体并不知如何吃东西 
  }
}//子public class dog: animal {
   //实现
   public override void eat(Food afood) {
     if (afood.attr == Food.Meal) {
       ...
     }
   }
}

Answer 2

如果有msdn的话
可以看看这个
ms-help://MS.VSCC/MS.MSDNVS.2052/csref/html/vclrfAbstract.htm

Answer 3

abstract 修饰符可用于类、方法和属性。在类声明中使用 abstract 修饰符以指示类只能是其他类的基类。抽象类具有以下特性： 抽象类不能实例化。 
抽象类可以包含抽象方法和抽象访问器。 
不能用 sealed 修饰符修改抽象类，这意味着该类不能被继承。 
从抽象类派生的非抽象类必须包括继承的所有抽象方法和抽象访问器的实实现。 
在方法或属性声明中使用 abstract 修饰符以指示此方法或属性不包含实现。抽象方法具有以下特性： 抽象方法是隐式的 virtual 方法。 
只允许在抽象类中使用抽象方法声明。 
因为抽象方法声明不提供实实现，所以没有方法体；方法声明只是以一个分号结束，并且在签名后没有大括号 ({ })。例如： 
public abstract void MyMethod();
实现由 overriding 方法提供，它是非抽象类的成员。 
在抽象方法声明中使用 static、virtual 或 override 修饰符是错误的。 
除了在声明和调用语法上不同外，抽象属性的行为与抽象方法一样。 在静态属性上使用 abstract 修饰符是错误的。 
在派生类中，通过包括使用 override 修饰符的属性声明可以重写抽象的继承属性。 
抽象类必须为所有接口成员提供实现。 实现接口的抽象类可以将接口方法映射到抽象方法上。例如：interface I 
{
   void M();
}
abstract class C: I 
{
   public abstract void M();
}
有关更多信息，请参阅 10.1.1.1 抽象类和 10.5.6 抽象方法。示例
在本例中，MyDerivedC 类是从抽象类 MyBaseC 派生的。抽象类包含一个抽象方法 MyMethod() 和两个抽象属性：GetX() 和 GetY()。// abstract_keyword.cs
// Abstract Classes
using System;
abstract class MyBaseC   // Abstract class
{
   protected int x = 100; 
   protected int y = 150;
   public abstract void MyMethod();   // Abstract method   public abstract int GetX   // Abstract property
   {
      get;
   }   public abstract int GetY   // Abstract property
   {
      get;
   }
}class MyDerivedC: MyBaseC
{
   public override void MyMethod() 
   {
      x++;
      y++;   
   }      public override int GetX   // overriding property
   {
      get 
      {
         return x+10;
      }
   }   public override int GetY   // overriding property
   {
      get
      {
         return y+10;
      }
   }   public static void Main() 
   {
      MyDerivedC mC = new MyDerivedC();
      mC.MyMethod();
      Console.WriteLine("x = {0}, y = {1}", mC.GetX, mC.GetY);    
   }
}
输出
x = 111, y = 161
在上面的示例中，如果试图通过使用下面的语句将抽象类实例化：MyBaseC mC1 = new MyBaseC();   // Error
将收到以下错误信息：Cannot create an instance of the abstract class 'MyBaseC'.

Answer 4

to icyer():
icyer兄似乎混淆了“抽象”和“静态”的概念或者说“类”和“对象”的概念。
以下所使用的“模版”和“类”，“对象”和“实例”等名词是同等的概念。静态的成员即类成员，类是对象的模版，对象是用这个模版创造出来的实例。在面向对象的系统中，系统是由对象组成的，而不是类。非静态的成员是对象的成员，引用一个对象的成员时，如果该对象不存在，这种引用是没有意义的。所以icyer兄直接用一个类(模版)引用一个实例的方法是不对的。基于上面的观点，抽象类是指这样一种模版：它没办法直接创建实例，它只能籍它衍生出的模版（非抽象的子类）来创建实例。因为这些实例的模版是该抽象类（模版）的子，所以我们可以认为这些实例的类型就是前述的抽象类型。从而，可以把这些实例赋予上述抽象类型的指针。最后，任何时候，不论一个 变量/指针 是否是一个抽象类型的 变量/指针，它必须指向一个实实在在的实例时才能引用实例型的成员（属性或者方法）。