// See https://aka.ms/new-console-template for more information
using System;
namespace HelloWorldApplication
{
    /*
     *  虚方法：
     *      声明为virtral的就是虚方法。基类的虚方法可以在派生类中使用override进行重写。
     *      重写虚方法必须具有相同的可访问性，且基类方法不能是private
     *      不能重写static方法或非虚方法
     *      方法，属性，索引器，事件，都可以声明为virtral或override
     *      
     *  多态：
     *      通过指向派生类的基类调用，调用虚方法，会根据引用所指向派生类的实际类型，调用派生类中同名重写的函数，即是多态。
     *  
     *  抽象方法：
     *      必须是方法，属性，事件，索引
     *      必须用abstract修饰符标记
     *      不能有实现代码块
     *      
     *  抽象类：
     *      抽象类的存在目的是被继承
     *      不能实例化，用abstract修饰
     *      可以包含抽象成员和普通成员，以及任意组合
     *      抽象类的抽象成员在派生类中需要用override关键字实现
     *      
     *  密闭类：
     *      声明为sealed的类
     *      有些类不希望被其他人通过继承来修改
     *  
     *  密闭方法：
     *      声明为sealed的方法
     *      不希望其他人来重写该方法
     *      如果一个基类方法不希望子类对其重写，就可以不声明为virtual
     *      如果是某个派生类方法不希望子类对其重写，同时是override重写,就可以使用sealed机制
     *      
     *  接口：
     *      指定一组函数成员，而不实现他们的引用类型
     *      定义接口不能写public，但默认是public类型
     *      
     *  结构和类：
     *      结构是值类型（栈中），类是引用类型（堆中）
     *      结构不支持继承，类支持继承
     *      结构不能定义默认构造函数，编译器会定义
     *  适用场合：
     *      结构：由于分配内存快，作用域结束即被删除，不需要垃圾回收机制，用于小型数据结构。
     *          但传递过程中会复制，应该使用ref提高效率。
     *      类：用于其他的需要继承体系的场合
     *      
     *  静态成员：标识为static的字段，方法，属性，构造函数，事件。
     *      被类的所有实例共享，所有实例访问同一个内存地址
     *  生存期：独立于任何实例，没有实例也可以访问。
     *      其初始化语句在任何静态成员使用之前调用
     *      
     *  静态函数成员：
     *      独立于任何实例，没有实例也可以调用
     *      不能访问实例成员，只能访问其他静态成员
     *      
     *  静态构造函数：
     *      可用于初始化静态字段
     *      在引用任何静态成员之前，和创建任何实例之前调用
     *      与类同名，使用static，无参数，无访问修饰符
     *      
     *  静态类：
     *      类只包含了静态的方法和属性，并标识为static
     *      不能创建实例，不能被继承
     *      可以为静态类定义一个静态构造函数
     *      用于基础类库（如数学库）或扩展方法
     *      
     *  扩展方法的要求
     *      扩展方法所属的类必须是static类
     *      扩展方法本身必须是static方法
     *      扩展方法的第一个参数类型，必须是this+类名
     *      
     *  装箱：浅拷贝
     *      根据值类型的值，在堆上创建一个完整的引用类型对象，并返回对象的引用，是一种隐式转换
     *      有时候需要将值类型转化为引用类型（例如object)来进行统一的操作（例如作为函数的参数）和统一的存储（例object[])
     *      在堆上创建引用类型的副本，新创建的引用类型和原本的值类型相互独立
     *      
     *  拆箱：
     *      将装箱后的对象转换成值类型的过程，是一种显示转换
     *      
     *  自定义转换：
     *      为自己的结构或类定义显示和隐式转换
     *  隐式转换：public static implicit operator Dog(Cat cat) 目标类型（原类型）
     *  显示转换：public static explicit operatir Dog(Cat cat)
     *  
     *  重载运算符：
     *      利用现有的某种运算符，针对自定义类或结构，定义某种运算符
     *      
     *  泛型类：class Cage<T>
     *      就是一个模子，装入类型的材料，可以塑造想要的产品
     *      易于维护，修改模板，所有的实例都会被改变
     *      只有需要的类型才会被实例化
     *      
     *  泛型方法：
     *      就是方法的模型，给定具体的类型，就可以实例化出一个操作该类型的具体方法
     *   
     *  泛型接口：
     *      允许我们将接口成员的参数和返回类型设置成为泛型参数的接口
     *      
     *  约束：
     *      缩小泛型参数的范围
     *      只有添加了约束，才能调用泛型参数中(比如T)的方法
     *      
     *  集合：
     *      动态数组：ArrayList  列表：List   字典：Dictionary    
     *      队列：Queue    栈：Stack
     *      
     *  动态数组 ArrayList：
     *      初始化可以不指定大小
     *      获取长度，使用Count属性
     *      添加Add，删除Remove,RemoveAt，访问[index]
     *      类型不安全，有装箱拆箱的性能问题，于是出现了List<T>
     *     
     *  字典 Dictionary<Tkey,Tvalue>：
     *      存储的是一系列的键值对
     *      数量 Count    添加 Add(key,value)   删除 Remove   访问 [key]
     *      
     *  栈 Stack：
     *      出栈 Pop    入栈 Push     获取栈顶元素 Peek
     *      
     *  队列 Queue：
     *      出队 Dequeue      入队 enqueue
     *      
     *  委托：
     *      持有一个或者多个方法的对象，并且该方法可以执行，传递
     *      
     *  声明委托方法：
     *      可以声明，是一种引用类型    delegate void ActCute();
     *      
     *  Lambda 表达式
     *      del = delegate(){} del = ()=>{}
     *      
     *  事件：
     *  发布者：通知事件发生的
     *  订阅者：对某件事情关注的
     *  事件触发：事件发生时，会通知所有关注该事件的订阅者
     *  注册：想要在事件发生时被通知，必须注册以表示关注
     */
    /*
    struct fish
    {
        int weight;
        int size;
        int type;
    }
    */
    interface ICatchMice
    {
        void CatchMice();
    }

    interface ICimbTree
    {
        void CimbTree();
    }
    abstract public class Pet
    {   
        public Pet(string name)
        {
            _name = name;
            _age = 0;
        }
        // 受保护 让派生类可以访问
        protected string _name;
        protected int _age;
        public void PrintName()
        {
            Console.WriteLine("宠物的名字是："+_name);
        }
        abstract public void Speak();

        public void ShowAge()
        {
            Console.WriteLine(_name + "年龄是："+ _age);
        }
        public static Pet operator ++(Pet pet)
        {
            ++pet._age;
            return pet;
        }
    }
    public class Cage<T>
    {
        T[] array;
        readonly int Size;
        int num;
        public Cage(int n)
        {
            Size = n;
            array = new T[Size];
            num = 0;    
        }

        public void Putin(T pet)
        {
            if (num < Size)
            {
                array[num++] = pet;
            }
            else
            {
                Console.WriteLine("笼子已经装满了...");
            }
        }
        public T TakeOut()
        {
            if (num > 0)
            {
                return array[--num];
            }
            else
            {
                Console.WriteLine("笼子是空的...");
                return default(T);
            }
        }
    }
    public class Dog : Pet 
    {
        static int Num;
        // 委托
        public delegate void Hander();
        // 事件
        public static event Hander NewDog;
        static Dog()
        {
            Num = 0;
        }
        public Dog(string name) : base(name)
        {
            ++Num;
            if (NewDog != null)
            {
                NewDog();
            }
        }
        // 隐藏基类方法
        new public void PrintName()
        {
            Console.WriteLine("狗的名字是：" + _name);
        }
        sealed override public void Speak()
        {
            Console.WriteLine(_name + "在说话：汪汪");
        }
        static public void ShowNum()
        {
            Console.WriteLine("一共有" + Num + "只狗");
        }

        // 隐式转换
        public static implicit operator Cat(Dog dog)
        {
            return new Cat(dog._name);
        }

        // 泛型方法
        public void IsHappy<T>(T target) where T : Pet
        {
            Console.WriteLine("很开心看到");
            target.PrintName();
        }

        public void WagTail()
        {
            Console.WriteLine(_name + "摇尾巴");
        }
    }

    public abstract class DogCmd
    {
        public abstract string GetCmd();   
    }
    public class SitDogCmd : DogCmd
    {
        public override string GetCmd()
        {
            return "坐下";
        }
    }
    public interface IDogLearn <C> where C : DogCmd
    {
        void Act(C cmd);
    }
    public class Labrador : Dog, IDogLearn<SitDogCmd>
    {
        public Labrador(string name):base(name)
        {
        }
        public void Act(SitDogCmd cmd)
        {
            Console.WriteLine(cmd.GetCmd());
        }
    }

    static class PetGuide
    {
        static public void HowToFeedDog(this Dog dog)
        {
            Console.WriteLine("喂养一条狗");
        }
    }

    public class Cat : Pet, ICatchMice, ICimbTree
    {
        public Cat(string name) : base (name)
        {
        }
        public override void Speak()
        {
            Console.WriteLine(_name + "在说话：喵喵");
        }

        public void CatchMice()
        {
            Console.WriteLine(_name + "在抓老鼠");
        }
        public void CimbTree()
        {
            Console.WriteLine(_name + "在爬树");
        }
        public static explicit operator Dog(Cat cat)
        {
            return new Dog(cat._name);
        }

        public void InnocentLook()
        {
            Console.WriteLine(_name + "看着你");
        }
    }
    class Person
    {

    }
    class Client
    {
        public void WantDog()
        {
            Console.WriteLine("有一条新的狗...");
        }
    }
    class HelloWorld
    {
        // 委托
        delegate void ActCute();
        static void Main(string[] args)
        {
            ActCute del = null;
            Dog d1 = new Dog("d1");
            Cat c1 = new Cat("C1");
            del = d1.WagTail;
            del += c1.InnocentLook;
            del += () =>
            {
                Console.WriteLine("Lambda表达式");
            };
            del();

            Pet[] pets = new Pet[] {new Dog("小狗"),new Cat("小猫"),new Dog("小白狗")};
            for(int k=0;k<pets.Length;k++)
            {
                pets[k].Speak();
                ++pets[k];
                pets[k].ShowAge();
            }

            Cat c = new Cat("小白猫");
            // 强制转换
            ICatchMice catchM = (ICatchMice)c;
            c.CatchMice();
            catchM.CatchMice();
            ICimbTree cimbT = (ICimbTree)c;
            c.CimbTree();
            cimbT.CimbTree();
            Dog.ShowNum();

            Dog dog = new Dog("大狗");
            dog.HowToFeedDog();

            int i = 3;
            object ob = i;
            Console.WriteLine("i=" + i + " ob=" + ob.ToString());
            i = 5;
            ob = 6;
            Console.WriteLine("i=" + i + " ob=" + ob.ToString());
            int j = (int)ob;
            Console.WriteLine("j=" + j);

            Dog dog1 = new Dog("比格");
            dog1.Speak();
            Cat cat = dog1;
            cat.Speak();
            cat.PrintName();

            Dog dog2 = (Dog)cat;
            dog2.Speak();

            var dogCage = new Cage<Dog>(1);
            dogCage.Putin(new Dog("小狗一号"));
            dogCage.Putin(new Dog("小狗二号"));

            var dogC = dogCage.TakeOut();
            dogC.PrintName();

            Dog dog3 = new Dog("哈士奇");
            //dog3.IsHappy<int>(2);
            dog3.IsHappy<Cat>(new Cat("英短"));

            Labrador labrador = new Labrador("拉不拉多");
            labrador.Act(new SitDogCmd());

            List<Dog> list = new List<Dog>();
            list.Add(new Dog("小黑"));
            list.Add(new Dog("小花"));
            list.Add(new Dog("小白"));
            list.RemoveAt(1);
            for (int p = 0; p < list.Count; p++)
            {
                list[p].PrintName();
            }

            Dictionary<string, Dog> dic = new Dictionary<string, Dog>();
            dic.Add("A",new Dog("A1"));
            dic["A"].PrintName();

            Stack<Pet> st = new Stack<Pet>();
            st.Push(new Dog("a"));
            st.Push(new Dog("b"));
            st.Peek().PrintName();

            Queue<Pet> qu = new Queue<Pet>();
            qu.Enqueue(new Dog("q1"));
            qu.Enqueue(new Dog("q2"));
            Pet pe = null;
            pe = qu.Dequeue();
            pe.PrintName();


            Client cl1 = new Client();
            Client cl2 = new Client();
            Dog.NewDog += cl1.WantDog;
            Dog.NewDog += cl2.WantDog;
            Dog dogs = new Dog("大狗");

            /*
            Pet dog = new Dog();
            dog._name = "小狗";
            dog.PrintName();
            dog.Speak();
            Pet cat = new Cat();
            cat._name = "小猫";
            cat.PrintName();
            cat.Speak();
            */
        }
    }
}

运行结果

d1摇尾巴
C1看着你
Lambda表达式
小狗在说话：汪汪
小狗年龄是：1
小猫在说话：喵喵
小猫年龄是：1
小白狗在说话：汪汪
小白狗年龄是：1
小白猫在抓老鼠
小白猫在抓老鼠
小白猫在爬树
小白猫在爬树
一共有3只狗
喂养一条狗
i=3 ob=3
i=5 ob=6
j=6
比格在说话：汪汪
比格在说话：喵喵
宠物的名字是：比格
比格在说话：汪汪
笼子已经装满了...
狗的名字是：小狗一号
很开心看到
宠物的名字是：英短
坐下
狗的名字是：小黑
狗的名字是：小白
狗的名字是：A1
宠物的名字是：b
宠物的名字是：q1
有一条新的狗...
有一条新的狗...