当前位置：文档之家 › 泛型基础知识

泛型基础知识

  • 格式：pdf
  • 大小：131.04 KB
  • 文档页数：6

下载文档原格式

  / 6

合集下载

关于泛型的基本概念

关于泛型的基本概念

泛型的基本概念1. 概念定义泛型是一种编程语言的特性，它允许在定义类、接口和方法时使用类型参数。

通过使用泛型，我们可以创建具有通用性的代码，使其能够适用于不同类型的数据。

在Java中，泛型可以应用于类、接口和方法。

通过使用泛型，我们可以实现代码的重用性、类型安全性和灵活性。

2. 重要性2.1 代码重用性使用泛型可以创建通用的数据结构和算法，使其能够适用于不同类型的数据。

这样一来，我们就无需为每种数据类型编写单独的代码，从而提高了代码的重用性。

例如，在Java中，我们可以使用泛型来实现一个通用的列表类（List），该列表类可以存储任意类型的元素。

通过使用泛型，我们只需编写一次列表类的实现代码，并且可以在不同场景下复用该实现。

2.2 类型安全性使用泛型可以在编译时捕获并解决类型错误。

通过指定参数化类型，在编译时会进行类型检查，并确保代码中只能操作正确类型的数据。

例如，在Java中，如果我们定义了一个只接收整数作为参数并返回整数结果的方法，并且尝试将字符串传递给该方法，编译器将会报错。

这样一来，我们可以在编译阶段就发现类型错误，避免在运行时出现异常。

2.3 灵活性使用泛型可以使代码更加灵活，能够适应不同的数据类型和需求。

通过使用泛型，我们可以在定义类、接口和方法时延迟指定具体的类型参数。

这样一来，我们可以根据实际情况，在不同的场景下使用不同的类型。

例如，在Java中，我们可以定义一个泛型方法来获取数组中的最大值。

通过使用泛型，我们可以在调用该方法时传递不同类型的数组，并且得到相应类型的最大值。

3. 应用泛型广泛应用于各种编程场景中。

以下是几个常见的应用领域：3.1 容器类容器类是最常见的泛型应用之一。

通过使用泛型，我们可以创建通用的容器类（如列表、集合、队列等），使其能够存储和操作不同类型的数据。

例如，在Java中，ArrayList是一个通用的动态数组实现。

它使用了泛型参数来指定存储元素的类型。

通过使用ArrayList，我们可以存储任意类型的元素，并且能够对其进行增删改查等操作。

Java泛型总结

Java泛型总结

Java泛型总结1. 什么是泛型？泛型（Generic type 或者generics）是对Java 语言的类型系统的一种扩展，以支持创建可以按类型进行参数化的类。

可以把类型参数看作是使用参数化类型时指定的类型的一个占位符，就像方法的形式参数是运行时传递的值的占位符一样。

可以在集合框架（Collection framework）中看到泛型的动机。

例如，Map 类允许您向一个Map 添加任意类的对象，即使最常见的情况是在给定映射（map）中保存某个特定类型（比如String）的对象。

因为Map.get() 被定义为返回Object，所以一般必须将Map.get() 的结果强制类型转换为期望的类型，如下面的代码所示：Map m = new HashMap();m.put("key", "blarg");String s = (String) m.get("key");要让程序通过编译，必须将get() 的结果强制类型转换为String，并且希望结果真的是一个String。

但是有可能某人已经在该映射中保存了不是String 的东西，这样的话，上面的代码将会抛出ClassCastException。

理想情况下，您可能会得出这样一个观点，即m 是一个Map，它将String 键映射到String 值。

这可以让您消除代码中的强制类型转换，同时获得一个附加的类型检查层，该检查层可以防止有人将错误类型的键或值保存在集合中。

这就是泛型所做的工作。

2. 泛型的好处Java 语言中引入泛型是一个较大的功能增强。

不仅语言、类型系统和编译器有了较大的变化，以支持泛型，而且类库也进行了大翻修，所以许多重要的类，比如集合框架，都已经成为泛型化的了。

这带来了很多好处：类型安全。

泛型的主要目标是提高Java 程序的类型安全。

通过知道使用泛型定义的变量的类型限制，编译器可以在一个高得多的程度上验证类型假设。

ts定义泛型方法 -回复

ts定义泛型方法 -回复

ts定义泛型方法-回复TS定义泛型方法泛型是一种方便且灵活的编程技术，它允许我们在定义函数、类或接口时使用未指定具体类型的参数。

TypeScript（TS）作为一种由微软开发和维护的静态类型脚本语言，提供了强大的泛型支持。

在本文中，我们将深入探讨TS中如何定义泛型方法。

一、泛型方法的基础概念泛型方法是指在定义函数时，利用泛型来代表参数或返回值的具体类型。

它可以适应不同类型的输入，并返回与输入相匹配的结果。

泛型方法使得我们可以编写更加通用的函数，减少了代码的重复性，并提高了代码的可维护性。

二、定义函数的泛型参数在TS中，定义泛型方法的第一步是为函数参数添加泛型标记。

通过在函数名后使用<T>的形式，来声明一个泛型参数T。

例如，我们可以定义一个函数来打印任意类型的数组：typescriptfunction printArray<T>(arr: T[]): void {for (let item of arr) {console.log(item);}}在上面的例子中，我们使用了泛型参数T来表示数组中元素的类型。

这使得我们可以在函数中使用未知的类型。

对于这个泛型函数，我们可以传递任何类型的数组作为参数，并打印数组中的每个元素。

三、使用泛型参数在定义了泛型参数之后，我们可以在函数内部使用这些参数，来实现特定的逻辑。

下面是一个使用泛型参数的示例：typescriptfunction firstElement<T>(arr: T[]): T {return arr[0];}在这个例子中，我们定义了一个名为firstElement的泛型函数，它接受一个泛型数组作为参数，并返回第一个元素。

这个函数的返回类型也使用了泛型参数T。

四、传递具体类型当我们想要调用泛型方法时，可以通过传递具体类型给泛型参数来指定函数参数或返回值的具体类型。

例如，对于上面的printArray函数，我们可以这样调用：typescriptprintArray<number>([1, 2, 3]);在这个例子中，我们通过< number >来指定泛型参数T的具体类型为number，表示传递的是一个数字数组。

typescript 泛型理解

typescript 泛型理解

typescript 泛型理解Typescript 泛型是 Typescript 中一个强大的特性，它使得我们能够编写灵活、可重用且类型安全的代码。

本文将深入探讨Typescript 泛型的概念、使用场景以及一些常见的用法。

一、概念泛型是一种将类型参数化的方法，它使得我们能够在代码中使用不特定类型的变量。

通过使用泛型，我们可以编写出更加通用的代码，从而提高代码的可重用性和灵活性。

二、使用场景在开发过程中，我们经常会遇到需要处理多种类型的情况。

例如，当我们编写一个函数来处理数组时，希望该函数能够适用于任何类型的数组。

这时，泛型就能派上用场了。

另一个常见的使用场景是在集合类中使用泛型。

通过使用泛型，我们可以在编译时强制确保集合中只能存储指定类型的元素，从而避免在运行时出现类型错误。

三、基本用法1. 泛型函数在 Typescript 中，我们可以使用泛型来定义函数的参数类型和返回值类型。

下面是一个简单的例子：```typescriptfunction identity<T>(arg: T): T {return arg;}```在上面的例子中，`<T>` 表示这是一个泛型函数，`T` 是一个类型参数。

在函数的参数和返回值类型中，我们可以使用这个类型参数来表示任意类型。

2. 泛型类除了函数，我们也可以使用泛型来定义类的成员变量和方法。

下面是一个示例：```typescriptclass Box<T> {private value: T;constructor(value: T) {this.value = value;}getValue(): T {return this.value;}}```在上面的例子中，`Box` 类使用一个类型参数 `T` 来表示盒子中存储的值的类型。

通过使用泛型，我们可以在编译时确保盒子中只能存储指定类型的值。

3. 泛型约束有时候，我们希望在泛型函数或泛型类中对类型参数进行一些限制。

java 泛型详解

java 泛型详解

java 泛型详解1. 概述泛型在java中有很重要的地位，在面向对象编程及各种设计模式中有非常广泛的应用。

什么是泛型？为什么要使用泛型？泛型，即“参数化类型”。

一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。

那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。

泛型的本质是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型）。

也就是说在泛型使用过程中，操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。

2.一个栗子一个被举了无数次的例子：List arrayList = new ArrayList();arrayList.add("aaaa");arrayList.add(100);for(int i = 0; i< arrayList.size();i++){String item = (String)arrayList.get(i);Log.d("泛型测试","item = " + item);}毫无疑问，程序的运行结果会以崩溃结束：ng.ClassCastException:ng.Integer cannot be cast to ng.String。

ArrayList可以存放任意类型，例子中添加了一个String类型，添加了一个Integer类型，再使用时都以String的方式使用，因此程序崩溃了。

为了解决类似这样的问题（在编译阶段就可以解决），泛型应运而生。

我们将第一行声明初始化list的代码更改一下，编译器会在编译阶段就能够帮我们发现类似这样的问题。

List<String> arrayList = new ArrayList<String>();...//arrayList.add(100); 在编译阶段，编译器就会报错3.特性泛型只在编译阶段有效。

java 泛型原理

java 泛型原理

java 泛型原理
Java泛型是一种强类型编程语言的特性，它允许开发人员在编译时指定类型参数，在运行时可以避免类型强制转换的问题，并提供更好的类型安全和代码重用。

本文将详细介绍 Java 泛型的原理，包括类型擦除、泛型类、泛型方法、通配符和类型边界等内容。

Java 泛型的类型擦除是指在编译时将所有泛型类型擦除成原始类型，即 Object 类型。

这意味着泛型类型的类型参数信息在编译后不再存在，而是在运行时由 JVM 根据上下文推断出来。

因此，Java 泛型为了保持类型安全，需要使用类型边界和通配符来限制泛型类型的范围。

Java 泛型类是指在类定义中使用泛型参数，可以用来定义具有通用性的类，例如 ArrayList<E>。

泛型方法是指在方法定义中使用泛型参数，可以用来定义具有通用性的方法，例如 <T> void printArray(T[] array)。

泛型类和泛型方法都采用了类型参数的方式来实现编写通用代码的目的。

Java 泛型通配符用于限制泛型类型的范围，包括上界通配符和下界通配符。

上界通配符用 extends 关键字来限制某个类型参数必须是某个类的子类，下界通配符用 super 关键字来限制某个类型参数必须是某个类的超类。

Java 泛型的原理深入理解对于提高代码的重用性和类型安全性非常有帮助，同时也是 Java 开发者必须了解的基本知识。

- 1 -。

Java泛型知识点全方位总结

Java泛型知识点全⽅位总结前⾔我⼀直认为泛型是编程语⾔设计中⼀个⾮常基本和重要的概念。

Java中的泛型是什么？他们为什么在那⾥？他们是如何发展的？在学习基础知识时，对仿制药的透彻理解是⾮常重要的。

因此，我阅读了《Java编程思想》的⼀般章节。

不幸的是，我没有太多的经验，我已经看了好⼏次了。

我们将来只能有学习的机会。

但我也理解很多。

以下是我对仿制药的理解和理解。

如果有什么错误，我希望指出。

概念来源：Java在设计开始之前不是通⽤的，直到它在JDK 1.5中被引⼊。

Java泛型是通过擦除实现的。

你知道什么是擦除吗？往下看。

概念：常规类和⽅法只能使⽤特定类型；基本类型或⾃定义类。

如果要编写可应⽤于多种类型代码的代码，这种严格的限制将对代码施加很⼤的约束。

泛型实现了参数化类型的概念，使代码能够应⽤于多个类型。

当泛型在编程语⾔中出现时，它们的最初⽬的是希望类和⽅法具有⼴泛的表达能⼒。

简单的泛型出现泛型有很多原因，其中最重要的⼀个原因是创建容器类。

我们暂时不指定类型，但决定以后使⽤什么类型。

为了实现这⼀⽬标，需要在类名后⾯使⽤类型参数，⽤尖括号括起来。

然后，当使⽤此类时，将⽤实际类型替换此类型的参数。

在下⾯的⽰例中，t是类型参数。

代码如下：然⽽，在许多源代码中，⼀些泛型类具有多个泛型参数，例如Java。

UTIL功能。

双功能，有三种类型的参数t，u，r。

泛型⽅法泛型⽅法使⽅法独⽴于类。

在编写通⽤代码时，基本的指导原则是尽可能使⽤通⽤⽅法。

这意味着，如果可以对整个类使⽤泛型⽅法⽽不是泛型⽅法，那么可以使⽤泛型⽅法，因为它们可以使事情更清楚。

此外，对于静态⽅法，不能访问泛型类的类型参数，因此如果静态⽅法需要使⽤泛化功能，则必须将它们变为泛型⽅法。

泛型的擦除当我读了Java编程思想的⼀般章节中的“被删除的奥秘”部分时，我特别头晕，然后当我向下看时，我变得越来越困惑。

尤其是当你看边界和通配符的时候，它有点令⼈困惑。

泛型知识点总结

泛型知识点总结泛型是Java语言中的一项重要特性，它允许我们在编写代码时使用一种通用的数据类型来代替具体的数据类型，从而提高代码的复用性、可读性和安全性。

本文将重点总结泛型在Java中的基本概念、用法和注意事项，帮助读者深入理解并合理运用泛型。

1.泛型的基本概念泛型是一种在编译时检查和验证数据类型的技术，它可以让我们在编写代码时使用一种通用的数据类型来代替具体的数据类型。

泛型的引入使得编写更加通用且类型安全的代码成为可能，从而提高了代码的可读性和可维护性。

泛型的基本概念主要涉及以下几个方面：1）泛型类（Generic Class）：使用泛型定义的类，其成员变量、方法参数和返回值均可以使用泛型类型。

例如：`ArrayList<T>`、`Map<K, V>`等。

2）泛型接口（Generic Interface）：使用泛型定义的接口，其方法参数和返回值均可以使用泛型类型。

例如：`Comparable<T>`、`List<E>`等。

3）泛型方法（Generic Method）：在普通类或非泛型类中定义的使用泛型的方法。

例如：`public <T> T get(int index)`。

4）泛型通配符（Generic Wildcard）：用于表示未知类型的通配符，包括`<? extends T>`、`<? super T>`等。

例如：`List<? extends Number>`。

2.泛型的用法泛型在Java中的用法主要有以下几种：1）定义泛型类泛型类是使用泛型定义的类，其中的成员变量、方法参数和返回值均可以使用泛型类型。

定义泛型类的语法如下：```javapublic class MyClass<T> {private T data;public T getData() {return data;}public void setData(T data) {this.data = data;}}```2）定义泛型接口泛型接口是使用泛型定义的接口，其中的方法参数和返回值均可以使用泛型类型。

java泛型基础知识总结

Java泛型Java泛型是java1.5中引入的新特性，在此之前，java通过对类型Object的引用来实现参数类型的“任意化”，特点则是需要进行显示的强制类型转换。

（而这种显示的类型转换可能是无法进行的，是错误的）但编译器无法发现强制类型转换可能引起的异常，异常只有在运行时才能出现，成为了系统的安全隐患。

----------------------------为啥要进入泛型这个概念泛型的本质是参数化类型，及所操作的数据类型被指定为一个参数，此参数类型可以用在类、接口、和方法的声明及创建中，分别被称为泛型类，泛型接口，及泛型方法。

使用注意事项：泛型的类型参数只能是类类型（包括自定义类），但是不能是简单类型泛型类型参数可以是多个泛型的参数类型还可以是通配符类型没有泛型的错误：Import java.util.*;Public class NoGenericTypeDemo{Public static void main(String[] args){List names=new ArrayList();Names.add("张桑拿");Names.add(new Integer(2);String nameFirst=(String)names.get(0);String namesecond=(String)names.get(1);//抛出异常ng.ClassCastException异常，而且编译时没有被发现}有时候需要使泛型变量能使用任何的类型，此时可以使用通配符”？”否则可能需要编写许多版本的重载函数，使用通配符，使方法printLsit（）可以接受各种类型的List对象，否则必须使用重载技术，Public static void printList(List<?>list){//输出集合中的元素}。

深入学习Java_泛型


2. 从泛型类派生子类
当创建了带泛型声明的接口、父类之后，可以为该接口创建 实现类，或者从该父类派生子类，需要指出的是，当使用这些接 口、父类时不能再包含类型形参。例如，下面代码是错误的。 方法中的形参代表变量、常量、表达式等数据，本书把它们 直接成为形参，或者称为数据形参。定义方法时可以声明数据形 参，调用方法（使用方法）时必须为这些数据形参传入实际的数 据； 如果想从Apple类派生一个子类，则可以改为如下代码：
实例
看下面代码打印结果：
因为不管泛型的实际参数是什么，它们在运行时总有同样的类 （class）。 不管为泛型的类型形参传入哪一种类型实参，对于Java来说， 它们依然被当成同一个类处理，在内存中也只占同一块内存空间 ，因此在静态方法、静态初始化或者静态变量的声明和初始化中 不允许使用类型形参。
由于系统中并不会真正生成泛型类，所以 instanceof运算符后 不能使用泛型类。例如，下面的代码是错误的。
调用方法时必须为所有的数据形参传入参数值，与调用方法不 同的是，使用类、接口时也可以不为类型形参参入实际的类型参 数。 如果从Apple<String>类派生子类，则在Apple类中所有使用 T 类型形参的地方都将被替换成String类型，即它的子类将会继承 到String getInfo()和void setInfo(String info)两个方法，如果 子类需要重写父类的方法，就必须注意这一点。
与数组进行比较，先看一下数组是如何工作的。在数组中， 程序可以直接把一个 Integer[] 数组赋给一个 Number[] 变量。如 果试图把一个Double对象保存到Number[]数组中，编译可以通 过，但在运行时抛出ArrayStoreException异常。
  1. 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
list.Add("It is raining in Redmond.");
int t = 0; // This causes an InvalidCastException to be returned. foreach (int x in list) {
t += x; } 尽管将字符串和 ints 组合在一个 ArrayList 中的做法在创建异类集合时是完全可接受的，并 且有时需要有意为之，但这种做法很可能产生编程错误，并且直到运行时才能检测到此错误。
public static int Find<T>(T[] items,T item){ for(int i=0 ;i<items.Length;i++) {
if(..) reutrn i; } return -1
} } //泛型方法调用 int i = Finder.Find<int>(new int[] {1,2,3,4,5},6);
Node current = head;
while (current != null) {
yield return current.Data; current = current.Next; } } }
下面的代码示例演示客户端代码如何使用泛型 GenericList<T> 类来创建整数列表。只需更改 类型参数，即可方便地修改下面的代码示例，创建字符串或任何其他自定义类型的列表： Code
CLR 为所有类型参数为“引用类型”的泛型类型产生同一份代码；但如果类型参数为“值 类型”，对每一个不同的“值类型”，CLR 将为其产生一份独立的代码。
泛型的优点对比： 在公共语言运行库和 C# 语言的早期版本中，通用化是通过在类型与通用基类型
Object 之间进行强制转换来实现的，泛型提供了针对这种限制的解决方案。通过创建泛型 类，您可以创建一个在编译时类型安全的集合。
System.Collections.ArrayList list2 = new System.Collections.ArrayList(); list2.Add("It is raining in Redmond."); list2.Add("It is snowing in the mountains.");
当然，也可以创建自定义泛型类型和方法，以提供自己的通用解决方案，设计类型安全的高 效模式。下面的代码示例演示一个用于演示用途的简单泛型链接列表类在通常使用具体类型 来指示列表中存储的项的类型的场合，可使用类型参数 T。其使用方法如下： 1、在 AddHead 方法中作为方法参数的类型。 2、在 Node 嵌套类中作为公共方法 GetNext 和 Data 属性的返回类型。 3、在嵌套类中作为私有成员数据的类型。
T：<接口名称> 类型参数必须是指定的接口或实现指定的接口。可以指定多个接口约束。约束接口也可以
是泛型的。
T：U 为 T 提供的类型参数必须是为 U 提供的参数或派生自为 U 提供的参数。这称为裸类型
#泛型知识详解
泛型介绍： 泛型类和泛型方法同事具备可重用性、类型安全和效率，这是非泛型类和非泛型方法无
法具备的。所谓泛型，即通过参数化类型实现同一份代码上操作多种数据类型，泛型编程是 一种编程范式，它利用“参数化类型”将类抽象化，从而达到更灵活的复用。
机制： C# 泛型类型替换是在运行时执行的，从而为实例化的对象保留了泛型类型信息。C#泛
class TestGenericList {
static void Main() {
GenericList<int> list = new GenericList<int>();
for (int x = 0; x < 10; x++) {
list.AddHead(x); }
foreach (int i in list) {
型代码在被编译为 IL 代码和无数据时，采用特殊的占位符来表示泛型类型，并用专有的 IL 指令支持泛型操作。而真正的泛型实例化工作以"on-demand"的方式，发生在 JIT 编译时。
举例： 泛型通常用与集合以及作用于集合的方法一起使用。.NET Framework 2.0 版类库提供一
个新的命名空间 System.Collections.Generic，其中包含几个新的基于泛型的集合类。建议面 向 2.0 版的所有应用程序都使用新的泛型集合类，而不要使用旧的非泛型集合类，如 ArrayList。
使用可以为 null 的类型（C# 编程指南）。
T：class 类型参数必须是引用类型；这一点也适用于任何类、接口、委托或数组类型。
T：new() 类型参数必须具有无参数的公共构造函数。当与其他约束一起使用时，new() 约束必须最
后指定。
T：<基类名> 类型参数必须是指定的基类或派生自指定的基类。
注意，T 可用于 Node 嵌套类。如果使用具体类型实例化 GenericList<T>（例如，作为 GenericList<int>），则所有的 T 都将被替换为 int。
Code // 参数类型 T public class GenericList<T> { private class Node { public Node(T t) { next = null; data = t; }
static bool F(int i){..} static bool G(string s){..} static void Main() { Predicate<string> p2 = G; Predicate<int> p1 = new Predicate<int>(F); } } 泛型委托支持在委托返回值和参数上应用参数类型，这些参数类型同样可以附带合法的约 束。
但这种方便是需要付出代价的。添加到 ArrayList 中的任何引用或值类型都将隐式地向 上强制转换为 Object。如果项是值类型，则必须在将其添加到列表中时进行装箱操作，在 检索时进行取消装箱操作。强制转换以及装箱和取消装箱操作都会降低性能；在必须对大型 集合进行循环访问的情况下，装箱和取消装箱的影响非常明显。
在 C# 语言的 1.0 和 1.1 版本中，只能通过编写自己的特定于类型的集合来避免 .NET Framework 基类库集合类中的通用代码的危险。当然，由于此类不可对多个数据类型重用， 因此将丧失通用化的优点，并且您必须对要存储的每个类型重新编写该类。
ArrayList 和其他相似类真正需要的是：客户端代码基于每个实例指定这些类要使用的具体数 据类型的方式。这样将不再需要向上强制转换为 T:System.Object，同时，也使得编译器可以 进行类型检查。换句话说，ArrayList 需要一个类型参数。这正是泛型所能提供的。在 N:System.Collections.Generic 命名空间的泛型 List<(Of <(T>)>) 集合中，向集合添加项的操作 类似于以下形式：
另一个限制是缺少编译时类型检查；因为 ArrayList 会将所有项都强制转换为 Object， 所以在编译时无法防止客户端代码执行类似如下的操作：
Code System.Collections.ArrayList list = new System.Collections.ArrayList(); // Add an integer to the list. list.Add(3); // Add a string to the list. This will compile, but may cause an error later.
泛型方法简介： C#泛型机制只支持“在方法声明上包含类型参数”----即泛型方法 C#泛型机制不支持在除方法外的其它成员（包括属性，事件，索引器，构造器，析构器）的 声明上包含类型参数，但这些成员本身可以包含在泛型类型中，并使用泛型类型的类型参数 泛型方法既可以包含在泛型类型中，也可以包含在非泛型类型中。 public class Finder{
泛型类型的成员: 泛型类型的成员可以使用泛型类型声明中的类型参数，但类型参数如果没有任何约束，则只 能在该类型上使用从 System.Object 继承的公有成员。
泛型接口： 泛型接口的类型参数要么已实例化，要么来源于实现类声明的类型参数。
泛型委托： delegate bool Predicate<T>(T value); class x {
使 用 非 泛 型 集 合 类 的 限 制 可 以 通 过 编 写 一 小 段 程 序 来 演 示 ， 该 程 序 利 用 .NET Framework 类库中的 ArrayList 集合类。ArrayList 是一个使用起来非常方便的集合类，无需 进行修改即可用来存储任何引用或值类型。
Code System.Collections.ArrayList list1 = new System.Collections.ArrayList(); list1.Add(3); list1.Add(105);
private Node head; public GenericList() {
head = null; }
// 用 T 做为方法的参数类型 public void AddHead(T t) {
Node n = new Node(t); n.Next = head; head = n; }
public IEnumerator<T> GetEnumerator() {
ArrayList 更安全并且速度更快的列表，对于列表项是值类型的情况尤为如此。
C#泛型的几个特点： 1、如果实例化泛型类型的参数相同，那么 JIT 编译器会重复使用该类型，因此 C#的动态泛 型能力避免了 C++静态模板可能导致的代码膨胀的问题。 2 C#泛型类型携带有丰富的元数据，因此 C#的泛型类型可以应用于强大的反射技术。 3、C#的泛型采用“基类，接口，构造器，值类型/引用类型”的约束方式来实现对类型能数 的“显式约束”，提高了类型安全的同时，也丧失了 C++模板基于“签名”的隐式约束所具 有的高灵活性。