// See https://aka.ms/new-console-template for more information
using System;
namespace HelloWorldApplication
{
    /*
     *  虛方法：
     *      聲明為virtral的就是虛方法立镶⊥徽眨基類的虛方法可以在派生類中使用override進行重寫搜锰。
     *      重寫虛方法必須具有相同的可訪問性呀非，且基類方法不能是private
     *      不能重寫static方法或非虛方法
     *      方法泪喊，屬性蝇刀，索引器譬淳，事件募舟，都可以聲明為virtral或override
     *      
     *  多態(tài)：
     *      通過指向派生類的基類調(diào)用祠斧，調(diào)用虛方法，會根據(jù)引用所指向派生類的實際類型拱礁，調(diào)用派生類中同名重寫的函數(shù)琢锋，即是多態(tài)。
     *  
     *  抽象方法：
     *      必須是方法呢灶，屬性吴超，事件，索引
     *      必須用abstract修飾符標(biāo)記
     *      不能有實現(xiàn)代碼塊
     *      
     *  抽象類：
     *      抽象類的存在目的是被繼承
     *      不能實例化鸯乃，用abstract修飾
     *      可以包含抽象成員和普通成員鲸阻，以及任意組合
     *      抽象類的抽象成員在派生類中需要用override關(guān)鍵字實現(xiàn)
     *      
     *  密閉類：
     *      聲明為sealed的類
     *      有些類不希望被其他人通過繼承來修改
     *  
     *  密閉方法：
     *      聲明為sealed的方法
     *      不希望其他人來重寫該方法
     *      如果一個基類方法不希望子類對其重寫，就可以不聲明為virtual
     *      如果是某個派生類方法不希望子類對其重寫缨睡，同時是override重寫,就可以使用sealed機制
     *      
     *  接口：
     *      指定一組函數(shù)成員鸟悴，而不實現(xiàn)他們的引用類型
     *      定義接口不能寫public，但默認(rèn)是public類型
     *      
     *  結(jié)構(gòu)和類：
     *      結(jié)構(gòu)是值類型（棧中）奖年，類是引用類型（堆中）
     *      結(jié)構(gòu)不支持繼承细诸，類支持繼承
     *      結(jié)構(gòu)不能定義默認(rèn)構(gòu)造函數(shù)，編譯器會定義
     *  適用場合：
     *      結(jié)構(gòu)：由于分配內(nèi)存快陋守，作用域結(jié)束即被刪除震贵，不需要垃圾回收機制利赋，用于小型數(shù)據(jù)結(jié)構(gòu)。
     *          但傳遞過程中會復(fù)制屏歹，應(yīng)該使用ref提高效率隐砸。
     *      類：用于其他的需要繼承體系的場合
     *      
     *  靜態(tài)成員：標(biāo)識為static的字段，方法蝙眶，屬性季希，構(gòu)造函數(shù)，事件幽纷。
     *      被類的所有實例共享式塌，所有實例訪問同一個內(nèi)存地址
     *  生存期：獨立于任何實例，沒有實例也可以訪問友浸。
     *      其初始化語句在任何靜態(tài)成員使用之前調(diào)用
     *      
     *  靜態(tài)函數(shù)成員：
     *      獨立于任何實例峰尝，沒有實例也可以調(diào)用
     *      不能訪問實例成員，只能訪問其他靜態(tài)成員
     *      
     *  靜態(tài)構(gòu)造函數(shù)：
     *      可用于初始化靜態(tài)字段
     *      在引用任何靜態(tài)成員之前收恢，和創(chuàng)建任何實例之前調(diào)用
     *      與類同名武学，使用static，無參數(shù)伦意，無訪問修飾符
     *      
     *  靜態(tài)類：
     *      類只包含了靜態(tài)的方法和屬性火窒，并標(biāo)識為static
     *      不能創(chuàng)建實例，不能被繼承
     *      可以為靜態(tài)類定義一個靜態(tài)構(gòu)造函數(shù)
     *      用于基礎(chǔ)類庫（如數(shù)學(xué)庫）或擴展方法
     *      
     *  擴展方法的要求
     *      擴展方法所屬的類必須是static類
     *      擴展方法本身必須是static方法
     *      擴展方法的第一個參數(shù)類型驮肉，必須是this+類名
     *      
     *  裝箱：淺拷貝
     *      根據(jù)值類型的值熏矿，在堆上創(chuàng)建一個完整的引用類型對象，并返回對象的引用离钝，是一種隱式轉(zhuǎn)換
     *      有時候需要將值類型轉(zhuǎn)化為引用類型（例如object)來進行統(tǒng)一的操作（例如作為函數(shù)的參數(shù)）和統(tǒng)一的存儲（例object[])
     *      在堆上創(chuàng)建引用類型的副本票编，新創(chuàng)建的引用類型和原本的值類型相互獨立
     *      
     *  拆箱：
     *      將裝箱后的對象轉(zhuǎn)換成值類型的過程，是一種顯示轉(zhuǎn)換
     *      
     *  自定義轉(zhuǎn)換：
     *      為自己的結(jié)構(gòu)或類定義顯示和隱式轉(zhuǎn)換
     *  隱式轉(zhuǎn)換：public static implicit operator Dog(Cat cat) 目標(biāo)類型（原類型）
     *  顯示轉(zhuǎn)換：public static explicit operatir Dog(Cat cat)
     *  
     *  重載運算符：
     *      利用現(xiàn)有的某種運算符卵渴，針對自定義類或結(jié)構(gòu)慧域，定義某種運算符
     *      
     *  泛型類：class Cage<T>
     *      就是一個模子，裝入類型的材料奖恰，可以塑造想要的產(chǎn)品
     *      易于維護吊趾，修改模板，所有的實例都會被改變
     *      只有需要的類型才會被實例化
     *      
     *  泛型方法：
     *      就是方法的模型瑟啃，給定具體的類型论泛，就可以實例化出一個操作該類型的具體方法
     *   
     *  泛型接口：
     *      允許我們將接口成員的參數(shù)和返回類型設(shè)置成為泛型參數(shù)的接口
     *      
     *  約束：
     *      縮小泛型參數(shù)的范圍
     *      只有添加了約束，才能調(diào)用泛型參數(shù)中(比如T)的方法
     *      
     *  集合：
     *      動態(tài)數(shù)組：ArrayList  列表：List   字典：Dictionary    
     *      隊列：Queue    棧：Stack
     *      
     *  動態(tài)數(shù)組 ArrayList：
     *      初始化可以不指定大小
     *      獲取長度蛹屿，使用Count屬性
     *      添加Add屁奏，刪除Remove,RemoveAt，訪問[index]
     *      類型不安全错负，有裝箱拆箱的性能問題坟瓢，于是出現(xiàn)了List<T>
     *     
     *  字典 Dictionary<Tkey,Tvalue>：
     *      存儲的是一系列的鍵值對
     *      數(shù)量 Count    添加 Add(key,value)   刪除 Remove   訪問 [key]
     *      
     *  棧 Stack：
     *      出棧 Pop    入棧 Push     獲取棧頂元素 Peek
     *      
     *  隊列 Queue：
     *      出隊 Dequeue      入隊 enqueue
     *      
     *  委托：
     *      持有一個或者多個方法的對象勇边，并且該方法可以執(zhí)行，傳遞
     *      
     *  聲明委托方法：
     *      可以聲明折联，是一種引用類型    delegate void ActCute();
     *      
     *  Lambda 表達式
     *      del = delegate(){} del = ()=>{}
     *      
     *  事件：
     *  發(fā)布者：通知事件發(fā)生的
     *  訂閱者：對某件事情關(guān)注的
     *  事件觸發(fā)：事件發(fā)生時粒褒，會通知所有關(guān)注該事件的訂閱者
     *  注冊：想要在事件發(fā)生時被通知，必須注冊以表示關(guān)注
     */
    /*
    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("籠子已經(jīng)裝滿了...");
            }
        }
        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 + "只狗");
        }

        // 隱式轉(zhuǎn)換
        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("喂養(yǎng)一條狗");
        }
    }

    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("小白貓");
            // 強制轉(zhuǎn)換
            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();
            */
        }
    }
}

運行結(jié)果

d1搖尾巴
C1看著你
Lambda表達式
小狗在說話：汪汪
小狗年齡是：1
小貓在說話：喵喵
小貓年齡是：1
小白狗在說話：汪汪
小白狗年齡是：1
小白貓在抓老鼠
小白貓在抓老鼠
小白貓在爬樹
小白貓在爬樹
一共有3只狗
喂養(yǎng)一條狗
i=3 ob=3
i=5 ob=6
j=6
比格在說話：汪汪
比格在說話：喵喵
寵物的名字是：比格
比格在說話：汪汪
籠子已經(jīng)裝滿了...
狗的名字是：小狗一號
很開心看到
寵物的名字是：英短
坐下
狗的名字是：小黑
狗的名字是：小白
狗的名字是：A1
寵物的名字是：b
寵物的名字是：q1
有一條新的狗...
有一條新的狗...