假如很多人要买水果吃，吃的动作只有一个，但是有的人要用现金买，有的人用信用卡，有的人赊帐。要为每个人定义一个类，就要定义多个相同的吃的方法。如果定义一个抽象类，在里面实现吃的方法，再做一个买的抽象方法。那每个人的类都从这个抽象类派生下来，只要实现买的方法即可，吃的方法就可以直接用父类的方法了。如果要改吃的方法就不用改多个，只要改这个抽象类里的就行了。    

一个接口：

  public interface IGrabber
    {
        /// <summary>
        /// 是否可用。
        /// </summary>
        bool Enabled
        {
            get;
            set;
        }

        /// <summary>
        /// 抓取器名。
        /// </summary>
        string Name
        {
            get;
            set;
        }

        /// <summary>
        /// 源字符串最大长度。
        /// </summary>
        uint MaxSourceLength
        {
            get;
            set;
        }

        /// <summary>
        /// 源字符串最小长度。
        /// </summary>
        uint MinSourceLength
        {
            get;
            set;
        }

        /// <summary>
        /// 抓取。
        /// </summary>
        /// <param name="source">要抓取的源。</param>
        /// <param name="target">抓取结果。</param>
        /// <returns>是否抓取成功。</returns>
        bool Grab(string source, out string[] targets);

        /// <summary>
        /// 抓取。
        /// </summary>
        /// <param name="source">要抓取的源。</param>
        /// <param name="targets">抓取结果。</param>
        /// <returns></returns>
        bool Grab(IList<Keys> source, out string[] targets)

 一个抽象类：

  public abstract class BaseGrabber : IGrabber
    {
        #region IGrabber成员。

        public virtual bool Enabled
        {
            get;
            set;
        }

        public virtual string Name
        {
            get;
            set;
        }

        public virtual uint MaxSourceLength
        {
            get;
            set;
        }

        public virtual uint MinSourceLength
        {
            get;
            set;
        }

        public abstract bool Grab(string source, out string[] targets);

        public abstract bool Grab(IList<Keys> source, out string[] targets);

        #endregion

        /// <summary>
        /// 是否重构数据源（识别方向键、删除键等按键对输入字符的影响，返回真实的输入项）。
        /// </summary>
        public virtual bool IsRestructured
        {
            get;
            set;
        }

        PRotected BaseGrabber()
        {
            this.Name = this.GetType().Name;
            this.MinSourceLength = 0;
            this.MaxSourceLength = 256;
            this.Enabled = true;
            this.IsRestructured = true;
        }

        /// <summary>
        /// 重构数据源（识别方向键、删除键等按键对输入字符的影响，返回真实的输入项）。
        /// </summary>
        /// <param name="source"></param>
        /// <returns></returns>
        public virtual string RestructureSource(string source)
        {
            return source;
        }

        /// <summary>
        /// 重构数据源（识别方向键、删除键等按键对输入字符的影响，返回真实的输入项）。
        /// </summary>
        /// <param name="source"></param>
        /// <returns></returns>
        public virtual IList<Keys> RestructureSource(IList<Keys> source)
        {
            int count = source.Count;
            for (int i = 0; i < count; i++)
            {
                Keys key = source[i];
                switch (key)
                {
                    case Keys.Back:
                        source.RemoveAt(i);
                        source.RemoveAt(i - 1);
                        i -= 2;
                        count -= 2;
                        break;
                }
            }
            return source;
        }

 终于搞明白了，还是上面那个例子说的是在。从接口到抽象类，在从抽象类到类，在类到对象。这就是面向对象。

下面是有关抽象类的一些基本感念：

抽象类与抽象方法由abstract修饰

抽象方法没有方法体

抽象类的派生类必须实现抽象方法体

抽象类只能作为基类，无法实例化。

重点就在于无法实例化，而且为了代码的清晰度，方便以后修改。