字典Dictionary<Tkey,Tvalue>

字典容器存储的是一系列的键值对，每个值对应一个唯一的键。

键的意义在于我们可以通过键相对高效的访问到底。

字典操作：

数量  Count

添加  Add(key,value)

删除  Remove

访问  [key]

栈：先进后出，后进先出

出栈  Pop

入栈  Push

获取栈顶元素  Peek

队列：先进先出

出队  Dequeue

入队  Enqueue

集合：一种存放多个数据的容器类型。

最简单的 集合：数组Array（完整的类型是System.Array）

预定义常用集合：

动态数组：ArrayList

列表：List

字典：Dictionary

队列：Queue

栈：Stack

动态数组ArrayList：

优点：

1、初始化，可以不指定大小；

2、获取长度，使用Count属性；

3、添加Add；

4、删除Remove（根据对象），RemoveAt（根据索引）；

5、访问 [index]。

缺点：

1、比数组耗费更多的内存；

2、存取速度不如数组那么快；

3、Object装箱、拆箱，性能损耗。

List<T>

不会有装箱拆箱的性能问题，但是存取速度较慢。

泛型接口：泛型接口允许我们将接口成员的参数和返回类型设置为泛型参数的接口。

语法：

interface IMyself<T>

{

T Myself(T self);  //泛型参数可以出现在泛型成员的定义当中，可以出现在参数位置，也可以出现在返回值位置，可以接一个泛型参数，也可以接多个泛型参数

}  //和反省语法类似

实现泛型接口语法：

class A: Imyself<A>

{

public A Myself(A self);  //泛型参数可以是实现类本身或者是其他类型

}

class A<T>: IMyself<T>

约束：缩小泛型参数的范围。

只有添加了约束，才能调用泛型参数中（比如T）的方法。

约束的类型：

类名，改类或者继承改类的类；

class，任何类；

struct，任何值；

接口名，该接口类型或任何实现该接口的类型；

new()，带有无参共有构造函数的类。

约束叠加规则：

A、主约束，类名，class，struct，只能由1个；

B、接口约束，任意多个；

C、构造约束。

三个约束可以三个都有，也可以一个都没有。

使用where来进行约束。

void Cage<T> where T:Pet,IClimbTree,new()

{...}

1、什么是泛型方法：就是方法的模型，给定具体的类型，就可以实例化出一个操作该类型的具体方法。 注意：泛型类中可以有泛型方法，普通类中也可以有泛型方法。 2、泛型方法语法 class Dog{ void DogIsHappy<T>(T target){//普通类中的泛型方法 ··· } } 实例 public void isHappy<T>(T target) { Console.Write("happy"+target.ToString()) } class Person{} ... var dog=new Dog("A"); dog.isHappy<Person>(new Person()); dog.isHappy<int>(3); 一个类的实例对象就相当于这个类类型的值； 比如 int 4；4是int类型的值；   Person new person() ;new person()是Person类型的值或实例； 其实就相当于创建一个Person类，然后Person person=new Person();  person 就是Person的一个类型值

泛型类：就是一个模子，装入类型的材料，可以塑造出想要的产品。

语法：

class Cage<T>

{

T[] petsArray;

public void PutIn(T pet)  //方法 （放入）

{.....}

public T TakeOut(int index) // 方法 （取出）

{....}

}

说明：T为占位符。类型：为类类型。

为什么需要泛型：

    用基类或者公共的接口，甚至是所有类的基类object，也可以实现一个Cage类，但是类型太宽泛，需要显示转换类型，并且判断真实类型是什么。

泛型实例化：

class Cage<T>{.....} //泛型类声明

Cage<Dog>dogCage; //类型的引用

dogCage=new Cage<Dog>(); //构造实例

重载运算符：

    利用现有的某种运算符，针对自定义类或者结构，定义某种运算操作。

为什么要重载运算符：

    利用现有运算符，简化自定义类型的操作。最好是，该运算符和该操作，具有一定以相关性。

语法：

public static Dog operator+(Dog male,Dog female)

{

....

return new Dog();

}

说明：Dog为返回值，重载加法（+）运算符。

重载运算符不能做什么：

1）创造新运算符

2）改变运算符语法

3）重定义运算符如何处理预定义类型（如：+等于-）

4）改变运算符的优先级和结合性

自定义转换：

为自己的结构或者类定义显式或隐式转换，为了让结构或者类可以变成一个预期相关的类型，并且使这种转换更加简单。

public static explicit（显式）/ implicit（隐式） operator 没有函数名称

显式需要用到括号强制转换。

装箱：根据值类型的值，在堆上创建一个完整的引用类型对象，并返回对象的引用，是一种隐式转换

就是将值类型转换为引用类型

有时候需要将值类型转化为引用类型来进行统一的操作和统一的存储

装箱示例：

int i=3；//这个是int类型的值类型，值为3

object oi=null；//这个是object的引用，赋值为空

oi=i；//将 i的值3赋值给 oi 的过程就是装箱

这样输出 i 和oi，输出的都是3

只有写了oi=i；输出的值才会相同

其它时候 i 就是 i 的值，oi就是oi的值

装箱本质：

在堆上创建了引用类型的副本，新创建的引用类型和原来的值类型相互独立

拆箱：

将装箱后的对象转换回值类型的过程，是一种显示转换

int i=3；

object oi=i；

int j=（int）oi；//把oi这个引用类型的对象通过一个强制的显示转换（int），转换为

我们想要的值类型

输出 j 的值就为3

静态类：

1、如果类只包含了静态的方法和属性，并且标识为static；

2、静态类不能创建实例，不能被继承；；

3、可以为静态类定义一个静态构造函数。

静态类主要用于基础类库（如数学库（Math类））和扩展方法。

总结扩展要求：

1、扩展方法所属的类，必须是static类

2、扩展方法本身必须是static方法

3、扩展方法的第一个参数类型，必须是this+类名

类的静态成员：标识为static的字段、方法、属性、构造函数、事件就是静态成员。

静态函数：

    1）静态函数也独立于任何实例，没有实例也可以调用。

    2）静态函数不能访问实例成员，仅能访问其他静态成员。

静态构造函数：

1）静态构造函数用于初始化静态字段。（为静态成员而生）

2）在引用任何静态成员之前，和创建任何实例之前调用

3）与类同名，使用static，无参数，无访问修饰符

结构和类

不同点：

1、结构是值类型（在栈中），类是引用类型（在堆中）；

2、结构不支持继承，类支持继承；

3、结构不能定义默认构造函数，编译器回定义。

适用场合：

结构：内存分配快，作用域结束即被删除，不需要垃圾回收，用于小型数据结构，传递会赋值，用ref提高效率；

类：用于其他的需要继承体系的场合

一个类只能单继承，继承自一个父类，但是是可以实现多个接口的，但是在写的时候是要按照下面的顺序来写的：继承的父类，实现的接口一，实现的接口二，，，，

virtual开头定义的方法是虚方法，父类里面定义了一个虚方法，然后继承他的子类可以用override重写这个方法，也可以不重写这个方法。

abstract开头定义的属性是抽象属性，abstract开头定义的方法我们称之为抽象方法，抽象方法只有函数声明是没有具体实现的函数体的，然后一个类里面如果有抽象方法或则是抽象属性的话，这个类是必须要声明为抽象类的，即abstract   class A {}；但是一个抽象类里面是可以有或则是没有抽象属性、方法的；

抽象类是可以抽象属性、方法和普通属性、方法共存的；

抽象类不能实例化，只能被继承的，所以一些共性是可以放在一个抽象类里面的。如果一个类继承了抽象类，那么是必须要在子类里面实现他的抽象方法的，要不然该子类也是一个抽象类，不能实例的

接口是一组函数的集合类似于，这些函数默认都是public，并且只有声明没有具体的实现函数体的，接口只能被实现，不能实例化

接口就是指定一组函数成员，而不实现他们的引用类型

interface IcatchMice

{

void CatchMice（）；

}

1. 接口只能用来被实现，就像抽象类只能用来被继承；

1、如果是基类方法不希望子类对其重写，就不声明为virtual

2、如果是派生类不希望其子类（即派生类的派生类）对其进行重写，同时是override重写，就可以使用sealed机制（即同时使用override和sealed）

抽象类

    1、抽象类的存在只有一个目的，就是被继承

    2、抽象类不能实例化，用abstract修饰

    3、抽象类可以包含抽象成员和普通成员，以及他们的任意组合

    4、抽象类的抽象成员在派生类中需要（必须）用override关键字实现

抽象成员：

    1、必须是方法、属性、事件、索引

    2、必须用abstract修饰符标记

    3、不能有实现代码块