我感觉你应该理解的是“泛”。瓶子和水，瓶子可以装你想要装的类型的水。

我在收看的教程视频是，把代码也给敲出来了，里面有相应的注释，分享一下吧

using System;
using System.Globalization;
using System.Net.Cache;

namespace PetShop
{
    interface ICatchMice //基类中接口的定义
    {
        void ICatchMice();
    }
    interface IClimbTree //基类中接口的定义
    {
        void IClimbTree();
    }
    abstract public class Pet
    {
        public int _age;
        public string _name;//设置为public或者protected，以便于子类访问
        public Pet(string name)//构造一个方法
        {
            _name = name;
            _age= 0;
        }
        public static Pet operator ++ (Pet pet)//重装运算符定义
        {
            ++pet._age;
            return pet;
        }
        public void PrintName()
        {
            Console.WriteLine("Pet's name is " + _name);
        }
        public void ShowAge()
        {
            Console.WriteLine(_name+"'s Age="+_age);
        }
        abstract public void Speak();
        /*上面这句话 是抽象方法的应用例子，之前版本 虚方法：
         virtual public void Speak()
         {
            Console.WriteLine(_name+"is speaking ");
          }       
        
         */
      

    }
    static class PetGuide
    {
        static public void HowToFeedDog(this Dog dog)
        {
            Console.WriteLine("Play a vedio about how to feed a dog");
        }
        static public void HowToFeedCat(this Cat cat)
        {
            Console.WriteLine("Play a vedio about how to feed a cat");
        }
    }
    public class Dog:Pet //继承的应用
    {
        static int Num;//静态类的应用
        static Dog()//静态构造方法的定义
        {
            Num = 0;
        }

        public Dog(string name):base(name)//显式调用基类构造函数
        {
            ++Num;
        }
        new public void PrintName()//重定义函数，隐藏功能实例
        {
            Console.WriteLine("宠物的名字叫 " + _name);
        }
        //sealed public override void Speak()//重写抽象函数，用override在派生类中被继承,
        //如果加上sealed关键字，那么在Dog的子类Hashiqi里重写Speak函数就会出错，sealed是密封的意思，不能被重写
        public override void Speak()//重写抽象函数，用override在派生类中被继承
        {
            Console.WriteLine(_name + " is speaking"+":wowo");
        }
        static public void ShowNum()//静态构造方法的调用
        {
            Console.WriteLine("Dog's number:" + Num);
        }
        /*public static implicit operator Dog(Cat cat)//隐式转换的定义，目的在于把猫猫变成狗狗，
        {
            return new Dog(cat._name);
        }*/
    }
   
    class Cat :Pet,ICatchMice, IClimbTree //子类中接口的调用
    {
        public Cat(string name) : base(name)
        {
        }
        public override void Speak()
        {
            Console.WriteLine(_name + " is speaking" + ":mewo");
        }
        public void ICatchMice()//子类中接口的调用
        {
            Console.WriteLine(_name+"can catch mice");
        }
        public void IClimbTree()//子类中接口的调用
        {
            Console.WriteLine(_name+"can climb tree");
        }
        public static implicit operator Cat(Dog dog)//隐式转换的定义，目的在于把狗狗变成猫猫，
        {
            return new Cat(dog._name);
        }

    }
    class Hashiqi:Dog
    {
        public Hashiqi(string name) : base(name)
        {
        }
        new public void PrintName()
        {
            Console.WriteLine("二哈的名字叫 " + _name);
        }
        public override void Speak()
        {
            Console.WriteLine(_name + " is speaking" + ":wowu");
        }

    }
    class Program
    {
        static void Main(string[] args)
        {
          Pet[] pets=new Pet[] {new Dog("Jack"),new Cat("Tom"),new Hashiqi("wangcai"),new Hashiqi("Chaijiazhe")};
            for(int i=0;i<pets.Length;i++)
            {
                pets[i].PrintName();
                pets[i].Speak();
            }
            Cat c = new Cat("Tom2");
            ICatchMice catchM = (ICatchMice)c;//强制转换c为接口类型
            c.ICatchMice();//通用接口调用
            catchM.ICatchMice();//通用接口调用
            IClimbTree climbT = c;//也可不用转换，本身就是一个引用类型
            c.IClimbTree();
            climbT.IClimbTree();

            /* Dog dog = new Dog();
             dog.Name = "Jack";
             dog.PrintName();
             Cat cat = new Cat();
             cat.Name = "Tom";
             cat.PrintName();
             Hashiqi erha = new Hashiqi();
             erha.Name = "wangcai";
             erha.PrintName();*/
            Dog dog0 = new Dog("tony");
            Dog dog1 = new Dog("tommy");
            dog0.HowToFeedDog();
            dog1.HowToFeedDog();

            Console.WriteLine("下面输出的是自定义转换的实例调用");
            dog1.Speak();
            Cat cat = dog1;
            cat.Speak();

            Dog.ShowNum();//静态方法调用
            c.HowToFeedCat();
            Console.WriteLine();

            for (int j = 0; j < pets.Length; j++)
            {
                ++pets[j];//这里的 ++ 就是重装运算符，根据定义，pet的年龄加1，返回pet，
                pets[j].ShowAge();
            }
       
        }
    }
}

dog类之前有讲的，你可以回看一下

不同动物的cage的属性不一样，因此类的数据结构就不会一样啊，不一样的话就不能通用一个cage类，每次都需要重新写一个适用不同动物的cage类，你可以写一个cage基本类，包含了他们cage的基本共同属性，但是针对于更加细节的属性就需要继承，因此泛型就有优势了。

之所以会用到default关键字，是因为需要在不知道类型参数为值类型还是引用类型的情况下，为对象实例赋初值。考虑以下代码：

class TestDefault<T>

    {

        public T foo()

        {

            T t = null; //???

            return t;

        }

    }

如果我们用int型来绑定泛型参数，那么T就是int型，那么注释的那一行就变成了 int t = null；显然这是无意义的。为了解决这一问题，引入了default关键字：

class TestDefault<T>

    {

        public T foo()

        {

                return default(T);

        }

   }

https://blog.csdn.net/sndongcheng/article/details/73274386

里面 有解释

if (num > 0)
            {
               return array[num--];
            }

var可以代替任何类型，类似 OBJECT，但是效率比OBJECT高点。

这个就看你干什么用了 ,  抽象类必须是要在继承它的派生类中去实现方法. 泛型类不需要啊

角标越界

dog的类型是TakeOut()函数返回的类型，如果返回的是数组就可以储存多个值，

dog可以调用Dog类的PrintName()，是因为dog被动态定义为了Dog类（TakeOut()函数返回了Dog类）

取出的那只汪当然是dog类，dog类里面有重写pet类的printname()函数

返回T的默认类型，这里T是引用类型（类），则返回默认值null。

详情参见：https://docs.microsoft.com/zh-cn/dotnet/csharp/programming-guide/statements-expressions-operators/default-value-expressions

默认返回值