网站建设合理性/太原seo外包平台

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<int> generic1 = new Generic<int>(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> {@Overridepublic T getValue() {return super.getValue();}
}

1.4.泛型接口的使用

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

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

// 我们可以创建一个非泛型类 ClassB 来实现这个接口，并明确 T 的类型为 String：
public class ClassB implements InterfaceA<String> {@Overridepublic 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;}@Overridepublic 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与返回值中间<T>非常重要，可以理解为声明此方法为泛型方法。
(2)只有声明了<T>的方法才是泛型方法，泛型类中的使用了泛型的成员方法并不是泛型方法。
(3)<T>表明该方法将使用泛型类型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要遵循前面的<E>return list.get(random.nextInt(list.size()));}
}

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也可以改为NumberSystem.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;}@Overridepublic 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;}@Overridepublic 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;}@Overridepublic 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>表示要对Animal这个数据类型进行比较
class Comprator1 implements Comparator<Animal> {@Overridepublic int compare(Animal o1, Animal o2) {return o1.name.compareTo(o2.name);}
}// 泛型接口的使用：实现类不是泛型类，接口要明确数据类型。
class Comprator2 implements Comparator<Cat> {@Overridepublic int compare(Cat o1, Cat o2) {return o1.age - o2.age;}
}class Comprator3 implements Comparator<MiniCat> {@Overridepublic 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<Integer> 和 ArrayList<String> 等类型，在编译后都会变成 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<String>[] listArr = new ArrayList<String>[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<T>, 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<T> 类型的 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<T>

· Constructor<T>

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