1、泛型类：
测试代码：
创建一个Box类;
package settest.com;
public class Box<T> { // T stands for "Type" - T是一个占位符，用于表示具体的类型 // 类的内部可以使用T作为类型声明变量 private T t; // 构造方法，用于设置对象的值 public void set(T t) { this.t = t; } // 获取存储的对象 public T get() { return t; }
}测试代码：
package settest.com;
public class GenericBoxTest { public static void main(String[] args) { // 创建一个可以存储String的Box Box<String> stringBox = new Box<>(); stringBox.set("Hello World"); System.out.println(stringBox.get()); // 创建一个可以存储Integer的Box Box<Integer> integerBox = new Box<>(); integerBox.set(100); System.out.println(integerBox.get()); // 下面的代码会引发编译错误，因为类型不匹配 //stringBox.set(100); // 错误：类型不兼容。 }
}运行结果如下：
2、泛型方法：
测试代码1：
package settest.com;public class GenericMethodTest {// 泛型方法printArray，可以接受任何类型的数组并打印。public static <E> void printArray(E[] inputArray) {// 显示数组元素for (E element : inputArray) {System.out.printf("%s ", element);}System.out.println();}public static void main(String[] args) {// 创建不同类型数组： Integer, Double 和 CharacterInteger[] intArray = { 1, 2, 3, 4, 5 };Double[] doubleArray = { 1.1, 2.2, 3.3, 4.4 };Character[] charArray = { 'H', 'E', 'L', 'L', 'O' };String[] stringArray = { "Java", "Generics", "Method" };System.out.println("整型数组元素为:");printArray(intArray); // 传递一个整型数组System.out.println("\n双精度型数组元素为:");printArray(doubleArray); // 传递一个双精度型数组System.out.println("\n字符型数组元素为:");printArray(charArray); // 传递一个字符型数组System.out.println("\n字符串数组元素为:");printArray(stringArray); // 传递一个字符串数组}
}运行结果如下：
测试代码2：
package maptest.com;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List; public class ListUtilsAndMain { // 泛型方法public static <T extends Comparable<? super T>> void sort(List<T> list) { //排序，List是泛型，需要确保列表中的元素类型是可以比较的（即实现Comparable接口）Collections.sort(list); } public static void reverse(List<?> list) { //反转列表中的元素顺序不需要列表元素实现任何接口，它只是简单地交换列表中的元素位置。Collections.reverse(list); } public static void shuffle(List<?> list) { //打乱列表中的元素顺序使用一个随机源重新排列元素Collections.shuffle(list); } public static void main(String[] args) { // ArrayList 确保列表是可修改的 List<Integer> numbers = new ArrayList<>(Arrays.asList(5, 3, 8, 4, 2)); System.out.println("Original: " + numbers); sort(numbers); System.out.println("Sorted: " + numbers); reverse(numbers); System.out.println("Reversed: " + numbers); shuffle(numbers); System.out.println("Shuffled: " + numbers); }
}运行结果如下;
3、泛型接口：
创建一个 Holder泛型接口：
package settest.com;
//定义泛型接口Holder，它有一个泛型方法get用于获取存储的数据。
public interface Holder<T> { // 获取存储的数据 T get(); }创建一个SimpleHolder类：
package settest.com;
//创建一个具体的SimpleHolder类，该类可以存储并返回任何类型的数据。
public class SimpleHolder<T> implements Holder<T> {private T data;public SimpleHolder(T data) {this.data = data;}@Overridepublic T get() {return data;}
}测试代码：
package settest.com;
//在需要封装单个值或对象时非常有用。
public class GenericInterfaceTest { public static void main(String[] args) { // 创建一个持有String的Holder Holder<String> stringHolder = new SimpleHolder<>("Hello, World!"); System.out.println(stringHolder.get()); // 创建一个持有Integer的Holder Holder<Integer> integerHolder = new SimpleHolder<>(42); System.out.println(integerHolder.get()); }
}运行结果如下：
4、类型通配符;
测试代码：
能力有限，希望各位朋友，各位网友别见笑。
/无界通配符适合只读操作且不关心具体类型，上界通配符适合只读操作且需要子类型关系，下界通配符适合写操作且需要添加特定类型或其子类型的元素。
class Animal {
}class Dog extends Animal {
}class Cat extends Animal {
}public class WildcardExample {public static void main(String[] args) {// 无界通配符List<?> unboundedList = new ArrayList<>();unboundedList = new ArrayList<Animal>();// 无法添加除null之外的任何元素// unboundedList.add(new Animal());unboundedList.add(null);if (!unboundedList.isEmpty()) {// 如果列表不为空，安全地访问第一个元素// 可以读取元素Object element = unboundedList.get(0);System.out.println("第一个元素是: " + element);} else {// 如果列表为空，打印一条消息System.out.println("列表是空的，没有元素可以访问。");}// 上界通配符List<? extends Animal> upperBoundedList = new ArrayList<>();upperBoundedList = new ArrayList<Dog>();// 无法添加任何元素// upperBoundedList.add(new Dog());// 可以读取元素，且元素类型为Animal或其子类if (!upperBoundedList.isEmpty()) {// 如果列表不为空，安全地访问第一个元素Animal animal = upperBoundedList.get(0);System.out.println("第一个元素是: " + animal);} else {// 如果列表为空，打印一条消息System.out.println("列表是空的，没有元素可以访问。");}// 下界通配符List<? super Dog> lowerBoundedList = new ArrayList<>();// 可以添加Dog及其子类元素lowerBoundedList.add(new Dog());// 可以读取元素，但需要进行类型转换Object obj = lowerBoundedList.get(0);if (obj instanceof Dog) {Dog dog = (Dog) obj;System.out.println("Dog: " + dog);}}
}
运行结果如下;
5、可变参数：
1. Arrays.asList(T... a)
方法签名：public static <T> List<T> asList(T... a)
功能：该方法将传入的数组转换成一个固定大小的列表。这个列表是由原始数组支持的，因此对列表的非结构性修改（即修改元素的值，如果元素是可变的）会反映到原始数组中，反之亦然。但是，这个列表的大小是固定的，尝试进行结构性修改（如添加、删除元素）会抛出ConcurrentModificationException异常（如果迭代器正在使用中）或UnsupportedOperationException（如果直接调用add、remove等方法）。
限制：返回的列表大小固定，不支持增删操作，但支持修改元素（如果元素本身是可变的）。
2. List.of(E... elements)
方法签名：public static <E> List<E> of(E... elements)（这是Java 9及以后版本引入的）
功能：该方法创建了一个包含任意数量元素的不可变列表。这个列表的大小在创建时就确定了，之后不能修改（即不支持增删改操作）。
限制：返回的列表不可变，不支持增删改操作。
3. Set.of(E... elements)
方法签名：public static <E> Set<E> of(E... elements)（这是Java 9及以后版本引入的）
功能：该方法创建了一个包含任意数量元素的不可变集合。这个集合不允许重复元素，如果尝试添加重复元素，将抛出IllegalArgumentException。集合的大小在创建时就确定了，之后不能修改（即不支持增删改操作）。
限制：返回的集合不可变，不支持增删改操作，且元素唯一，不允许重复。
总结
Arrays.asList返回的列表大小固定，不支持增删操作，但支持修改元素（如果元素本身是可变的）。
List.of和Set.of返回的都是不可变集合，不支持增删改操作。List.of可以包含重复元素，而Set.of则不允许重复元素。
测试代码1：
package settest.com;public class VarargsExample {// 第一个参数是String类型，第二个可变参数是int类型。// 实际上，不会在同一个方法中使用多个可变参数，而是使用单个可变参数或者不使用可变参数。public void printMessages(String prefix, int... numbers) {for (int number : numbers) {System.out.println(prefix + ": " + number);}}public static void main(String[] args) {VarargsExample example = new VarargsExample();example.printMessages("Number", 1, 2, 3, 4, 5);// 如果将可变参数放在非可变参数之前，编译器会报错。// public void wrongMethod(int... numbers, String prefix) {...}}
}运行结果如下：
测试代码2：
package settest.com;
import java.util.*;public class VariableParameters {public static void main(String[] args) {// 使用 Arrays.asList 方法创建固定大小的不可变 ListList<String> fixedList = Arrays.asList("apple", "banana", "cherry");System.out.println("Fixed List: " + fixedList);// 使用 List.of 方法创建不可变 ListList<String> immutableList = List.of("apple", "banana", "cherry");System.out.println("Immutable List: " + immutableList);// 尝试修改不可变 List，会抛出 UnsupportedOperationException 异常// immutableList.add("date");// 使用 Set.of 方法创建不可变 SetSet<String> immutableSet = Set.of("apple", "banana", "cherry");System.out.println("Immutable Set: " + immutableSet);// 尝试添加重复元素到不可变 Set，会抛出 IllegalArgumentException 异常// Set<String> immutableSetWithDuplicate = Set.of("apple", "banana", "apple");// 尝试修改不可变 Set，会抛出 UnsupportedOperationException 异常// immutableSet.add("date");}
}运行结果如下：
