【Java数据结构】泛型详解+图文，通配符上界、下界

泛型的本质&＃xff1a;泛型是在JDK1.5引入的新的语法&＃xff0c;通俗讲&＃xff0c;泛型&＃xff1a;就是适用于许多许多类型。从代码上讲&＃xff0c;就是对类型实现了参数
化。
总的来说&＃xff0c;泛型就是把类型参数化了&＃xff0c;即给类型一个指定的参数&＃xff0c;在使用时指定参数具体的值&＃xff0c;这个类型就可以在使用的时候决定了&＃xff0c;这样就可以编写应用于多种类型的代码。

泛型的目的&＃xff1a;是指定当前容器&＃xff0c;要持有什么类型的对象&＃xff0c;让编译器去做检查&＃xff0c;检查类型的安全性&＃xff0c;并且所有的强制转换都是隐式转换的。此时&＃xff0c;就需要把类型&＃xff0c;作为参数传递&＃xff0c;提高了代码的复用性。

class 泛型类的名称<类型形参列表>{
//代码块内使用类型参数
}
class Student<T1,T2....Tn>{
}


• 泛型的继承

class 泛型类型名称<类型形参列表> extends 继承类<类型形参列表>
//示例
class Mike<Integer> extends Student<Integer>{

}
//可以只是用部分类型参数
class Rose<T1,T2..Tn> extends Student<T1>{

}


1.1 泛型的使用

• 泛型类代码实例&＃xff1a;
  

了解&＃xff1a;【命名规范】类型形参一般使用一个大写字母表示&＃xff0c;常用的名称有&＃xff1a;

1. 注释1处&＃xff1a;不能直接new泛型的数组
   我是先new一个Object数组&＃xff0c;然后强制转换为T类型

2. 注释2处&＃xff1a;类型(Student)后加入是指定当前类型,new Student<>&＃xff0c;这里的<>内可加也可不加Integer。
3. 注释3处&＃xff1a;不需要强制类型转换&＃xff0c;Integer是包装类&＃xff0c;可以自动拆箱和装箱。这也就提高了效率。
4. 注释4处&＃xff1a;代码编译报错&＃xff0c;因为在注释2处指定类的当前类型是Integer&＃xff0c;此时在注释4处&＃xff0c;存放元素时&＃xff0c;编译器就会帮助我们进行类型检查。

在JAVA中&＃xff0c;由于基本类型不是继承于Object&＃xff0c;为了在泛型代码中可以支持基本类型&＃xff0c;JAVA给每个基本类型都对应了一个包装类。

• 需要特别注意的是&＃xff1a;int和char的包装类是Integer和Character&＃xff0c;其他的基本类型的包装类都是基本类型首字母大写。

2.1 装箱和拆箱

int a &＃61; 10;
/*
装箱操作
*/
Integer b &＃61; Integer.value(a); //调用value方法
Integer c new Integer(a);//调用构造方法
/*
拆箱操作
*/
int d &＃61; c.intValue();


在下面几行行代码&＃xff0c;编译器自动调用了Integer.valueof()&＃xff0c;属于自动装包和拆包。

2.2.1练习题

• 【挖坑&＃xff1a;】下列代码输出什么&＃xff0c;为什么&＃xff1f;

public static void main(String[] args) {
Integer a &＃61; 100;
Integer b &＃61; 100;
Integer c &＃61; 200;
Integer d &＃61; 200;
System.out.println(a &＃61;&＃61; b);
System.out.println(c &＃61;&＃61; d);
}

3 .泛型如何编译

• 擦除机制

在编译的过程中&＃xff0c;将所有的T都替换为Object的这种机制&＃xff0c;称为&＃xff1a;擦除机制。JAVA的泛型机制是在编译时实现的&＃xff0c;编译器生成的字节码在运行期间并不包含泛型的类型信息(运行时没有泛型这么一说了)。

• 思考&＃xff1a;

1. Why&＃xff1f; T[] T &＃61; new T[10];是不对的。编译的时候替换为Object&＃xff0c;不是相当于&＃xff1a;Object[] T &＃61; new Object[10];
2. 类型擦除&＃xff1a;一定把T擦除给Object吗&＃xff1f;

• 解惑&＃xff1a;

T[]擦除成了Object&＃xff0c;Object是不能用其他类型接收的&＃xff0c;因为Object可以存各种类型&＃xff0c;把Object里的元素取出来转换成某个具体元素&＃xff0c;是不安全的&＃xff0c;JAVA不支持这么做。
数组和泛型之间有一个重要的区别就是&＃xff1a;它们是如何强制执行类型检查。 数组在运行时存储和检查类型信息&＃xff0c;而泛型是在编译时检查类型错误。
所以&＃xff1a;泛型是不能实例化泛型类型数组。前面我写的T[] t &＃61; (T[]) new Obeject[10];其实也是错的。

class 泛型类名称 <类型形参> extends<类型形参> {
//....
}


• 示例&＃xff1a;

  class Myarray{
//..
}
class Int extends Myarray{
//..
}
class Long extends Int{
//...
}
public class Maths<E extends Myarray>{
//...

}


  解释&＃xff1a;Maths的E只能是Myarray的子类&＃xff0c;也就是说**E接受的类型实参只能是Myarray的子类**。

• 再看一个例子&＃xff1a;

  class Student<E extends Number>{
E[] arr;
E Name;
}
public class Test {
public static void main(String[] args) {
Student<Integer> in;//1
Student<String> str;//2
}
}


  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6YVc6XOJ-1665319877790)(C:\Users\COFFEEWEN\AppData\Roaming\Typora\typora-user-images\image-20221009194623454.png)]

  **解释&＃xff1a;**注释1处&＃xff0c;编译正确&＃xff0c;因为Integer是Number的子类型&＃xff0c;注释2处&＃xff0c;编译错误&＃xff0c;因为String不是Number的子类型。

  
  

  • 了解&＃xff1a;Number是 java.lang包下的一个抽象类&＃xff0c;提供了将包装类型拆箱成基本类型的方法&＃xff0c;所有基本类型的包装类型都继承了该抽象类&＃xff0c;并且是final声明不可继承改变&＃xff1b;

  • 了解&＃xff1a;没有指定类型边界 E&＃xff0c;可以视为 E extends Object。

通配符是用于解决泛型之间引用传递问题的特殊语法&＃xff0c;更为灵活&＃xff0c;多用于扩大参数的范围。

• 示例&＃xff1a;

class Fruits<T>{
private T fruits;

public T getFruits(){
return this.fruits;
}

public void setFruits(T fruits){
this.fruits &＃61; fruits;
}
}
public class Demo {
public static void main(String[] args) {
Fruits<String> fruits1 &＃61; new Fruits<>();
fruits1.setFruits("苹果");
put(fruits1);//输出

Fruits<Integer> fruits2 &＃61; new Fruits<>();
fruits2.setFruits(100);
put(fruits2);
}
public static void put(Fruits<?> tmp){//1.
System.out.println("这个水果是&＃xff1a;"&＃43;tmp.getFruits());
tmp.setFruits("banana");//2.无法修改
tmp.setFruits(66);//3.无法修改
Fruits ret &＃61; tmp.getName();//4.无法接收
}
}


[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cXPRUoxj-1665319877791)(C:\Users\COFFEEWEN\AppData\Roaming\Typora\typora-user-images\image-20221009200552338.png)]

解释&＃xff1a;

1. 注释1&＃xff1a;处 put(Fruits tmp)使用无边界通配符&＃xff0c;说明它是可以接受任意类型&＃xff0c;所以当不同类型的fruits1和fruits2调用put进行传参时&＃xff0c;并不会报错。

2. 注释2处、3处&＃xff1a;由于是可以接受任意类型的&＃xff0c;tmp是不确定类型的&＃xff0c;不允许进行修改操作。比如&＃xff0c;你此时传入了一个String类型的(传参时不会报错)&＃xff0c;可是你代码里写的是tmp.setFruits(66)设置的是int型&＃xff0c;这样是很不安全的&＃xff0c;所以编译器直接不允许你这么写。

3. 注释4处&＃xff1a;传入的参数类型是不确定的&＃xff0c;不能用Fruits来接收。

5.1通配符上界

class Apple extends Fruits{

}
class Banana extends Fruits{

}
class Fruits extends Meat{

}
class Meat{

}
class Food<T>{
private T name;
public T getName(){
return this.name;
}
public void setName(T name){
this.name &＃61; name;
}
}
public class Demo {
public static void main(String[] args) {
Food<Apple> appleFood &＃61; new Food<>();
//因为Food 给的类型是Apple&＃xff0c;所以你只能给相同类型的数据
appleFood.setName(new Apple());
fun(appleFood);

Food<Banana> bananaFood &＃61; new Food<>();
bananaFood.setName(new Banana());
fun(bananaFood);
}
public static void fun(Food<? extends Fruits> tmp){//1.
System.out.println(tmp.getName());
tmp.setName(new Banana());//2.无法修改
tmp.setName(new Apple());//3.无法修改
Fruits ret &＃61; tmp.getName();//读取数据
}


解释&＃xff1a;

1. 注释1处&＃xff1a;使用了上界通配符&＃xff0c;表示可以传入的实参类型是Fruits和Fruits的子类型。
2. 注释2、3处&＃xff1a;由于是不确定类型的&＃xff0c;所以无法修改&＃xff0c;因为tmp接收的是Fruits和它的子类&＃xff0c;此时存储的元素类型应该是哪个子类&＃xff0c;是无法确定的&＃xff0c;所以设置会报错&＃xff01;但是可以获取元素&＃xff0c;因为ret的类型的Fruits&＃xff0c;是所有能传入参数的父类。
3. 通配符上界&＃xff1a;可以读取数据&＃xff0c;不能写入数据

5.2通配符下界

public static void main(String[] args) {
Food f1 &＃61; new Food<>();
f1.setName(new Fruits());
fun(f1);

Food f2 &＃61; new Food<>();
f2.setName(new Meat());
fun(f2);
}
public static void fun(Food tmp){//1.
System.out.println(tmp.getName());//只能直接输出
tmp.setName(new Banana());//2.可以修改
tmp.setName(new Fruits());//3.可以修改
Fruits ret &＃61; tmp.getName();//4.不能读取数据
}


解释&＃xff1a;

1. 注释1处&＃xff1a;使用的是通配符下界&＃xff0c;表示接受的参数只能是Fruits或者是Fruits的父类。
2. 注释2、3处&＃xff1a;可以修改&＃xff0c;因为tmp的类型是Fruits或者它的父类&＃xff0c;只能设置Fruits的子类或者它本身。
3. 注释4处&＃xff1a;如果此时传入的参数是Fruits的父类&＃xff0c;用Fruits类型来接收是不安全的&＃xff0c;换句话说&＃xff0c;传入的参数是不确定是哪个父类&＃xff0c;不能接收。
4. 通配符下界&＃xff1a;不能读取数据&＃xff0c;可以写入数据。

配符下界&＃xff1a;不能读取数据&＃xff0c;可以写入数据。

• 填坑&＃xff1a;

public static void main(String[] args) {
Integer a &＃61; 100;
Integer b &＃61; 100;
Integer c &＃61; 200;
Integer d &＃61; 200;
System.out.println(a &＃61;&＃61; b); //1.
System.out.println(c &＃61;&＃61; d); //2.
}


解释&＃xff1a;

• 注释1处&＃xff1a;输出true&＃xff1b;
• 注释2处&＃xff1a;输出false&＃xff1b;
• Why&＃xff1f;
  Integer源码有一个cache数组事先存储了【-128,127】之间的数据&＃xff0c;总共256个数据&＃xff0c;这些数据被static final修饰&＃xff0c;是不能改变的。当赋的值是在这个区间里&＃xff0c;会直接在这个数组里读取&＃xff0c;也就是变量a和b&＃xff0c;指向了同一个对象&＃xff0c;所以输出true。当超过了这个区间&＃xff0c;每次都会重新new一个对象&＃xff0c;所以输出false。