在定义的时候需要用var类型【变量的类型是由他赋的值类型决定的】

类的泛：

例如：瓶子，笼子，等工具类，

可以存放任何你想装的东西，是一个存放工具；

1、泛型类就是一个模子，放入类型的材料（字段属性方法），可以塑造出想要的产品。
2、语法
class Cage<T>//这是一个笼子类和泛型类，类名后加上一对<>,加上一个泛型参数
{
T[] petArray;//定义T类型的数组
public void PutIn(T pet){···}//放入T类型的宠物
public T TakeOut(int index){···}//占位符T，cage类变为具体类时，T相应的变成具体数
}
//实例化
var dogCage=new Cage<Dog>();//得到狗狗笼子
var catCage=new Cage<Cat>();//得到猫咪笼子
3、为什么需要泛型，用基类（包括所有类的基类object）或者公共的接口也可以实现一个Cage类，但是类型太宽泛，需要显示转换类型并判断真是类型是什么。
4、泛型使用：声明一个泛型类->引用泛型->构造实例
class Cage<t>{···}
class Cage<Dog>{···}
dogCage=new Cage<Dog>;

比如不写Petcage<Dog> dog=new Petcage<Dog> ("名字");而用一个从来没见过的 var代替。还有 return default<T>也没解释啥意思
理解：泛型就是在不确定类的参数类型和返回类型时，设置一个变量来代替这个固定的类型。当创建类实例时，在给这个变量赋对应类类型值，这样就可以实现一个类，输出不同类型的值和方法。
不用老师的例子，用一个给数组赋值输出数组的例子更好理解；如设置一个类，构造函数初始化一个数组数组类型为int,有给数组赋值方法和获取数组值的方法，在此注意：数组的类型int和获取数组值的方法的返回值类型都为int，如果实例此类调用方法，实参和返回值类型也必须是int；就此限定死了此类的实例； 如果想要一个设置char类型的实例，还得必须创建一个新的char的类和方法才能实现；这样代码工作量很大；若使用泛型，用变量<T>代替固定类型int或char,这样在实例化的时候，将T赋不同类型（int、double、char）就可以获得想要的返回值类型，从而实现了一个模板，只变一个参数T就能实现相同的功能
上面给出的例子。只需要把所有<T>去掉，后面的T全改为int或char 就能变为普通类了。对比理解非常简单了

泛型类：

语法展示：

class Cage<T>{

    T[] petsArray;

    public void Putln(T pet){//.......}

    public T TackOut(int idnex){//.....}

}

T:就是指外部传进来的具体类型。

而T[]就是外部传进来的具体类型，

T方法中的T就是一个占位符。

为什么需要泛型类？

1. 大大减少了工作量。

定义泛型类：

class Cage<T>{...}

使用|实例化

Cage<Dog>dog=new Cage<Dog>();

用基类或者公共的接口，类型太宽泛，需要显示转换类型，并且判断真实类型是什么。

泛型实例化的步骤：泛型类的声明，类型的引用，构造实例。

C#

泛型类的语法

泛型类就是模板类

使用泛型的方法

泛型类就是一个模子，语法：class Cage<T>{。。。}其中T是某种类 

泛型类的使用

为什么需要泛型类

泛型类的语法

什么是泛型类

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

语法：

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>(); //构造实例

泛型类就是相当于一个模板，然后我去给这个模板传递什么参数值然后会根据我传递的这个值去生产出来个性化的东西

然后泛型类定义的方法是：/T是一中类型，可能是猫啊狗啊的。然后根据这个传递的类型，其实有点类似于实参，然后我们去创建出不哦她那个的对象来进行处理，可以减少编写重复的代码

class A <T>{ 

 T[]petsArray;

public void PutIn(t PET){...}

public T TakeOut(int index){.......}

}

实例化语句：

A<Dog> dog;  //A<Dog>类型的引用

dog=new A<Dog>();//构造实例

var cat=new A<Cat>();

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

泛型类优势：

1、代码量小，无论多少种笼子，我们之需要一个实现；

2、只有需要的类型才会被实例化；

3、易于维护，修改模板，所有的实例都将改变。

泛型类优势：

1）代码量更小，无论多少种笼子，我们只需要一个实现

2）只有需要的类型才会被实例化

3）易于维护，修改模板，所有的实例都将改变

为什么需要泛型：

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

泛型实例化：

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

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

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

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

语法：

class Cage<T>

{

T[] petsArray;

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

{.....}

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

{....}

}

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

泛型类：模子

class Cage<T>   // T，占位符，类类型参数

{

}  //声明

Cage<Dog> dogCage;  //引用

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

var dogCage = new Cage<Dog>();

为什么需要泛型：

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

只有需要的类型才会被实例化。

var：

C# 中的var关键字

var 是3.5新出的一个定义变量的类型 其实也就是弱化类型的定义 VAR可代替任何类型 编译器会根据上下文来判断你到底是想用什么类型的 至于什么情况下用到VAR 我想就是你无法确定自己将用的是什么类型 就可以使用VAR 类似 OBJECT 但是效率比OBJECT高点。

或者通俗的讲：

  var可以理解为匿名类型，我们可以认为它是一个声明变量的占位符。它主要用于在声明变量时，无法确定数据类型时使用。

使用var定义变量时有以下四个特点:

1. 必须在定义时初始化。也就是必须是var s = “abcd”形式，而不能是如下形式: var s; s = “abcd”;

2. 一但初始化完成，就不能再给变量赋与初始化值类型不同的值了。

3. var要求是局部变量。

4. 使用var定义变量和object不同，它在效率上和使用强类型方式定义变量完全一样。

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

语法：

class Cage<T>//<T>里面的T是类类型参数，（T是一个类型），然后得到专属的这个Cage泛型类，就是把我们这个具体的类T，注入到泛型类Cage，就会得到具体的类型

{

T[]petsArray;

public void PutIn(T pet){...}

public T TakeOut(int index){...}

}

使用时：也就是实例化

var dogCage=new Cage<Dog>();

var cavyCage=new Cage<Cavy>();

1.泛型类：装载同类型类的容器，实例化泛型类后依靠泛型类内中的方法连续处理相同类型的类

class A<T>{}   //泛型类

class B{}   //B类

A a =new A<B>()  //实例化传入类B

2.泛型方法，可以在泛型类中也可以是普通类

public void print<T>(T t){ 

    return defualt(T);    //返回传入的类的写法

}  //传入t可以是类也可以是数据

3.加入约束可以规定泛型类或泛型方法的传入值类型,解决2的问题

class A<T> where T:······{} 

public void print<T>(T t)  where T:······{}     // ······可以是a.具体类名[本类以及派生类]，class[所有类都可以]，struct[所有结构都可以];  b.具体接口名或泛型接口[本接口以及实现该接口的类型];   c.     new( ) [带有无参数并且共有的构造函数的相关类型，好像是让泛型类实例化后可以调用传入类的构造函数]。注意：同时有约束多个，必须是主约束只一个【a的三个只能有一个】，再来是若干个接口约束【可以多个接口】，构造约束的顺序。

4.泛型接口，格式和泛型类大致相同，注意接口和类本身的不同就行

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

class Cage<T>{

    T[] petsArray;

    public void PutIn(T pet){……}

    public T TakeOut(int index){……}

}

为什么需要泛型

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

优势

1. 代码量更小，无论多少种笼子，我们只需要一个实现

2. 只有需要的类型才会被实例化

3. 易于维护，修改模板，所有的实例都将改变

   
   

为什么需要泛型类

1、泛型类就是一个模子，放入类型的材料（字段属性方法），可以塑造出想要的产品。 

2、语法 class Cage<T>//这是一个笼子类和泛型类，类名后加上一对<>,加上一个泛型参数 { T[] petArray;//定义T类型的数组 public void PutIn(T pet){···}//放入T类型的宠物

T为类类型参数，

泛型类的优点