第10章 类型参数化——泛型

1.1习题1解答1.（1）机器语言是计算机直接理解执行的语言，由一系列（二进制）指令组成，其助记符构成了汇编语言；接近人的自然语言习惯的程序设计语言为高级语言。

（2）结构化程序设计方法主要内容有：自顶向下，逐步求精；面向对象方法将现实世界中的客观事物描述成具有属性和行为的对象，抽象出共同属性和行为，形成类。

（3）C++程序开发通常要经过5个阶段，包括：编辑，编译，连接，运行，调试。

首先是编辑阶段，任务是编辑源程序，C++源程序文件通常带有.c p p扩展名。

接着，使用编译器对源程序进行编译，将源程序翻译为机器语言代码（目标代码），过程分为词法分析、语法分析、代码生成3个步骤。

在此之前，预编译器会自动执行源程序中的预处理指令，完成将其他源程序文件包括到要编译的文件中，以及执行各种文字替换等。

连接器的功能就是将目标代码同缺失函数的代码连接起来，将这个“漏洞”补上，生成可执行文件。

程序运行时，可执行文件由操作系统装入内存，然后CPU从内存中取出程序执行。

若程序运行进程中出现了错误，还在需要对程序进行调试。

（4）对象与对象之间通过消息进行相互通信。

（5）类是具有相同属性和行为的一组对象的抽象；任何一个对象都是某个类的一个实例。

（6）多态性是指在一般类中定义的属性或行为，被特殊类继承之后，可以具有不同的数据类型或表现出不同的行为。

（7）面向对象的软件开发过程主要包括面向对象的方法分析、面向对象的设计、面向对象的编程、面向对象的测试和面向对象的维护。

（8）泛型程序设计是指在程序设计时，将数据类型参数化，编写具有通用性和可重用的程序。

（9）#include<iostream>是一条预处理指令（语句），在编译（或预处理）时由编译器（或预编译器）执行，其功能是将iostream文件包含（复制）到指令处。

（10）C++中使用cin作为标准输入流对象，通常代表键盘，与提取操作符>>连用；使用cout作为标准输出流对象，通常代表显示设备，与<<连用。

1程序控制结构,特别是异常:(1)异常（Exception）——程序检测到的运行时刻不正常的情况。

如被0 除、数组越界访问或空闲存储内存耗尽等等。

(2)异常处理——是一种允许两个独立开发的程序组件在程序执行期间遇到程序不正常的情况时相互通信的机制。

(3)这里的异常是指软件异常(4)抛掷异常的程序段……throw 表达式;（异常抛出）……(5)捕获并处理异常的程序段try复合语句（保护段）catch（异常类型声明）复合语句（处理段）catch（异常类型声明）复合语句（处理段）……(6)异常处理的执行过程如下：①程序通过正常的顺序执行到达try语句，然后执行try块内的保护段。

②如果在保护段执行期间没有引起异常，那么跟在try块后的catch语句就不执行，程序从最后一个catch语句后面的语句继续执行下去。

③如果在保护段执行期间或在保护段调用的任何函数中(直接或间接的调用)有异常被抛掷，则从通过throw创建的对象中创建一个异常对象(隐含调用拷贝构造函数)，程序转到catch处理段。

④如果匹配的catch处理器未找到，则terminate()将被自动调用，该函数的默认功能是调用abort终止程序。

⑤如果找到了一个匹配的catch处理程序，且它通过值进行捕获，则其形参通过拷贝异常对象进行初始化。

在形参被初始化之后，“展开栈”的过程开始。

这包括对那些在与catch处理器相对应的try块开始和异常丢弃地点之间创建的（但尚未析构的）所有局部对象的析构。

3.委托的使用:答：（1）委托定义；（2）用委托声明变量；（3）准备委托函数；（4）委托调用；（5）委托赋值。

4 this指针或引用:(1)面向对象语言提供的一个特殊对象指针,this指针是一种隐含指针，每个非静态的成员函数都有一个this指针，用来标记成员函数操作哪个对象的数据成员。

(2)this是为了实现代码共享,C++和C一样：函数的作用是减少代码开销。

java泛型函数定义Java泛型函数定义是指在函数声明中使用泛型类型参数来定义一个通用的函数。

泛型函数可以接受不同类型的参数，并返回不同类型的结果。

泛型函数定义的语法如下：```public <T> T functionName(T parameter) {//函数体}```其中，`<T>`指定了一个泛型类型参数T，T可以是任何类型，包括基本类型和对象类型。

泛型函数可以使用泛型类型参数T作为参数类型或返回类型。

例如，下面的代码定义了一个泛型函数`max`，用于比较两个参数的大小并返回较大的那个：```public static <T extends Comparable<T>> T max(T x, T y) { if (pareTo(y) > 0) {return x;} else {return y;}}```其中，`<T extends Comparable<T>>`指定了泛型类型参数T必须是实现了`Comparable`接口的类型。

这样，我们就可以使用`compareTo`方法来比较两个参数的大小了。

使用泛型函数的时候，可以根据需要传入不同类型的参数，函数会自动根据传入的参数类型推导出泛型类型参数T的类型。

例如： ```Integer x = 1;Integer y = 2;Integer z = max(x, y); // z = 2String s1 = 'hello';String s2 = 'world';String s3 = max(s1, s2); // s3 = 'world'```在泛型函数中，我们也可以使用多个泛型类型参数，并且它们可以有不同的类型。

例如：```public static <T, U> boolean isEqual(T x, U y) {return x.equals(y);}```这个函数可以接受任意类型的参数，并判断它们是否相等。

C#中的泛型和泛型集合⼀、什么是泛型？泛型是C#语⾔和公共语⾔运⾏库（CLR）中的⼀个新功能，它将类型参数的概念引⼊.NET Framework。

类型参数使得设计某些类和⽅法成为可能，例如，通过使⽤泛型类型参数T，可以⼤⼤简化类型之间的强制转换或装箱操作的过程（下⼀篇将说明如何解决装箱、拆箱问题）。

说⽩了，泛型就是通过参数化类型来实现在同⼀份代码上操作多种数据类型，利⽤“参数化类型”将类型抽象化，从⽽实现灵活的复⽤。

使⽤泛型给代码带来的5点好处：1、可以做⼤限度的重⽤代码、保护类型的安全以及提⾼性能。

2、可以创建集合类。

3、可以创建⾃⼰的泛型接⼝、泛型⽅法、泛型类、泛型事件和泛型委托。

4、可以对泛型类进⾏约束，以访问特定数据类型的⽅法。

5、关于泛型数据类型中使⽤的类型的信息，可在运⾏时通过反射获取。

例⼦：using System;namespace ConsoleApp{class Program{class Test<T>{public T obj;public Test(T obj){this.obj = obj;}}static void Main(string[] args){int obj1 = 2;var test = new Test<int>(obj1);Console.WriteLine("int:" + test.obj);string obj2 = "hello world";var test1 = new Test<string>(obj2);Console.WriteLine("String:" + test1.obj);Console.ReadKey();}}}　输出结果是： int:2 String:hello world 分析： 1、 Test是⼀个泛型类。

C#之使类型参数--泛型1、泛型是什么泛型的就是“通⽤类型”，它可以代替任何的数据类型，使类型参数化，从⽽达到只实现⼀个⽅法就可以操作多种数据类型的⽬的。

2、为什么使⽤泛型举⼀个⽐较两个数⼤⼩的例⼦：以上例⼦实现int类型数据的⼤⼩⽐较是完全没有问题的，但是如果客户现在增加需求“⼜可以实现两个字符串⼤⼩的⽐较”，此时就不得不在类中再添加⼀个⽐较字符串⼤⼩的⽅法了：如果客户现在还增加需求，要求实现浮点型的⽐较，那么⼯作量就更⼤了，不得不再次修改代码，显然这不是我们想看到的，两个⽅法中有⼤部分代码是类似的，所以微软提出了⼀个激动⼈⼼的特性--泛型，他使得类型可以被参数化。

where语句是类型参数的约束它⽤来使参数可以适⽤于CompareTo⽅法。

向泛型中加⼊元素的效率远⽐⾮泛型数组⾼，原因是⾮泛型rrayList的Add（Object value）⽅法中，参数为object类型，当把int参数i传⼊⽅法时，会发⽣装箱操作，从⽽导致性能的损失，使运⾏的时间变得更长。

泛型可以保证类型安全，当你向int类型数组中添加string类型的值的时候，会造成“⽆法从string类型转换为int类型”的错误，因为你⽤int类型初始化了泛型类型。

3、泛型参数解析1、类型参数根据泛型类型参数是否已经提供实际类型，可分为未绑定的泛型和已构造的泛型，如果没有给泛型提供实际类型，此时的泛型成为未绑定的泛型；如果已指定了实际类型作为参数，此时的泛型成为已构造泛型。

已构造泛型⼜称为开放泛型和密封泛型。

开放泛型指包含类型参数的泛型，所有未绑定的类型都属于开放类型；⽽封闭类型指已经为每个参数都指定了实际数据类型的泛型。

2、泛型中的静态字段和静态函数问题对于⾮泛型类，定义了⼀个静态字段，不管是创建了多少个该类的实例，也不管从该类派⽣出多少个实例，都只存在⼀个字段，但是每个封闭的泛型类型中都有仅属于他⾃⼰的静态字段。

这是因为，在使⽤实际类型参数代替泛型参数时，编译器会根据不同的类型参数，从新⽣成类型。

ts 泛型类型默认值理解全文共四篇示例，供读者参考第一篇示例：TS的泛型类型是一种非常强大和有用的特性，它使得我们能够以一种更加灵活和通用的方式来定义函数和类。

泛型类型允许我们在定义函数或类的时候不指定具体的类型，而是使用一个占位符来表示该类型。

这样一来，我们就可以在使用函数或类的时候再指定具体的类型，从而实现更加灵活和通用的代码编写。

在实际的项目中，我们经常会遇到需要定义泛型类型并给其设置默认值的情况。

默认值是一种在定义泛型类型时设置的初始值，当我们在使用泛型类型的时候不显式地指定具体的类型时，就会使用默认值来作为该泛型类型的类型。

在TS中给泛型类型设置默认值非常简单，在定义泛型类型的时候可以使用`=`符号来指定默认值。

例如：```typescriptfunction identity<T = string>(arg: T): T {return arg;}const output = identity<number>(10); // output 的类型为numberconst output2 = identity('hello'); // output2 的类型为string```上面的例子中，我们定义了一个泛型函数`identity`，并且为泛型类型`T`设置了默认值`string`。

当我们在使用`identity`函数时没有显式地指定`T`的类型时，TS会自动推断泛型类型为`string`，从而返回值的类型也会是`string`。

通过设置默认值，我们可以在定义泛型类型的时候为其指定一个普适的类型，当我们在使用这个泛型类型时不做额外的指定时，就会使用默认值。

这样一来，可以简化代码的编写，并且提高代码的复用性和可维护性。

TS的泛型类型和默认值是一种非常实用的特性，能够帮助我们更加灵活和通用地定义函数和类。

通过设置默认值，可以简化代码的编写，并提高代码的复用性和可维护性。

目录1. 泛型简介 (2)1.1.理解泛型 (2)1.2.泛型简介 (3)2.泛型的优点 (3)3.泛型类型参数 (4)4.类型参数的约束 (5)5.泛型类 (9)6.泛型接口 (11)7.泛型方法 (13)8.泛型委托 (15)9.泛型代码中的默认关键字 (17)10.泛型和属性 (18)1.泛型简介1.1.理解泛型如果我们编写一个求和的函数，我们应该怎么做？如果这两个数是整数，我们可以实现下面的函数：如果求两个double类型的数的和，我们还可以用重载实现：假设程序升级需要支持，decimal、long等类型的加法操作，我们怎么办？用重载去一次实现这些函数？可不可写一个通用的函数呢？于是我们想到object类型，实现了下面的函数：这里用到的技术就是装箱和拆箱，Add方法首先将所有数据类型的数据进行装箱，这样就统一了它们的类型，然后再进行类型转换和计算，计算结果再拆箱就是要求的结果。

实际上就是“泛型”思想的一个应用，这里用一个通用方法解决了几乎任何数值类型两个数的求和操作。

可以说，对于这个求和算法来讲是通用的、泛型的（不需要特定数据类型）。

但是我们从上面的代码可以看到问题，就是它频繁的执行装箱和拆箱操作，这些操作是非常损耗性能的。

另外，装箱和拆箱的代码也显得比较“难看”，因为每次都要进行强类型转换，有没有更好的方式来编写这种通用算法呢？于是，C#从 2.0版本开始引入了泛型技术，泛型能够给我们带来的两个明显好处是代码清晰并且减少了装箱、拆箱。

1.2.泛型简介下面我们应用泛型实现交换两个数的例子：这个交换算法不仅支持任何数字类型，它还支持你在程序中能用到得任何类型。

注意，泛型不属于任何命名空间，准确的讲，泛型是一种编译技术。

在书写算法的时候，泛型技术允许我们使用一种类型占位符（或称之为类型参数，这里使用的占位符是“T”）作为类型的标识符，而不需要指定特定类型。

当我们在调用这个算法的时候，编译器使用指定的类型代替类型占位符建立一个针对这种类型的算法。

浅谈Java泛型编程原文地址：/thread.jspa?messageID=154504我原本想全文翻译Generics in the Java Programming Language，但是功力不够，太耗时间。

于是乎按照原文的框架，翻了一些再加上自己写的一点东西。

第一次写文，如有谬误还清指出~~谢谢！浅谈Java泛型编程1 引言在JDK 1.5中，几个新的特征被引入Java语言。

其中之一就是泛型（generics）。

泛型（generics，genericity）又称为“参数类型化（parameterized type）”或“模板（templates）”，是和继承（inheritance）不同而互补的一种组件复用机制。

继承和泛型的不同之处在于——在一个系统中，继承层次是垂直方向，从抽象到具体，而泛型是水平方向上的。

当运用继承，不同的类型将拥有相同的接口，并获得了多态性；当运用泛型，将拥有许多不同的类型，并得以相同的算法作用在它们身上。

因此，一般说来，当类型与实现方法无关时，使用泛型；否则，用继承。

泛型技术最直接联想到的用途就是建立容器类型。

下面是一个没有使用泛型技术的例子：List myIntList = new LinkedList();// 1myIntLikst.add(new Integer(0));// 2Integer x = (Integer)myIntList.iterator().next();// 3显然，程序员知道究竟是什么具体类型被放进了myIntList中。

但是，第3行的类型转换（cast）是必不可少的。

因为编译器仅仅能保证iterator返回的是Object类型。

要想保证将这个值传给一个Integer类型变量是安全的，就必须类型转换。

除了使代码显得有些混乱外，类型转换更带来了运行时错误的可能性。

因为程序员难免会犯错误。

使用了泛型技术，程序员就可以确切地表达他们的意图，并且把myIntList限制为包含一种具体类型。

java泛型语法Java泛型语法是Java编程语言中的一个重要特性，它允许我们编写更加通用和灵活的代码。

通过使用泛型，我们可以在编译时期检测类型错误，并在运行时期避免类型转换异常。

本文将介绍Java泛型的基本语法和使用方法。

一、泛型的定义和作用泛型是Java中的一种参数化类型，它允许我们在定义类、接口和方法时使用类型参数。

通过使用泛型，我们可以将类型作为参数传递给类、接口和方法，从而实现代码的复用和灵活性。

泛型的作用主要有以下几个方面：1. 类型安全：通过使用泛型，我们可以在编译时期检测类型错误，避免类型转换异常。

2. 代码复用：通过定义泛型类、接口和方法，我们可以实现对多种类型的支持，从而提高代码的复用性。

3. 简化代码：通过使用泛型，我们可以减少冗余的类型转换代码，使代码更加简洁。

4. 提高性能：通过使用泛型，我们可以避免使用Object类型，从而减少了装箱和拆箱的开销，提高了代码的执行效率。

二、泛型的基本语法Java中的泛型通过使用尖括号<>来定义类型参数。

在定义类、接口和方法时，我们可以将类型参数放在尖括号中，并在后续的代码中使用该类型参数。

1. 泛型类的定义：```public class GenericClass<T> {private T data;public T getData() {return data;}public void setData(T data) {this.data = data;}}```在上面的代码中，泛型类GenericClass使用了类型参数T。

我们可以在创建GenericClass对象时指定具体的类型，例如：```GenericClass<String> genericString = new GenericClass<>(); genericString.setData("Hello, World!");String data = genericString.getData();```上面的代码中，我们创建了一个GenericClass对象genericString，并指定了类型参数为String。

java泛型详解-绝对是对泛型⽅法讲解最详细的，没有之⼀1. 概述泛型在java中有很重要的地位，在⾯向对象编程及各种设计模式中有⾮常⼴泛的应⽤。

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

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

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

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

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

2. ⼀个栗⼦⼀个被举了⽆数次的例⼦：1 List arrayList = new ArrayList();2 arrayList.add("aaaa");3 arrayList.add(100);45for(int i = 0; i< arrayList.size();i++){6 String item = (String)arrayList.get(i);7 Log.d("泛型测试","item = " + item);8 }毫⽆疑问，程序的运⾏结果会以崩溃结束：1 ng.ClassCastException: ng.Integer cannot be cast to ng.StringArrayList可以存放任意类型，例⼦中添加了⼀个String类型，添加了⼀个Integer类型，再使⽤时都以String的⽅式使⽤，因此程序崩溃了。

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

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

C++泛型编程基本概念详解⽬录1.什么是泛型编程？2.函数模板(1)函数模板概念(2)函数模板格式(3)函数模板的原理(4)函数模板的实例化(5)模板参数的匹配原则3.类模板(1)类模板的定义格式(2)类模板的实例化总结1.什么是泛型编程？⽐如说，我们如何实现⼀个通⽤的交换函数呢？int型、double型、char型的交换void Swap(int& left, int& right){int temp = left;left = right;right = temp;}void Swap(double& left, double& right){double temp = left;left = right;right = temp;}void Swap(char& left, char& right){char temp = left;left = right;right = temp;}......虽然我们可以使⽤函数重载来实现，但是有⼀下⼏个不好的地⽅：（1）重载的函数仅仅只是类型不同，代码的复⽤率⽐较低，当新类型出现时，就需要增加对应的函数。

（2）代码的可维护性⽐较低，⼀个出错可能所有的重载均出错。

泛型编程：编写与类型⽆关的通⽤代码，是代码复⽤的⼀种⼿段。

模板是泛型编程的基础。

包括函数模板和类模板。

前⾯我们介绍的vector,list,map都是⼀种数据结构容器，容器本⾝的存储结构不同，各容器中存在的数据类型也可以不同。

但我们在访问这些容器中数据时，拥有相同的⽅式。

这种⽅式就叫做“泛型编程”，顾名思义，不同的类型采⽤相同的⽅式来操作。

2.函数模板(1)函数模板概念函数模板代表了⼀个函数家族，该函数模板与类型⽆关，在使⽤时被参数化，根据实参类型产⽣函数的特定类型版本。

(2)函数模板格式template<typename T1, typename T2,......,typename Tn>返回值类型函数名(参数列表){}//typename是⽤来定义模板参数关键字，也可以使⽤class(切记：不能使⽤struct代替class)template<typename T>void Swap(T& left , T& right){T temp = left;left = right;right = temp;}(3)函数模板的原理函数模板是⼀个蓝图，它本⾝并不是函数，是编译器通过使⽤⽅式产⽣特定具体类型函数的模具。

Java泛型List转数组1. 概述在Java编程中，我们经常会使用List来存储一组元素。

但是有时候我们需要将List转换为数组，以满足特定的需求。

本文将详细介绍如何使用Java的泛型来实现List转数组的操作。

2. 泛型介绍在Java中，泛型是一种参数化类型的概念。

通过使用泛型，我们可以在编译时检查类型的安全性，避免在运行时出现类型转换错误。

泛型可以应用于类、接口、方法等。

3. List和数组的区别在开始讨论List转数组之前，我们先来了解一下List和数组的区别。

3.1 ListList是Java集合框架中的一种接口，它继承自Collection接口，并且允许存储重复元素。

List提供了一系列方法来操作元素，例如添加、删除、修改等。

List还有一个特点就是可以动态改变大小。

3.2 数组数组是一种固定长度的数据结构，它可以存储相同类型的元素。

数组在创建时需要指定长度，且长度不可变。

数组的访问速度比List快，但是不支持动态改变大小。

4. List转数组的方法Java中提供了多种方法来实现List转数组的操作。

下面我们将分别介绍这些方法的使用。

4.1 toArray方法List接口提供了一个toArray方法，可以将List转换为数组。

该方法有两种重载形式：4.1.1 toArray方法 - 无参Object[] toArray()无参的toArray方法将List转换为Object类型的数组。

示例代码如下：List<String> list = new ArrayList<>();list.add("A");list.add("B");list.add("C");Object[] array = list.toArray();上述代码中，list是一个包含三个元素的List，通过toArray方法将其转换为Object类型的数组。

java方法泛型的定义和使用Java中的泛型是一种参数化类型的概念，它可以在定义类、接口或方法时使用。

泛型的主要目的是为了增加代码的重用性和类型安全性。

在Java中，泛型使用尖括号<>来标识泛型的类型参数，可以在类、接口和方法的定义中使用。

以下是Java方法泛型的定义和使用的示例：1. 定义一个泛型方法：```public <T> void printArray(T[] array) {for (T element : array) {System.out.println(element);}}```上述代码中的`<T>`表示定义了一个泛型类型参数T。

`printArray`方法接收一个泛型数组`array`，并逐个打印数组中的元素。

2. 使用泛型方法：```Integer[] intArray = {1, 2, 3, 4, 5};String[] strArray = {"Apple", "Orange", "Banana"};printArray(intArray);printArray(strArray);```上述代码中，`Integer[]`和`String[]`是具体的数组类型，可以传递给`printArray`方法进行打印。

3. 泛型方法的返回类型：```public <T> T getFirstElement(T[] array) {if (array.length > 0) {return array[0];} else {return null;}}```上述代码中的泛型方法`getFirstElement`返回数组的第一个元素，其返回类型是参数化的类型T。

通过使用泛型方法，可以根据实际传入的数组类型确定返回类型。

可以看出，使用泛型方法可以达到代码的灵活性和类型安全的目的。

Java泛型机制初探【摘要】本文首先对泛型的基本概念和特点进行简单介绍，然后通过引入实例来讨论泛型机制带来的优点，同时还介绍了泛型的转化，怎么将带有泛型的Java程式转化成一般的没有泛型的Java程式，最后介绍了Java中的泛型和C++模板的主要差别。

【关键词】泛型；类型参数；Java1 泛型概述泛型是程序设计语言的一种特性。

允许程序员在强类型程序设计语言中编写代码时定义一些可变部分，那些部分在使用前必须作出指明。

各种程序设计语言和其编译器、运行环境对泛型的支持均不一样。

非常多Java程式员都使用过集合（Collection），集合中元素的类型是多种多样的，Java语言之所以支持这么多种类的集合，是因为他允许程式员构建一个元素类型为Object的Collection，所以其中的元素能是所有类型。

当使用Collection时，我们经常要做的一件事情就是要进行类型转换，当转换成所需的类型以后，再对他们进行处理。

非常明显，这种设计给编程人员带来了极大的不便，同时也容易引入错误。

近些年的一些编译器对Java语言进行了扩充，使Java语言支持了“泛型”，特别是Sun公司发布的JDK 5.0更是将泛型作为其中一个重要的特性加以推广。

2 泛型概览泛型本质上是提供类型的“类型参数”，他们也被称为参数化类型（parameterized type）或参量多态（parametric polymorphism）。

GJ（Generic Java）是对Java语言的一种扩展，是一种带有参数化类型的Java语言。

用GJ编写的程式看起来和普通的Java程式基本相同，只不过多了一些参数化的类型同时少了一些类型转换。

具体的转化过程大致分为以下几个部分：（1）将参数化类型中的类型参数“擦除”（erasure）掉。

（2）将类型变量用“上限（upper bound）”取代，通常情况下这些上限是Object。

这里的类型变量是指实例域，本地方法域，方法参数及方法返回值中用来标记类型信息“变量”。

泛型（⼀）泛型类和泛型⽅法⼀、泛型的概念 Java5引⼊参数化类型（Parameterized Type）的概念，也称为泛型（Generic）。

泛型：就是允许在定义类、接⼝、⽅法时使⽤类型形参。

这个类型形参将在声明变量、创建对象、调⽤⽅法时动态指定，即传⼊实际的类型参数（也叫传⼊类型实参）。

传⼊的类型实参的类型必须是引⽤类型。

⼆、泛型类 2.1、定义泛型类public class A<T> { // 泛型类：定义类的时候指定类型形参T，在类⾥⾯T就可以当成类型使⽤private T a;public T getA() {return a;}public void setA(T a) {this.a = a;}} 2.2、继承泛型类的⼏种⽅式class B1 extends A<String> {}class B2<E> extends A<String> {}class B3<E> extends A<E> {}class B4<E1, E2> extends A<E1> {} 2.3、使⽤泛型类public static void main(String[] args) {B1 b1 = new B1();b1.setA("b1");System.out.println(b1.getA());A<String> a1 = new B1();a1.setA("a1");System.out.println(a1.getA());//B2<?> b2 = new B2<String>();//B2<String> b2：声明变量时已经指定了B2的类型形参E为String，//new B2<>()：创建对象时可以使⽤菱形语法（泛型推断）B2<String> b2 = new B2<>();//菱形语法b2.setA("b2");System.out.println(b2.getA());// ⽆法通过A<String>推断出B2的类型形参E的类型，不可以使⽤菱形语法A<String> a2 = new B2<Object>();a2.setA("a2");System.out.println(a2.getA());B3<String> b3 = new B3<>();//菱形语法b3.setA("b3");System.out.println(b3.getA());A<String> a3 = new B3<>();//菱形语法a3.setA("a3");System.out.println(a3.getA());} 2.4、JDK7新特性：菱形语法（泛型推断） 菱形语法（泛型推断）：从JDK 7 开始，Java允许在构造器后不需要带完整的泛型信息，只要给出⼀对尖括号<>即可，Java可以推断出尖括号⾥⾯应该是什么类型。

第1章Java概述1.编译java application源程序文件将产生相应的字节码文件，这些字节码文件别的扩展名为.java2.执行一个java程序fristapp的方法是运行java fristapp3.main（）方法的返回类型是void4.在java代码中，public static void main方法的参数描述正确的是string args【】，string【】args5.内存的回收程序负责释放无用内存√6.java体系主要分为java ME,Java SE,JavaEE三大块第2章Java基础1.Java语言中，下列标识符错误的是40name2.java变量中，以下不属于引用类型的数据类型是字符型3.double d=5.3E12 ×4.C5.A6.for循环的一般形式为；for（初值；终值；增量），以下对for循环的叙述，正确的是初值和增量都是赋值语句，终值是条件判断语句7.当输入下面选项中3值时，将会输出default8.下面哪种方法能够支持javadoc命令/**…*/9.下面声明一个string类型的数组正确的是string str[]10.下面定义一个整型数组，不合法的是int[][]array=new int[][4];11.给定代码；。

下面叙述正确的是输出的结果为：012.java语言规定，标示符只能由字母，数字美元符$和下划线租成，并且第一个字符不能是数字；java是区分大小写的。

13.表达式1/2*3的计算结果是0；设x=2，则表达式（x++）/3的值是014.数组的长度可以用其属性lengt h获得；创建一个数组对象可以使用new关键字创建第3章面向对象基础1.在java中引用对象变量和对象间有什么关系？引用变量是指向对象的一个指针2.对象是面向对象技术的核心所在，在面向对象程序设计中，对象是累的抽象×3.构造方法何时被调用？创建对象时4.A，B,D5.在java语言中在包p1中包含包p2，类A直接隶属于p1，类B直接隶属于包p2.在类c中要使用类a的方法和类b的方法b，需要选择import p1.*; import p1.p2,*;6.java中，访问修饰符限制最高的是private第4章类之间的关系1.在java中，下面关于类的描述正确的是一个父类可以有多个子类2.在java语言中，类worker是类person的子类，worker的构造方法中有一句“super（）”，该语句是调用person的构造法法。

泛型：通过参数化类型来实现在同一份代码上操作多种数据类型。

利用“参数化类型”将类型抽象化，从而实现灵活的复用。

例子代码：class Program{static void Main(string[] args){int obj = 2;Test<int> test = new Test<int>(obj);Console.WriteLine("int:" + test.obj);string obj2 = "hello world";Test<string> test1 = new Test<string>(obj2);Console.WriteLine("String:" + test1.obj);Console.Read();}}class Test<T>{public T obj;public Test(T obj){this.obj = obj;}}输出结果是：int:2String:hello world程序分析：1、Test是一个泛型类。

T是要实例化的范型类型。

如果T被实例化为int型，那么成员变量obj就是int型的，如果T被实例化为string型，那么obj就是string类型的。

2、根据不同的类型，上面的程序显示出不同的值。

C#泛型机制：C#泛型能力有CLR在运行时支持：C#泛型代码在编译为IL代码和元数据时，采用特殊的占位符来表示范型类型，并用专有的IL指令支持泛型操作。

而真正的泛型实例化工作以“on-de mand”的方式，发生在JIT编译时。

看看刚才的代码中Main函数的元数据.method private hidebysig static void Main(string[] args) cil managed{.entrypoint// Code size 79 (0x4f).maxstack 2.locals init ([0] int32 obj,[1] class CSharpStudy1.Test`1<int32> test,[2] string obj2,[3] class CSharpStudy1.Test`1<string> test1)IL_0000: nopIL_0001: ldc.i4.2IL_0002: stloc.0IL_0003: ldloc.0IL_0004: newobj instance void class CSharpStudy1.Test`1<int32>::.ctor(!0) IL_0009: stloc.1IL_000a: ldstr "int:"IL_000f: ldloc.1IL_0010: ldfld !0 class CSharpStudy1.Test`1<int32>::objIL_0015: box [mscorlib]System.Int32IL_001a: call string [mscorlib]System.String::Concat(object,object)IL_001f: call void [mscorlib]System.Console::WriteLine(string)IL_0024: nopIL_0025: ldstr "hello world"IL_002a: stloc.2IL_002b: ldloc.2IL_002c: newobj instance void class CSharpStudy1.Test`1<string>::.ctor(!0) IL_0031: stloc.3IL_0032: ldstr "String:"IL_0037: ldloc.3IL_0038: ldfld !0 class CSharpStudy1.Test`1<string>::objIL_003d: call string [mscorlib]System.String::Concat(string,string)IL_0042: call void [mscorlib]System.Console::WriteLine(string)IL_0047: nopIL_0048: call int32 [mscorlib]System.Console::Read()IL_004d: popIL_004e: ret} // end of method Program::Main再来看看Test类中构造函数的元数据.method public hidebysig specialname rtspecialnameinstance void .ctor(!T obj) cil managed{// Code size 17 (0x11).maxstack 8IL_0000: ldarg.0IL_0001: call instance void [mscorlib]System.Object::.ctor()IL_0006: nopIL_0007: nopIL_0008: ldarg.0IL_0009: ldarg.1IL_000a: stfld !0 class ConsoleCSharpTest1.Test`1<!T>::objIL_000f: nopIL_0010: ret} // end of method Test`1::.ctor1、第一轮编译时，编译器只为Test<T>类型产生“泛型版”的IL代码与元数据——并不进行泛型的实例化，T在中间只充当占位符。

泛型 get方法什么是泛型？在编程中，泛型是指一种将类型参数化的机制。

它允许我们编写可以处理多种类型的代码，而不需要为每种类型编写重复的代码。

通过使用泛型，我们可以提高代码的复用性、可读性和安全性。

泛型的核心思想是类型参数化，即将类型作为参数传递给方法或类。

这样一来，我们就可以在编译时确定类型，并且可以在代码中使用该类型进行操作。

泛型可以应用于类、接口、方法等各种场景。

泛型 get方法的作用泛型 get方法是一种用于获取对象的方法，它具有以下特点：1.可以处理多种类型的对象，提高代码的复用性；2.在编译时确定类型，提高代码的安全性；3.可以返回指定类型的对象，减少类型转换的代码。

实现泛型 get方法的方式在Java中，我们可以通过以下几种方式来实现泛型 get方法：1. 使用泛型类我们可以创建一个泛型类，并在类中定义一个泛型 get方法。

这样一来，我们就可以通过实例化泛型类并调用泛型 get方法来获取指定类型的对象。

public class GenericClass<T> {private T value;public GenericClass(T value) {this.value = value;}public T getValue() {return value;}}通过上述代码，我们可以创建一个泛型类GenericClass，并定义了一个泛型 get方法getValue()。

该方法可以返回指定类型的对象。

使用泛型类的示例代码如下：GenericClass<String> stringGenericClass = new GenericClass<>("Hello");String stringValue = stringGenericClass.getValue();System.out.println(stringValue); // 输出：HelloGenericClass<Integer> integerGenericClass = new GenericClass<>(123);Integer integerValue = integerGenericClass.getValue();System.out.println(integerValue); // 输出：123通过实例化GenericClass类并传入不同的类型参数，我们可以分别获取到String 类型和Integer类型的对象，而不需要编写重复的代码。