• Java泛型--什么是泛型？

    https://www.bilibili.com/video/BV1xJ411n77R?p=5&vd_source=bb1fced25254581cf052adea5e87a1ff

    1.泛型类、接口

    1.1.泛型类

    泛型类的定义

    class 类名称 <泛型标识, 泛型标识, ...> {
  private 泛型标识 变量名;
  ......
}

    • 1
    • 2
    • 3
    • 4

    常用的泛型标识：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 + '}';
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    }

    
**泛型类的使用**

```java
类名<具体的数据类型> 对象名 = new 类名<具体的数据类型>();

Java1.7以后，后面的<>中的具体的数据类型可以省略不写
类名<具体的数据类型> 对象名 = new 类名<>();

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    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
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28

    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;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    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
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

    1.3.泛型类派生子类

    子类也是泛型类，子类和父类的泛型类型要一致

    class ChildGeneric<T> extends Generic<T>

    • 1

    子类不是泛型类，父类要明确泛型的数据类型

    语法：class ChildGeneric extends Generic<String>

    • 1
    package org.example;

public class Parent<E> {
    private E value;

    public E getValue() {
        return value;
    }

    public void setValue(E value) {
        this.value = value;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    package org.example;

public class Child<T> extends Parent<T> {
    @Override
    public T getValue() {
        return super.getValue();
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    1.4.泛型接口的使用

    实现类不是泛型类，接口要明确数据类型：

    // 例如，假设我们有一个泛型接口 InterfaceA：
public interface InterfaceA<T> {
    void method(T t);
}

    • 1
    • 2
    • 3
    • 4
    // 我们可以创建一个非泛型类 ClassB 来实现这个接口，并明确 T 的类型为 String：
public class ClassB implements InterfaceA<String> {
    @Override
    public void method(String s) {
        System.out.println(s);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    //在这个例子中，ClassB 不是一个泛型类，但它实现了一个泛型接口，并且在实现接口时明确了 T 的类型为 String。因此，当我们实例化 ClassB 时，不需要指定数据类型：
ClassB b = new ClassB();
b.method("Hello, world!");

    • 1
    • 2
    • 3

    实现类是泛型类，实现类和接口的泛型类型要一致：

    package org.example;

// 定义一个Generator接口，数据类型是T
public interface Generator<T> {
    T getKey();
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    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;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    public class Main{
    public static void main( String args[] ) {
        Pair<String, Integer> pair = new Pair<>("coung", 100);
        System.out.println(pair.getKey());;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    2.泛型方法

    修饰符 <T, E, ...> 返回值类型 方法名(形参列表) {
  方法体...
}

    • 1
    • 2
    • 3

    (1)public与返回值中间非常重要，可以理解为声明此方法为泛型方法。
    (2)只有声明了的方法才是泛型方法，泛型类中的使用了泛型的成员方法并不是泛型方法。
    (3)表明该方法将使用泛型类型T，此时才可以在方法汇总使用泛型类型T。
    (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要遵循前面的
        return list.get(random.nextInt(list.size()));
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    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
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    (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;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    下面实现是会报错的，因为虽然他们的泛型类型不同，但是他们本质还是同一个类，所以两个下面两个函数的参数本质还是个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);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24

    因此引入了类型通配符：

    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);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    3.2.类型通配符上限

    类/接口<? extends 实参类型>

    • 1

    要求泛型的类型，只能是实参类型，或实参类型的子类类型。比如，下面最大可以传到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;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    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);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    再举个例子，加深对类型通配符上限用法

    package demo08;

public class Animal {
}

    • 1
    • 2
    • 3
    • 4
    package demo08;

public class Cat extends Animal{
}

    • 1
    • 2
    • 3
    • 4
    package demo08;

public class MiniCat extends Cat {
}

    • 1
    • 2
    • 3
    • 4
    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);
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25

    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);
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26

    TreeSet的使用案例解读类型通配符下限。我们使用到TreeSet类

    查看TreeSet源代码：表达式中的 ? super E 是一个通配符类型。这意味着可以传递任何 Comparator<E> 或者它的父类的实例。
public TreeSet(Comparator<? super E> comparator)

    • 1
    • 2

    代码如下所示：

    package demo08;

public class Animal {
    public String name;
    public Animal(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Animal{" +
                "name='" + name + '\'' +
                '}';
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    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 + '\'' +
                '}';
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    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 + '\'' +
                '}';
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    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;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42

    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());
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    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
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

    解决方案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);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23

    解决方案2：可以通过java.lang.reflect.Array的newInstance(Class, int)创建T[]数组。

    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;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    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()));;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    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();
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
  • 相关阅读:
    Vue3中v-if与v-for、多事件处理器即案件修饰符、$attrs、$root和$parent
    制作一个模板
    如何获取standard cell各端口的作用
    【Mysql系列】01_查询+排序
    MariaDB落幕和思考
    语音合成 - TTS pyttsx3
    基于Syntiant TinyML Board与Edge Impulse的LED语音控制(Arduino/C++)
    mac上安装docker并运行kubernetes
    netdata 监控软件安装与学习
    2023-10-27 LeetCode每日一题（切割后面积最大的蛋糕）
  • 原文地址：https://blog.csdn.net/weixin_40981660/article/details/132909192