Abstract（抽象）

谈到抽象，就先谈谈面向对象语言的三大特性，也是人们口中常说的封装、继承、多态。

封装：什么是封装，按到我的理解，封装就是把某些类的相关属性和方法封装，对内实现数据影城，对外提供稳定接口。

继承：从字面上理解，就是声明一个父类，然后子类可以继承，并且子类拥有父类的一切属性和方法。

多态，值一个类实例相同的方法不同情形有不同表现形式

讲完这些说说主题，抽象类和接口。

先来说说抽象类：

1）抽象类的本质还是一个类，里面可以包含一切类可以包含的
2）抽象成员 必须包含在抽象类里面，抽象类还可以包含普通成员
3）继承抽象类后，必须显示的override其抽象成员
4）抽象类不能直接实例化，声明的对象只能使用抽象类里的方法，不能用子类新增的方法
5）父类只有一个

比如说声明一个手机的抽象类，手机又打电话，品牌，系统等一些基本属性。

public abstract class BasePhone
    {
        public int Id { get; set; }
        public string Name = "123";
        public delegate void DoNothing();
        public event DoNothing DoNothingEvent;

        public void Show()
        {
            Console.WriteLine("这里是Show1");
        }
        public virtual void ShowVirtual()
        {
            Console.WriteLine("这里是Show");
        }

        /// <summary>
        /// 品牌
        /// </summary>
        /// <returns></returns>
        public abstract string Brand();

        /// <summary>
        /// 系统
        /// </summary>
        /// <returns></returns>
        public abstract string System();

        /// <summary>
        /// 打电话
        /// </summary>
        public abstract void Call();

        /// <summary>
        /// 拍照
        /// </summary>
        public abstract void Photo();

        public abstract void Do<T>();
    }

然后有一台苹果手机；应该怎么做呢，这时候就可以继承这个抽象类。

    public class iPhone : BasePhone
    {
        /// <summary>
        /// 品牌
        /// </summary>
        /// <returns></returns>
        public override string Brand()
        {
            return "iPhone";
        }

        /// <summary>
        /// 系统
        /// </summary>
        /// <returns></returns>
        public override string System()
        {
            return "IOS";
        }

        /// <summary>
        /// 打电话
        /// </summary>
        public override void Call()
        {
            Console.WriteLine("User{0} {1} {2} Call", this.GetType().Name, this.Brand(), this.System());
        }

        /// <summary>
        /// 拍照
        /// </summary>
        public override void Photo()
        {
            Console.WriteLine("User{0} {1} {2} Call", this.GetType().Name, this.Brand(), this.System());
        }

        public override void Do<T>()
        {

        }

    }

那如果这台手机需要实现一个支付功能呢，怎么办，可以在苹果手机类中添加一个支付功能，但是手机不只是有苹果，还有别的品牌，如果都有支付功能，不可能在每个类中都添加一个这样的方法吧，这样太麻烦了，有人会讲，在抽象类中抽象一个支付方法，但是在抽象类中添加了方法，所有继承了这个类的都需要实现这个方法，这样太不方便了，这个时候就需要接口。

1）接口不是类，里面可以包含属性、方法、事件 不能包含字段，委托，不能用访问修饰符

2）接口只能包含没有实现的方法

3）实现接口的话，必须实现全部方法

4）接口不能直接实例化，声明的对象只能使用接口里的方法，不能用子类新增的方法

5）接口可以实现多个

public interface IPay
    {
        void Pay();
    }

这样在苹果类实现这个接口，就既可以实现支付功能，又不会影响其他类。

   public class iPhone : BasePhone,  IPay
    {
        /// <summary>
        /// 品牌
        /// </summary>
        /// <returns></returns>
        public override string Brand()
        {
            return "iPhone";
        }

        /// <summary>
        /// 系统
        /// </summary>
        /// <returns></returns>
        public override string System()
        {
            return "IOS";
        }

        /// <summary>
        /// 打电话
        /// </summary>
        public override void Call()
        {
            Console.WriteLine("User{0} {1} {2} Call", this.GetType().Name, this.Brand(), this.System());
        }

        /// <summary>
        /// 拍照
        /// </summary>
        public override void Photo()
        {
            Console.WriteLine("User{0} {1} {2} Call", this.GetType().Name, this.Brand(), this.System());
        }

        public override void Do<T>()
        {

        }

        public void Pay()
        {
            throw new NotImplementedException();
        }
    }　

说了这么多。那么什么时候用抽象类，什么时候用接口呢

抽象是模板化，减少一定的代码量；

接口是功能化，增加一定的灵活性；

用经典的话说，就是is a，和has a 的关系。

抽象类本质还是一个类，就好比上面举的例子，BasePhone这个类他的本质还是是一份手机，只不过是把手机一些共有的性能给抽象出来一个类。

在比如IPay这个接口，它只是为了手机拥有这个功能而存在的，但不是所有的手机都拥有了这个功能，所以说只能把支付功能声明为一个接口。

最后说说重写overwrite(new)  覆写override 重载overload(方法)

在这里就不细说了，直接通过代码是讲述。

声明一个父类：有普通方法，虚方法，抽象方法，然后子类继承，

#region abstract
    public abstract class ParentClass
    {
        /// <summary>
        /// CommonMethod
        /// </summary>
        public void CommonMethod()
        {
            Console.WriteLine("ParentClass CommonMethod");
        }

        /// <summary>
        /// virtual  虚方法  必须包含实现 但是可以被重载
        /// </summary>
        public virtual void VirtualMethod()
        {
            Console.WriteLine("ParentClass VirtualMethod");
        }

        public abstract void AbstractMethod();
    }

    public class ChildClass : ParentClass
    {
        /// <summary>
        /// new 隐藏
        /// </summary>
        public new void CommonMethod()
        {
            Console.WriteLine("ChildClass CommonMethod");
        }
        /// <summary>
        /// virtual 可以被覆写
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public override void VirtualMethod()
        {
            Console.WriteLine("ChildClass VirtualMethod");
            base.VirtualMethod();
        }

        public override void AbstractMethod()
        {
            Console.WriteLine("ChildClass AbstractMethod");
        }
    }

    #endregion abstract

　通过控制台程序看效果。　

class Program{
 static void Main(string[] args)
        {
   Console.WriteLine("*******************************************");
                     Console.WriteLine("*******************************************");
            Console.WriteLine("*******************************************");
            ParentClass instance = new ChildClass();
            Console.WriteLine("下面是instance.CommonMethod()");
            instance.CommonMethod();
            Console.WriteLine("下面是instance.VirtualMethod()");
            instance.VirtualMethod();
            Console.WriteLine("下面是instance.AbstractMethod()");
            instance.AbstractMethod();
}

}

　　

可以看出普通方法，是调用父类的方法，虚方法和抽象方法都是调用子类的，其实不难理解，因为虚方法和抽象方法都被子类给override（覆写）了。

那什么是重载呢，重载就是方法名相同，参数不同

 public new void CommonMethod()
        {
            Console.WriteLine("ChildClass CommonMethod");
        }

        public void CommonMethod(string name)
        {
           Console.WriteLine("ChildClass CommonMethod");
        }
       public void CommonMethod(int id)
        {
            Console.WriteLine("ChildClass CommonMethod");
        }
        public void CommonMethod(int id, string name)
        {
            Console.WriteLine("ChildClass CommonMethod");
       }