实验12 泛型与实用类

go 结构体定义泛型（实用版）目录1.Go 语言中的结构体2.结构体的定义和声明3.泛型结构体的定义4.使用泛型结构体的示例正文在 Go 语言中，结构体是一种复合类型，用于将多个具有不同类型的字段组合在一起。

结构体可以看作是一个包含多个字段的记录，每个字段可以具有不同的类型。

结构体在 Go 语言中是一种非常灵活的类型，可以用于表示复杂的数据结构。

结构体的定义和声明与普通类型相似，使用`struct`关键字。

以下是一个简单的结构体定义示例：```gotype Person struct {Name stringAge intGender string}```在这个例子中，我们定义了一个名为`Person`的结构体，包含三个字段：`Name`、`Age`和`Gender`。

这些字段分别具有`string`、`int`和`string`类型。

从 Go 1.18 版本开始，Go 语言引入了泛型编程。

泛型是一种编写通用代码的方法，允许我们编写可以处理不同类型的代码，而不仅仅是特定类型。

为了使用泛型结构体，我们需要在结构体定义中添加一个泛型参数。

以下是一个泛型结构体的定义示例：```gotype GenericStruct[T any] struct {Value TDescription string}```在这个例子中，我们定义了一个名为`GenericStruct`的泛型结构体，它包含两个字段：`Value`和`Description`。

`Value`字段的类型是泛型参数`T`，这意味着它可以容纳任何类型的值。

`Description`字段的类型是`string`。

使用泛型结构体的示例：```gopackage mainimport ("fmt")func main() {// 定义一个整数类型的泛型结构体实例intStruct := GenericStruct[int]{Value: 42, Description: "这是一个整数"}fmt.Println(intStruct)// 定义一个字符串类型的泛型结构体实例strStruct := GenericStruct[string]{Value: "Hello, world!", Description: "这是一个字符串"}fmt.Println(strStruct)}```在这个例子中，我们创建了两个泛型结构体实例，分别使用`int`和`string`类型。

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

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

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

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

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

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

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

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

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

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

java中泛型的作用泛型是Java语言的一项强大特性，它允许我们在定义类、接口、方法等时使用类型参数，从而使得代码更加灵活和可复用。

泛型的作用主要体现在以下几个方面：1.类型安全：泛型提供了一种编译时的类型检查机制，可以在编译阶段捕获一些类型错误。

通过使用泛型，我们可以在编译时检查参数类型是否匹配，避免了在运行时可能产生的类型转换异常。

2.代码复用：使用泛型可以编写更加通用的代码，提高代码的可复用性。

通过定义泛型类或泛型方法，我们可以将相似代码逻辑抽象出来，以适用于不同的类型，从而减少重复编写代码的工作量。

3. 集合类的类型安全：泛型集合类（如ArrayList、HashSet等）可以指定存储的元素类型，使得集合中的元素都是指定类型。

这样可以在编译时就避免了将错误类型的对象存入集合的问题，并且在读取集合中的元素时可以直接获取到正确类型的对象，避免了类型转换的繁琐与风险。

4. 简化代码：在没有泛型之前，我们可能需要编写各种类型的容器类，如IntList、StringList等，用于存储不同类型的元素。

而有了泛型，我们可以使用通用的容器类List，通过指定泛型参数的方式来存储不同类型的元素，从而大大简化了代码结构。

5.提高性能：使用泛型可以避免一些不必要的类型转换，从而提高程序的执行效率。

在编译时确定了泛型类型后，编译器会自动插入类型转换的代码，避免了动态类型检查所带来的性能损失。

6.编写更安全的API：通过使用泛型，我们可以将一些类型相关的约定和规范编码到API中，从而可以在编译时强制执行这些约定，提高代码的安全性和可靠性。

7.代码逻辑清晰：泛型可以使代码更具可读性和可维护性。

通过使用泛型，我们可以在编程时直观地表达出代码逻辑的意图，从而使代码更加清晰明了。

总之，泛型是Java语言中一项非常重要的特性，它提供了更高层次的抽象和灵活性，使得我们可以编写更加通用、类型安全且可复用的代码。

通过正确地使用泛型，我们可以提高代码的质量和可维护性，并且更容易适应未来的需求变化。

泛型方法泛型方法。

泛型方法是一种在编程中非常重要的概念，它能够帮助我们编写更加灵活、通用的代码。

在本文中，我们将深入探讨泛型方法的定义、特点、以及如何在实际编程中应用泛型方法。

首先，让我们来了解一下泛型方法的定义。

泛型方法是一种在编程中使用类型参数来增加代码的灵活性和通用性的方法。

通过泛型方法，我们可以在方法中使用一个或多个类型参数，从而实现对不同类型的数据进行操作，而无需针对每种类型编写不同的方法。

泛型方法有几个重要的特点。

首先，泛型方法可以与泛型类和泛型接口结合使用，从而实现更加灵活的编程。

其次，泛型方法可以在编译时进行类型检查，从而避免在运行时出现类型错误。

此外，泛型方法还可以减少代码的重复性，提高代码的可维护性和可读性。

在实际编程中，我们可以通过泛型方法来实现对不同类型的数据进行操作。

例如，我们可以编写一个泛型方法来对数组进行排序，而无需针对每种类型的数组编写不同的排序方法。

又如，我们可以编写一个泛型方法来查找数组中的最大值或最小值，而无需针对每种类型的数组编写不同的查找方法。

除此之外，泛型方法还可以应用于集合类中。

通过泛型方法，我们可以实现对不同类型的集合进行操作，从而实现更加灵活和通用的代码。

例如，我们可以编写一个泛型方法来遍历集合中的元素，而无需针对每种类型的集合编写不同的遍历方法。

总之，泛型方法是一种非常重要的编程概念，它能够帮助我们编写更加灵活、通用的代码。

通过泛型方法，我们可以实现对不同类型的数据进行操作，而无需针对每种类型编写不同的方法。

因此，在实际编程中，我们应该充分利用泛型方法，从而提高代码的灵活性、可维护性和可读性。

java 泛型用法实例Java 泛型是一种将类型参数化的方法，通过它可以在编译时检测到类型不匹配的错误。

泛型的核心思想是参数化类型，实现了代码的重用性和类型的安全性。

下面我将通过一些实例来介绍 Java 泛型的用法。

1. 泛型类泛型类是指在定义类时使用类型参数来代替真实类型。

例如，我们可以定义如下的一个泛型类来表示一个有序对（Ordered Pair）：```public class OrderedPair<K, V> {private K key;private V value;public OrderedPair(K key, V value) {this.key = key;this.value = value;}public K getKey() {return key;}public V getValue() {return value;}}```在上面的例子中，`K` 和 `V` 是类型参数，用来代替真实的类型。

在使用该类时，我们可以指定实际的类型来创建对象：```OrderedPair<Integer, String> p1 = new OrderedPair<Integer, String>(1, "One");OrderedPair<String, Integer> p2 = new OrderedPair<String, Integer>("Two", 2);```2. 泛型方法泛型方法是指在定义方法时使用类型参数来代替方法中的参数类型。

例如，我们可以定义如下的一个泛型方法来交换数组中的两个元素：```public static <T> void swap(T[] array, int i, int j) {T temp = array[i];array[i] = array[j];array[j] = temp;}```在上面的例子中，`<T>` 表示该方法是一个泛型方法，类型参数 `T` 用来代替真实的类型。

泛型（⼀）泛型类和泛型⽅法⼀、泛型的概念 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.理解泛型的作用，掌握泛型类的声明及实例化的方法
2.掌握枚举类的定义和使用
3.掌握内部类的定义和使用方法
4.掌握匿名类的使用方法
实验要求和过程
1.修改书上程序7-4，要求利用具有泛型机制的Comparable<T>实现。

2.模仿程序8-5，利用匿名内部类实现对Account数组进行按照属性id的
大小进行排序。

3.在java.util包中有一接口Comparator<T>，提供了比较器的功能。

请根据
此接口定义的比较方法，针对类Account中的余额字段，完成比较器类
的定义（声明成普通外部类）。

修改书上程序7-4，验证你的设计是否正
确。

（比较一下题目1和题目3异同）
评语：
教师签字：日期：年月日。

mockito 泛型返回值（实用版）目录1.介绍 Mockito 框架2.泛型返回值的概念3.Mockito 中如何使用泛型返回值4.泛型返回值的优势与使用场景5.示例代码演示正文一、介绍 Mockito 框架Mockito 是一个流行的 Java 库，用于创建和配置模拟对象，以便在单元测试中使用。

它可以帮助开发人员在不实际调用对象的情况下，模拟对象的行为和返回值。

这样可以有效地隔离测试代码与实际业务代码，提高测试的稳定性和可维护性。

二、泛型返回值的概念泛型是 Java 语言中一种强大的特性，允许我们编写更加通用、可重用的代码。

泛型返回值是泛型的一个应用场景，它指的是在方法返回值类型前使用泛型，使得返回值类型可以灵活地根据方法参数类型自动推断。

这种技术可以提高代码的灵活性和可读性。

三、Mockito 中如何使用泛型返回值在 Mockito 中，我们可以使用泛型返回值来模拟对象的返回值。

具体做法是，在创建模拟对象时，使用 `when()` 方法定义返回值，并在方法参数类型前添加泛型。

这样，当实际调用模拟对象的方法时，Mockito 会自动根据参数类型推断返回值类型，并返回相应的值。

四、泛型返回值的优势与使用场景泛型返回值具有以下优势：1.提高代码的灵活性和可读性，减少重复代码。

2.方便测试中模拟对象的返回值，提高测试质量。

泛型返回值适用于以下场景：1.当方法的返回值类型与参数类型密切相关，且不同的参数类型可能返回不同的值时。

2.当需要为模拟对象定义多个相似的方法时，可以使用泛型返回值简化代码。

五、示例代码演示下面是一个使用 Mockito 泛型返回值的示例：```javaimport org.mockito.Mockito;public class MockitoGenericReturnValueExample {public static void main(String[] args) {// 创建一个模拟对象Mockito<String> mockString =Mockito.mock(String.class);// 定义泛型返回值Mockito.when(mockString.length()).thenReturn(10);// 调用模拟对象的方法，返回泛型返回值System.out.println(mockString.length()); // 输出：10}}```综上所述，Mockito 泛型返回值是一种强大的技术，可以帮助开发人员在单元测试中更加灵活地模拟对象的行为和返回值。

java泛型类的定义和使用
Java泛型类是在Java SE 5中引入的一种新的编程模式，可以把参数化类型的参数作为泛型类的类型参数。

它是在编译时期类型检查，而不必在运行时期做类型强转，大大提升了Java程序的可敬性与可维护性。

使用Java泛型类的规则很简单：创建类的时候，可以定义一个类型参数，把它放到class关键字后面的尖括号中，它不是Object类型中的属性，也不是构造函数中的参数，而是一种可以用来定义全新模板类型的一种变量，就像早期使用C++模板编程一样。

如果要使用Java泛型类，首先需要定义类型参数，类型参数必须以小写字母开头，建议一次仅使用一个字母，以便更容易理解它是一个类型
参数，不能用原始类型表达（如int、long等），有了类型参数后，就可以在类声明中使用它，比
如List<T>把泛型T用在类声明，大大提高了代
码的重用性。

使用Java泛型类可以大大减少代码中出现错
误的可能性，带来更高的可维护性，面对复杂的
代码结构，可以定义遵循一定规范的类。

此外，Java泛型类还为开发商提供了多样的编程思路，使用它们可以更好地利用类的功能，提高代码的
可维护性、可敬性与扩展性。

总而言之，Java泛型类可以让我们的代码更加安全、可扩展、高效。