C#复习日记（第四部分）泛型跟各种集合

第四部分 稍微梳理一下就是 之前很不懂的泛型知识

首先为什么要用泛型呢，因为他省内存，不用反复写

代码量比较小，只需要一个实现就可以了。
只有在需要的时候才会实例化，
而且！！易于维护，只要修改模板，所有实例都会改变。
（泛型类是一个容器，类的模型）

泛型类：

public class Cage<T>
{
    T[] array;//类型的数组
    readonly int size;//只读的整形大小
    int num;//数量
    public Cage(int n)//构造函数
    {
        size = n;
        num = 0;
        array = new T[size];
    }//这里创造了一个泛型类 笼子cage，这样子之后本来已经有的猫狗就可以直接定义了
    public void PutIn(T pet)//输入数组的方法//T类型
        {
            if(num<size)
            {
                array[num++] = pet;//宠物数量++
            }
            else
            {
                Console.WriteLine("Cage is full");
            }
        }

class Program
    {
        static void Main(string[] args)
        {
           
            var catCage = new Cage<Cat>(3);
            catCage.PutIn(new Cat("A"));
            catCage.PutIn(new Cat("b"));
            catCage.PutIn(new Cat("c"));

            var cat = catCage.TakeOut();
            cat.printName();
        }//在这里 直接就定义了一个cage的cat，然后只需要用设置好的putin函数直接调入
    }

泛型方法：就是方法的模型

  public void ishappy<T>(T target)
        {
            Console.WriteLine("happy");
        }//先是在Cat类中定义了这个泛型方法

然后紧接着在主程序中实现了他的

//泛型方法
cat.ishappy<Person>(new Person());//不理解
cat.ishappy<int>(10);//不理解,看见10很开心？？？？/

但是我没有很理解，为什么int 10之后，什么都不用识别，就可以直接在输出中直接执行呢？
不需要条件判断吗？直接输入参数就可以输出函数了吗？
//因为这个泛型方法本身没有条件判断，无论是多少都会直接输出。

泛型方法 约束，
其中类名，class，struct只能约束一个，
接口则可以无限多约束，
new（）；

 public void isnothappy<T>(T target) where T:Pet
        {//另外一个泛型方法，其中加了个约束，所有将只能用pet或者其派生的类
            Console.WriteLine("nothappy bacuse");
            target.printName();
           
        }

泛型接口，没有学懂。

最后一个部分的内容，各种集合。
其中数组array是最基础的用法，【】
其他的分别是
0.数组

 Pet[] pets = new Pet[] { new Dog("狗"), new Cat("猫") };

            for(int i=0;i<pets.Length;++i)
            { 
                pets[0].printName();
            }
            Dog.ShowNum();

1.动态数组：（小叶昨晚刚刚跟我讲）
因为其不用在一开始定义的时候就定好大小，他可以随意补充大小。
而且其内置有函数，获取数组长度（count），增加add，remoe，访问

 //动态数组
            List<Dog> dogs = new List<Dog>();
            dogs.Add(new Dog("1"));
            dogs.Add(new Dog("2"));
            dogs.Add(new Dog("3"));
            dogs.RemoveAt(0);
            for (int i = 0; i < dogs.Count; i++)
            {
               dogs[i].printName();
            }

2.字典类型：Dictionary< T key，T value>
主要的好处是，可以自己定义key索引，搜索方便。

//字典类型
            Dictionary<string, Dog> dic = new Dictionary<string, Dog>();
            dic.Add("sb", new Dog("A"));
            dic["sb"].printName();

3.栈（先进后出，后进先出）

其中的（指令）有，
出栈，pop，
入栈，push，
获取顶端元素，，peek

//栈
            Stack<Dog> stack = new Stack<Dog>();
            stack.Push(new Dog("GU"));
            stack.Push(new Dog("GU2"));

            stack.Peek().printName();
            stack.Pop();
            stack.Peek().printName();

4.队列，先进先出
出队 Dequeue
入队 Eequque

//队列
            Queue<Pet> queue = new Queue<Pet>();
            queue.Enqueue(new Dog("P"));
            queue.Enqueue(new Cat("O"));

            //下面这步是为什么
            Pet pet = null;
           // Pet pet = queue.Dequeue应该这么写，出来到这里
            pet = queue.Dequeue();
            pet.printName();
            pet = queue.Dequeue();
            pet.printName();
            //依次出队

其中三四的栈跟队列之中都有一个特点，就是所有在使用的使用的时候，都需要先让他们导出来，才能使用，根据我现在的知识，队列还需要多一个位置来存放他。

最后一个 内容 委托
delegate 没学会

Lambda表达式

事件的触发和注册，
发布者跟订阅者。