接口，虚函数，抽象类的理解

说明：接口其实就是程序之间的一种协定，用来约束一组相关的行为。这三种概念的功能很类似下面通过一些例子来说明。
1.接口
现在有三个动物：猫，狗，鸭子，猫不会游泳，狗会游泳，鸭子会游泳。我们要描述这三种动物，如果采用虚函数的形式，则无法解决游泳函数问题

using System;
class dongwu  //基类
{
    virtual public void youyong() //虚函数
    {
        Console.WriteLine("游泳");
    }
}
class mao:dongwu
{
    
}
class gou : dongwu
{
    override public void youyong()
    {
        Console.WriteLine("狗刨式游泳");
    }
}
class yazi : dongwu
{
    override public void youyong()
    {
        Console.WriteLine("靠浮力游泳");
    }
}
class Test
{
    public void show(dongwu d)
    {
        d.youyong();
    }
    public static void Main(string[] args)
    {
        Test t = new Test();
        mao m = new mao();
        gou g = new gou();
        yazi y = new yazi();
        t.show(m);  //无法解决游泳函数问题
        t.show(g);
        t.show(y);
    }
}

所以上面的方法无法解决这个问题，因此我们可以使用接口，接口里面封装游泳的方法，具体由继承的类去实现，这里可以想象类是对象的封装，结构是方法的封装（不知道是否合适）

using System;
interface you  //定义接口
{
    void youyong();
}
class mao //不会游泳所以不继承接口
{
    
}
class gou : you  //继承接口
{
    public void youyong()
    {
        Console.WriteLine("狗刨式游泳");
    }
}
class yazi : you
{
    public void youyong()
    {
        Console.WriteLine("靠浮力游泳");
    }
}
class Test
{
    public void show(you d)
    {
        d.youyong();
    }
    public static void Main(string[] args)
    {
        Test t = new Test();
        mao m = new mao();
        gou g = new gou();
        yazi y = new yazi();
        
        t.show(g);  //显示
        t.show(y);
    }
}

2.抽象类
抽象方法必须在抽象类中，且抽象类被继承以后子类必须实现基类中的抽象方法（基类中没有实现方法）。这一点和虚函数不同，虚函数必须有实现，所以子类不一定需要对基类方法进行重写，如果不重写子类使用基类的虚方法。

using System;
abstract class dongwu
{
    abstract public void youyong();
}
class mao    //:dongwu,如果要继承必须要有对youyong()的实现
{
    
}
class gou : dongwu
{
    override public void youyong()
    {
        Console.WriteLine("狗刨式游泳");
    }
}
class yazi : dongwu
{
    override public void youyong()
    {
        Console.WriteLine("靠浮力游泳");
    }
}
class Test
{
    public void show(dongwu d)
    {
        d.youyong();
    }
    public static void Main(string[] args)
    {
        Test t = new Test();
        mao m = new mao();
        gou g = new gou();
        yazi y = new yazi();
        
        t.show(g);
        t.show(y);
    }
}

3.虚函数
虚函数的作用主要是用于子类对父类方法的重写。

using System;
class dongwu
{
    virtual public void jiao()
    {
        Console.WriteLine("正常叫");
    }
}
class mao:dongwu   
{
    
}
class gou : dongwu
{
    override public void jiao()
    {
        Console.WriteLine("汪汪叫");
    }
}
class yazi : dongwu
{
    override public void jiao()
    {
        Console.WriteLine("嘎嘎叫");
    }
}
class Test
{
    public void show(dongwu d)
    {
        d.jiao();
    }
    public static void Main(string[] args)
    {
        Test t = new Test();
        mao m = new mao();
        gou g = new gou();
        yazi y = new yazi();
        t.show(m);
        t.show(g);
        t.show(y);
    }
}

4.重写和覆盖的区别
重写主要是用于实现多态，然而覆盖不能实现多态

using System;
class dongwu
{
    public void jiao()
    {
        Console.WriteLine("正常叫");
    }
}
class mao:dongwu   
{
    
}
class gou : dongwu
{
    public void jiao()
    {
        Console.WriteLine("汪汪叫");
    }
}
class yazi : dongwu
{
    public void jiao()
    {
        Console.WriteLine("嘎嘎叫");
    }
}
class Test
{
    public void show(dongwu d)
    {
        d.jiao();
    }
    public static void Main(string[] args)
    {
        Test t = new Test();
        mao m = new mao();
        gou g = new gou();
        yazi y = new yazi();
        t.show(m);  //输出"正常叫"
        t.show(g);  //输出"正常叫"
        t.show(y);  //输出"正常叫"
    }
}

总结：接口主要是对共同方法的封装但不实现其具体功能，主要是在程序间提供一种共同的协定。抽象类，抽象方法主要封装在类中不提供方法的实现，具体实现由子类去实现，用于提供程序最初的框架。虚函数用于在基类中定义的函数，在子类中能有重写的机会。三者的共同目标是实现多态。