Java泛型--什么是泛型？
https://www.bilibili.com/video/BV1xJ411n77R?p=5&vd_source=bb1fced25254581cf052adea5e87a1ff
1.泛型类、接口
1.1.泛型类
泛型类的定义
class 类名称 <泛型标识, 泛型标识, ...> {
private 泛型标识 变量名;
......
}
常用的泛型标识：T、E、K、V
```java
package org.example;
public class Generic {
private T key;
public Generic(T key) {
this.key = key;
}
// alt+insert快速生成get和set方法
public T getKey() {
return key;
}
public void setKey(T key) {
this.key = key;
}
@Override
public String toString(){
return "Generic{" + "key=" + key + '}';
}
}
**泛型类的使用**
```java
类名<具体的数据类型> 对象名 = new 类名<具体的数据类型>();
Java1.7以后，后面的<>中的具体的数据类型可以省略不写
类名<具体的数据类型> 对象名 = new 类名<>();
public class Main{
public static void main( String args[] ) {
// 1.泛型类在创建对象的时候，通过【类名<具体的数据类型>】来指定操作的具体数据类型
Generic<String> strGeneric = new Generic<>("abc");
String key1 = strGeneric.getKey();
System.out.println("key1：" + key1);
System.out.printf("key1：%s", key1);
System.out.println("----------------------------");
Generic<Integer> intGeneric = new Generic<>(100);
int key2 = intGeneric.getKey();
System.out.println("key2:" + key2);
System.out.println("----------------------------");
// 2.泛型类在创建对象的时候，没有指定类型，将按照Object类型来操作
Generic generic = new Generic("ABC");
Object key3 = generic.getKey();
System.out.println("key3：" + key3);
// 3.泛型类，不支持基本数据类型。
// Generic generic1 = new Generic(100);
System.out.println("----------------------------");
// 4.同一泛型类，根据不同的数据类型创建的对象，本质上是同一类型。
System.out.println(intGeneric.getClass());
System.out.println(strGeneric.getClass());
System.out.println(intGeneric.getClass() == strGeneric.getClass());
}
}
1.2.泛型类–使用
package org.example;
import java.util.ArrayList;
import java.util.Random;
public class ProductGetter<T> {
Random random = new Random();
// 奖品
private T product;
// 奖品集合
ArrayList<T> list = new ArrayList<>();
// 添加奖品
public void addProduct(T t){
list.add(t);
}
// 抽奖
public T getProduct() {
// 获取的int的值不要超过list.size()长度
product = list.get(random.nextInt(list.size()));
return product;
}
}
public class Main{
public static void main( String args[] ) {
ProductGetter<String> stringProductGetter = new ProductGetter<>();
String[] strProducts = { "苹果手机", "华为手机", "扫地机器人", "咖啡机" };
for (int i=0; i < strProducts.length; i++) {
stringProductGetter.addProduct(strProducts[i]);
}
String product1 = stringProductGetter.getProduct();
System.out.println("恭喜您，你抽中了：" + product1);
System.out.println("----------------------------------");
ProductGetter<Integer> integerProductGetter = new ProductGetter<>();
int[] intProducts = {10000, 5000, 3000, 500, 300000};
for (int i=0; i<intProducts.length; i++) {
integerProductGetter.addProduct(intProducts[i]);
}
Integer product2 = integerProductGetter.getProduct();
System.out.println("恭喜您，你抽中了：" + product2);
}
}
1.3.泛型类派生子类
子类也是泛型类，子类和父类的泛型类型要一致
class ChildGeneric<T> extends Generic<T>
子类不是泛型类，父类要明确泛型的数据类型
语法：class ChildGeneric extends Generic<String>
package org.example;
public class Parent<E> {
private E value;
public E getValue() {
return value;
}
public void setValue(E value) {
this.value = value;
}
}
package org.example;
public class Child<T> extends Parent<T> {
@Override
public T getValue() {
return super.getValue();
}
}
1.4.泛型接口的使用
实现类不是泛型类，接口要明确数据类型：
// 例如，假设我们有一个泛型接口 InterfaceA：
public interface InterfaceA<T> {
void method(T t);
}
// 我们可以创建一个非泛型类 ClassB 来实现这个接口，并明确 T 的类型为 String：
public class ClassB implements InterfaceA<String> {
@Override
public void method(String s) {
System.out.println(s);
}
}
//在这个例子中，ClassB 不是一个泛型类，但它实现了一个泛型接口，并且在实现接口时明确了 T 的类型为 String。因此，当我们实例化 ClassB 时，不需要指定数据类型：
ClassB b = new ClassB();
b.method("Hello, world!");
实现类是泛型类，实现类和接口的泛型类型要一致：
package org.example;
// 定义一个Generator接口，数据类型是T
public interface Generator<T> {
T getKey();
}
package org.example;
public class Pair<T, E> implements Generator<T>{
private T key;
private E value;
public Pair(T key, E value) {
this.key = key;
this.value = value;
}
@Override
public T getKey() {
return this.key;
}
public E getValue() {
return this.value;
}
public void setKey(T key) {
this.key = key;
}
public void setValue(E value) {
this.value = value;
}
}
public class Main{
public static void main( String args[] ) {
Pair<String, Integer> pair = new Pair<>("coung", 100);
System.out.println(pair.getKey());;
}
}
2.泛型方法
修饰符 <T, E, ...> 返回值类型 方法名(形参列表) {
方法体...
}
(1)public与返回值中间
(2)只有声明了
(3)
(4)与泛型类的定义一样，此处T可以随便写为任意标识，场景的如T、E、K、V等形式的参数常用于表示泛型。
package org.example;
import java.util.ArrayList;
import java.util.Random;
public class ProductGetter<T> {
Random random = new Random();
// 奖品
private T product;
// 奖品集合
ArrayList<T> list = new ArrayList<>();
// 添加奖品
public void addProduct(T t){
list.add(t);
}
// 抽奖
public T getProduct() {
// 获取的int的值不要超过list.size()长度
product = list.get(random.nextInt(list.size()));
return product;
}
public <E> E getProduct1(ArrayList<E> list) { // ArrayList里的E要遵循前面的package demo06;
import org.example.ProductGetter;
import java.util.ArrayList;
public class Test06 {
public static void main(String[] args) {
ProductGetter<Integer> productGetter = new ProductGetter<>();
ArrayList<String> strList = new ArrayList<>();
strList.add("笔记本电脑");
strList.add("华为手机");
strList.add("苹果手机");
String product1 = productGetter.getProduct1(strList);
System.out.println(product1 + "\t" + product1.getClass());
System.out.println(product1 + "\t" + product1.getClass().getSimpleName());
}
}
(1)泛型方法能使方法独立于类而产生变化
(2)如果static方法要使用泛型能力，就必须使其成为泛型方法
3.类型通配符
3.1.为什么需要类型通配符
类型通配符一般是使用"?"代表具体的类型实参。所以，类型通配符是类型实参，而不是类型形参。
虽然他们的泛型类型不同，但是他们本质还是同一个类，所以两个下面两个函数的参数本质还是个Box，并没有实现方法重载：
package demo07;
public class Box<E> {
private E first;
public E getFirst() {
return first;
}
public void setFirst(E first) {
this.first = first;
}
}
下面实现是会报错的，因为虽然他们的泛型类型不同，但是他们本质还是同一个类，所以两个下面两个函数的参数本质还是个Box，并没有实现方法重载。
package demo07;
public class Test07 {
public static void main(String[] args) {
Box<Number> box1 = new Box<>();
box1.setFirst(100);
showBox(box1);
Box<Integer> box2 = new Box<>();
box2.setFirst(200);
showBox(box2);
}
// 虽然他们的泛型类型不同，但是他们本质还是同一个类，所以下面两个函数的参数本质还是个Box，并没有实现方法重载。
public static void showBox(Box<Number> box) {
Number first = box.getFirst();
System.out.println(first);
}
public static void showBox(Box<Integer> box) {
Number first = box.getFirst();
System.out.println(first);
}
}
因此引入了类型通配符：
package demo07;
public class Test07 {
public static void main(String[] args) {
Box<Number> box1 = new Box<>();
box1.setFirst(100);
showBox(box1);
Box<Integer> box2 = new Box<>();
box2.setFirst(200);
showBox(box2);
}
public static void showBox(Box<?> box) {
Object first = box.getFirst();
System.out.println(first);
}
}
3.2.类型通配符上限
类/接口<? extends 实参类型>
要求泛型的类型，只能是实参类型，或实参类型的子类类型。比如，下面最大可以传到Number，或者Number的子类(下面的Object就是Number的子类)：
package demo07;
public class Box<E> {
private E first;
public E getFirst() {
return first;
}
public void setFirst(E first) {
this.first = first;
}
}
package demo07;
public class Test07 {
public static void main(String[] args) {
Box<Number> box1 = new Box<>();
box1.setFirst(100);
showBox(box1);
Box<Integer> box2 = new Box<>();
box2.setFirst(200);
showBox(box2);
}
public static void showBox(Box<? extends Number> box) {
Object first = box.getFirst(); // Object也可以改为Number
System.out.println(first);
}
}
再举个例子，加深对类型通配符上限用法
package demo08;
public class Animal {
}
package demo08;
public class Cat extends Animal{
}
package demo08;
public class MiniCat extends Cat {
}
package demo08;
import java.util.ArrayList;
public class Test08 {
public static void main(String[] args) {
ArrayList<Animal> animals = new ArrayList<>();
ArrayList<Cat> cats = new ArrayList<>();
ArrayList<MiniCat> miniCats = new ArrayList<>();
// showAnimal(animals); // 报错：因为类型通配符的上限，传递的集合类型，只能是Cat或Cat的子类类型。
showAnimal(cats);
showAnimal(miniCats);
}
public static void showAnimal(ArrayList<? extends Cat> list) {
// 报错：类型通配符，不能用下列方法指定增加类型，因为泛型通配符，你并不知道list里面的元素是什么数据类型。
// list.add(new Animal());
// list.add(new Cat());
for (int i = 0; i < list.size(); i++) {
Cat cat = list.get(i);
System.out.println(cat);
}
}
}
3.3.类型通配符的下限
package demo08;
import java.util.ArrayList;
// 集合
import java.util.List;
public class Test08 {
public static void main(String[] args) {
ArrayList<Animal> animals = new ArrayList<>();
ArrayList<Cat> cats = new ArrayList<>();
ArrayList<MiniCat> miniCats = new ArrayList<>();
showAnimal(animals); // 因为Animal类型是Cat的父类类型，因此可以传递
// showAnimal(miniCats); // 报错：因为不是Cat或Cat的父类类型，会报错
}
/**
* 类型通配符下限，要求集合只能是Cat或Cat的父类类型
*/
// 表达式中的? super Cat是一个类型通配符。接受一个List作为参数，这个List的元素类型是Cat或者Cat的任何父类。
public static void showAnimal(List<? super Cat> list) {
for (Object o : list) {
System.out.println(o);
}
}
}
TreeSet的使用案例解读类型通配符下限。我们使用到TreeSet类
查看TreeSet源代码：表达式中的 ? super E 是一个通配符类型。这意味着可以传递任何 Comparator<E> 或者它的父类的实例。
public TreeSet(Comparator<? super E> comparator)
代码如下所示：
package demo08;
public class Animal {
public String name;
public Animal(String name) {
this.name = name;
}
@Override
public String toString() {
return "Animal{" +
"name='" + name + '\'' +
'}';
}
}
package demo08;
public class Cat extends Animal{
public int age;
public Cat(String name, int age) {
super(name);
this.age = age;
}
@Override
public String toString() {
return "Cat{" +
"age=" + age +
", name='" + name + '\'' +
'}';
}
}
package demo08;
public class MiniCat extends Cat {
public int level;
public MiniCat(String name, int age, int level) {
super(name, age);
this.level = level;
}
@Override
public String toString() {
return "MiniCat{" +
"level=" + level +
", age=" + age +
", name='" + name + '\'' +
'}';
}
}
package demo08;
import java.util.Comparator;
// 在Java中，TreeSet 是一个实现了 SortedSet 接口的类，它可以确保集合中的元素按照某种特定的顺序进行排序。这个顺序可以是元素自然的顺序（例如数字的升序或降序），也可以是通过提供一个 Comparator 对象来定义的自定义顺序。
import java.util.TreeSet;
public class Test08 {
public static void main(String[] args) {
// 传递new Comprator2() 参数，其是一个 Comparator 对象，它定义了如何比较 Cat 对象。这意味着 TreeSet 将使用这个 Comparator 来决定元素的排序方式。
TreeSet<Cat> treeSet = new TreeSet<>(new Comprator2());
treeSet.add(new Cat("jerry", 20)); // java字符串要用双引号
treeSet.add(new Cat("amy", 22));
treeSet.add(new Cat("frank", 35));
treeSet.add(new Cat("jim", 15));
for (Cat cat: treeSet) {
System.out.println(cat);
}
}
}
// Comparator表示要对Animal这个数据类型进行比较
class Comprator1 implements Comparator<Animal> {
@Override
public int compare(Animal o1, Animal o2) {
return o1.name.compareTo(o2.name);
}
}
// 泛型接口的使用：实现类不是泛型类，接口要明确数据类型。
class Comprator2 implements Comparator<Cat> {
@Override
public int compare(Cat o1, Cat o2) {
return o1.age - o2.age;
}
}
class Comprator3 implements Comparator<MiniCat> {
@Override
public int compare(MiniCat o1, MiniCat o2) {
return o1.level - o2.level;
}
}
4.类型擦除
package demo09;
import java.util.ArrayList;
public class Test09 {
public static void main(String[] args) {
ArrayList<Integer> intList = new ArrayList<>();
ArrayList<String> strList = new ArrayList<>();
// 类型擦除：在代码中定义 ArrayList 和 ArrayList 等类型，在编译后都会变成 ArrayList ，JVM看到的只是ArrayList，而由泛型附加的类型信息对JVM是看不到的3。这就是类型擦除的基本概念
System.out.println(intList.getClass().getSimpleName());
System.out.println(strList.getClass().getSimpleName());
System.out.println(intList.getClass() == strList.getClass());
}
}
5.泛型与数组
package demo10;
import java.util.ArrayList;
public class Test10 {
public static void main(String[] args) {
// 报错：可以声明带泛型的数组引用，但是不能直接创建带泛型的数组对象
// ArrayList[] listArr = new ArrayList[5];
// 不能直接创建带泛型的数组对象，那么怎么办？可以将list的引用赋值给listArr。但会出现一个问题：listArr的元素类型要求String，但是listArr[0][0]指向的是Integer类型，类型检查还不会报错，只有运行之后才会报错。那又该怎么办？看下一块代码。
// 创建数组的基本方法：创建一个长度为5、元素数据类型为ArrayList的列表list。
ArrayList[] list = new ArrayList[5];
ArrayList<String>[] listArr = list;
ArrayList<Integer> intList = new ArrayList<>();
intList.add(100);
list[0] = intList;
String s = listArr[0].get(0);
System.out.println(s);
}
}
解决方案1：声明类型相同的数组
package demo10;
import java.util.ArrayList;
public class Test10 {
public static void main(String[] args) {
// 不变知识点：这种声明长度为5，元素类型都为String的数组。
ArrayList<String>[] listArr = new ArrayList[5];
ArrayList<Integer> intList = new ArrayList<>();
intList.add(100);
ArrayList<String> strList = new ArrayList<>();
strList.add("abc");
// 报错
// listArr[0] = intList;
listArr[0] = strList;
// 这行代码的意思是从一个列表数组 listArr 中获取第一个列表，然后从该列表中获取第一个元素，也就是说这是个二维数组。
String s = listArr[0].get(0);
System.out.println(s);
}
}
解决方案2：可以通过java.lang.reflect.Array的newInstance(Class
package demo10;
import java.lang.reflect.Array;
public class Fruit<T> {
// 报错：T是什么数据类型都无法确认，无法直接使用T[3]，只有new ArrayList[3]才可以，但T不一定是ArrayList。
// private T[] array = new T[3];
private T[] array;
// Fruit 类的一个构造函数，它接受两个参数：一个是 Class 类型的 clz，另一个是 int 类型的 length。
public Fruit(Class<T> clz, int length) {
// 通过Array.newInstance创建泛型数组
array = (T[]) Array.newInstance(clz, length);
}
/**
* 填充数组
* @param index
* @param item
*/
public void put(int index, T item) {
array[index] = item;
}
/**
* 获取数组元素
* @param index
* @return
*/
public T get(int index) {
return array[index];
}
public T[] getArray() {
return array;
}
}
package demo10;
import java.util.Arrays;
public class Test10 {
public static void main(String[] args) {
Fruit<String> fruit = new Fruit<>(String.class, 3);
fruit.put(0, "苹果");
fruit.put(1, "西瓜");
fruit.put(2, "香蕉");
System.out.println(Arrays.toString(fruit.getArray()));;
}
}
6.泛型和反射
反射常用的泛型类
· Class
· Constructor
package demo11;
import java.lang.reflect.Constructor;
public class Test11 {
public static void main(String[] args) throws Exception {
// 获取 Person 类的 Class 对象。在Java中，每个类型都有一个对应的 Class 对象。
Class<Person> personClass = Person.class;
// 获取 Person 类的无参数构造函数。getConstructor() 方法是 Class 类的一个方法，用于获取类的公共（public）构造函数。
Constructor<Person> constructor = personClass.getConstructor();
// 调用 Constructor 对象的 newInstance() 方法来创建 Person 类的一个新实例。
Person person = constructor.newInstance();
}
}