Java通俗易懂讲解泛型（java泛型的定义和使用）

Java通俗易懂讲解泛型（java泛型的定义和使用）

目录1.什么是泛型2.引出泛型3.泛型类的语法4.裸类型5.泛型如何编译的5.1 擦除机制5.2.泛型数组为什么不能实例化6.泛型的上界7.通配符7.1.通配符能用来干嘛7.2.通配符的上界(读数据)7.3.通配符的下界(写数据)

1.什么是泛型

泛型是在JDK1.5引入的新的语法，通俗讲，泛型：就是适用于许多许多类型。从代码上讲，就是对类型实现了参数化。

看到标红的这句话，有些兄弟可能会有疑惑，我们以前传参，传得是一个整形数据，传得是一个引用，我从来没传过类型嘛，类型难道还能作为参数传递？？？对，没错，接下来，我们就来看一下类型作为参数传递的实现方式

2.引出泛型

我们以前学过继承和多态，我们知道所有类的父类默认是Object类，我们现在目标是：数组中可以存放任何类型的数据，这时候我们就可以new一个Object类型的数组，，，

class MyArray {

public Object[] array = new Object[10];

public Object getPos(int pos) {

return array[pos];

}

public void setPos(iirVwHltcsLnt pos, Object value) {

array[pos] = value;

}

}

public class TestDemo {

public static void main(String[] args) {

MyArray myArray = new MyArray();

myArray.setPos(0,1);

myArray.setPos(1,"hello");

}

}

当我们写出这样一个代码的时候，我们发现数组中什么元素都能放了，可以放整形数据，可以放字符串，还可以放小数，这里面能放的东西太多了，你能知道某个下标的元素是什么样的类型吗？？当我们取元素的时候，会发现你的代码编译都不能通过，，，

为什么会出现这样的情况呢，我相信大部分兄弟们都知道，我们观察getPos的返回值是Object，也就意味着我们拿出来的可能是任意元素，但编译器知道吗？？？它只知道返回的是一个Object：这就很明显了，父类给子类，，这不纯纯的向下转型吗，向下转型就必须要强转类型，否则你的代码就不可能通过。

那么问题又来了，，我这里只是放了两个元素，肉眼还能看的过来，但是这里面的类型时刻在发生改变，就算你知道类型，你每次都需要强转吗，我是动态的啊，我代码是写死的啊，所以这个地方如果用Object去做的话，会显得格外麻烦，而且局限性非常的大

我们现在的困境有两个：

1.任何类型都可以放，不好控制，，，

2.每次取元素的时候，都得进行强制类型转换，，，

这时候我们得搞一手希望工程，我们的希望是：

1.我们能不能自己指定类型

2.我们能不能，不再进行类型转换呀，能不能把这一步省略呀，兄弟！！！

为了解决这一问题，我们java就引入了这个东西----》泛型

那到底怎么指定类型呢，来看代码：

class MyArray {

//public Object[] array = new Object[10];

public T[] array = (T[]) new Object[10];//这样写也不好，待会说为什么？？

public T getPos(int pos) {

return array[pos];

}

public void setPos(int pos, T value) {

array[pos] = value;

}

}

public class TestDemo {

public static void main(String[] args) {

//我指定放整形

MyArray myArray = new MyArray<>();

//后面的尖括号里的类型可以省略，在实例化对象的时候根据前面可以做出判断

//MyArray myArray = new MyArray();

myArray.setPos(0,1);

myArray.setPos(1,2);

Integer ret = myArray.getPos(1);

System.out.println(ret);

//我指定放字符串类型

MyArray myArray2 = new MyArray<>();

myArray2.setPos(0,"abc");

myArray2.setPos(1,"bit");

String ret2 = myArray2.getPos(0);

System.out.println(ret2);

}

}

这个代码有几个注意事项：

1.尖括号<>里面只能放引用类型；

2.是一个占位符，代表当前类是一个泛型类；

3.MyArray array = new MyArray<>();后面的尖括号可以省略Integer不写，实例化对象的 时候编译器根据前面能做出判断。

看完上面的代码，我相信兄弟们已经明白是怎么一回事了吧

我们刚刚的希望工程也已经实现了

1.，指定当前类中，使用的类型是Integer类型

2.泛型帮我在编译期间做了2件事情（目前为止的优点）：

存放元素的时候，进行类型的检查取元素的时候，帮我进行类型的转换

3.泛型类的语法

有了刚刚知识的铺垫，这一块咱就形式化一下啦，，当然，语法还是很重要滴！！

语法：

泛型类<类型实参> 变量名; // 定义一个泛型类引用 new 泛型类<类型实参>(构造方法实参); // 实例化一个泛型类对象

栗子：

MyArray list = new MyArray();

4.裸类型

说明：

兄弟们，咱学了新东西，这旧东西，咱也得了解一下是不咯，，万一以后跟别人聊到了，自己好像从来没听过就尴尬了，，

裸类型是一个泛型类但没有带着类型实参，例如 MyArrayList 就是一个裸类型

MyArray list = new MyArray();

注意： 我们不要自己去使用裸类型，裸类型是为了兼容老版本的 API 保留的机制

5.泛型如何编译的

5.1 擦除机制

我用的是Powershell窗口查看的字节码文件，当然用idea的兄弟们也可以去下载一个展示字节码的插件，，接下来我们看看泛型到底是怎么编译的，，javap -c查看字节码

我们发现在编译期间，所有的T都被擦除为了Object，那既然所有的T都变成了Object，那我们为什要指定类型呢？注意这里不是编译的时候替换，指定类型只是为了在编译的时候帮我们进行类型的检查和转换，并不是替换！！！最终字节码编译完成的时候，所有的T变成了Object，而这就是我们Java当中泛型所谓的擦除机制！！！

提问：那既然T在编译的时候被擦除为了Object，那为啥 T[] array = new T[] 会报错呢？

5.2会给你答案

5.2.泛型数组为什么不能实例化

先看一段代码和运行结果：

class MyArray {

public T[] array = (T[])new Object[10];

public T getPos(int pos) { return this.array[pos]; }

public void setVal(int pos,T val) { this.array[pos] = val; }

public T[] getArray() { return array; }

}

public class TestDemo {

public static void main(String[] args) {

MyArray myArray1 = new MyArray<>();

Integer[] strings = myArray1.getArray();//这里运行时会报错

String[] strings1 = (String)myArray1.getArray();//这里编译都不能通过

}

}

出现这种情况的原因何在呢？

这里最大的问题就是数组，java中的数组是非常特殊的，它是在堆上分配内存的，它有自己的一套特殊的机制，而T[] array = new T[] 这个数组它没有指定具体的类型,肯定是不让这样做的；再者，get方法的返回类型是Object类型，如果用整形数组来接受，父类给子类，编译器是直接不让你做的。

那问题来了？？？既然 T[] array = new T[] 这种写法是错误的，T[] array = (T[])new Object[10] 这种写法又不好，那正确的写法应该是怎么的呢？？？

正确写法：（了解即可）

/**

* 通过反射创建指定类型的数组

*/

public MyArray(Class clazz, int capacity) {

array = (T[]) Array.newInstance(clazz, capacity);

}

看起来很复杂，对吧，但是没关系，java官方都不这么用，所以我们也只需要了解即可。

我们可以看下ArrayList的源码来确认一下（以免存在忽悠的成份）：

6.泛型的上界

什么叫泛型的上界呢？？先给你们看一下语法：

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

这一模块我将举两个栗子来和大家一起认识或温习一下这个知识点，，，

简单示例：

class Test {

}

public class TestDemo {

public static void main(String[] args) {

//Number的子类

Test test = new Test<>();

Test test1 = new Test<>();

Test test2 = new Test<>();

//Number本身

Test test3 = new Test<>();

}

}

中的 extends可不敢理解为继承喔，可以理解为T擦除为了Number的子类或自己本身，也就是说在主函数中用这个类实例化的时候，可以指定的类型一定要 <= Number ，，差不多就这意思，，，简单的你们都能理解，我就不多废话了，给你们来点稍微有难度的（我觉得难）

进阶示例：

class Alg> {

//如果不设置上界为Comparable,就用不了compareTo这个方法，因为T如果不指定的话，

// 在编译的时候被擦除成了Object，而Object并没有实现这个接口

public T findMax(T[] array) {

T max = array[0];

for (int i = 1; i < array.length; i++) {

if(max.compareTo(array[i]) < 0) {

max = array[i];

}

}

return max;

}

}

class Student implements Comparable {

public String name;

public int age;

public Studehttp://nt(String name, int age) {

this.name = name;

this.age = age;

}

@Override

public String toString() {

return "Student{" +

"name='" + name + '\'' +

", age='" + age + '\'' +

'}';

}

@Override

public int compareTo(Student o) {

return 0;

}

}

public class TestDemo {

public static void main(String[] args) {

//指定类型为整形

Alg alg = new Alg<>();

Integer[] array = {1,2,3,4,5};

Integer max = alg.findMax(array);

System.out.println(max);

//指定类型为Student

Alg alg2 = new Alg<>();

Student[] students = new Student[3];

students[0] = new Student("毛毛",15);

students[1] = new Student("吉吉",13);

students[2] = new Student("毛二",16);

Student student = alg2.findMax(students);

System.out.println(student);

}

}

>意为擦除到实现了这个接口，简而言之就是这里面接收的类型一定是实现了Comparable接口的，给你们证明一下，我那里面Student类型毋庸置疑，自己实现的Comparable接口，我们来看看Integer的源码：

再者，我们观察一下 Alg 这个类中的 findMax 方法，我们都知道引用类型比较大小要用比较器或者compareTo方法，如果 Student 这个类没有实现 Comparable 接口，我们在写代码的时候，会发现点都点不出来，比较一下，就通透了，，

没有实现Comparable接口：

实现了Comparable接口：

当然，又有人会问，我能不能不实例化这个方法，直接调用这个方法，这时候我们把这个方法搞成静态的来看一下：

发现它报错了，，，别急哈，咱们一步一步是爪牙，，哦，不对，是一步一步来揭开面纱，，

那如何将这个代码改成正确的呢？？细心的兄弟会发现，既然这个方法是静态的， 那我们只需要通过类名来方法，如果还按照之前的写法，类后面跟一个 ，那我们啥时候给它指定类型？？不知道吧，这时候我们要将代码改成这样，在 static 的后面跟一个 ，这样你的代码就不会报错了，，，

当然，我们也可以指定边界，这里跟类有着异曲同工之妙，就不细说了，花两秒钟看一下代码，你就能发出： 哦~~~~~的声音，中国人不骗中国人

class Alg2 {

public static T findMax(T[] array) {

T max = array[0];

for (int i = 1; i < array.length; i++) {

if(max.compareTo(array[i]) < 0) {

max = array[i];

}

}

return max;

}

}

最后，你们可能会问，那它既然有上界，那它有下界吗？？

那肯定是没有的啊，咱学习编程多辛苦啊 ！！是不是兄弟们

7.通配符

兄弟们，最后两个知识点，咱泛型就告一段落了，，

什么是通配符？？我还是换一行吧

？这个就是通配符，对，没错，就是这个问号 "?"

7.1.通配符能用来干嘛

JAVA中引入通配符这一玩意是用来解决泛型无法协变这一问题的，那什么是协变呢？

协变这东西怎么说呢，类似于，继承当中的父类引用子类的对象，但是泛型中不支持协变类型，而JAVA的数组是支持的，数组中明确了它所允许存储的对象类型，并且会在运行时做类型检查（这也是为什么不能创建泛型数组的原因，数组创建时必须知道确切类型）。

下面看具体代码，看看是如何解决协变问题的，，，

class Message {

private T message;

public T getMessage() {

return message;

}

public void setMessage(T message) {

this.message = message;

}

}

public class TestDemo2 {

public static void main(String[] args) {

Message message = new Message<>();

message.setMessage(1);

fun(message);//编译不通过

}

public static void fun(Message temp) {

System.out.println(temp.getMessage());

}

}

首先，上面这一段代码编译是不能通过的，很明显我 fun 方法中只能接收 String 类型的数据，而你给我一个整形数据，肯定会报错吗，当我把它改成这样的时候，，你会发现代码不报错了：

class Message {

private T message;

public T getMessage() {

return message;

}

public void setMessage(T message) {

this.message = message;

}

}

public class TestDemo2 {

public static void main(String[] args) {

Message message = new Message<>();

message.setMessage(1);

fun(message);

}

public static void fun(Message> temp) {

//temp.setMessage(1);//是不能往里面加元素的，所以源码当中通配符用的比较多

System.out.println(temp.getMessage());

}

}

这里尖括号里面放❓意味着可以接收任何类型，人家用户你可不知道你这是什么类型，所以通配符在这一块就起了非常大的作用；再者，既然可以接收所有类型，就不能让用户随便修改。具体是怎么做到的呢？也就是说当你用通配符在函数中接收任意类型之后，你不能调用 set 方法往里面设值，你根本不知道你接收到的是什么类型，，，所以，我们也看到源码当中通配符用的比较多就是这么回事

7.2.通配符的上界(读数据)

通配符的上界，这东西跟刚刚的泛型上界很相似，有了刚刚的只是铺垫，应该不难理解了，，语法这一块咱就不演示了

class Food {}

class Fruit extends Food {}

class Apple extends Fruit {}

class Banana extends Fruit {}

class Plate {

private T pear;

public T getPlate() {

return pear;

}

public void setPlate(T a) {

this.pear = a;

}

}

public class TestDemo3 {

public static void main(String[] args) {

Plate plate = new Plate<>();

Plate plate1 = new Plate<> ();

fun1(plate);

fun1(plate1);

}

public static void fun1(Plate extends Fruit> temp) {

//temp.setPlate(new Apple());这里不知道temp引用的子类是谁，所以不能往里边放元素

//可以接收元素，父类接收子类，顶多就是向上转型

System.out.println(temp.getPlate());

//Fruit fruit = temp.getPlate();

}

}

我们这里给了它香蕉/苹果等一些水果类和 Fruit 这个父类， extends Fruit>这里可以接收任何Fruit 的子类类型，同理，既然可以接收任何类型，就不适合写数据，只适合读数据，，

7.3.通配符的下界(写数据)

通配符不同于泛型，它是有下界的，来看看它的下界，，，

语法大概就这样子，简单了解一下： super 下界>---重点在代码

public class TestDemo3 {

public static void main(String[] args) {

Plate plate = new Plate<>();

fun(plate);

Plate plate2 = new Plate<>();

fun(plate2);

Plate plate1 = new Plate<>();

//fun(plate1);

}

public static void fun(Plate super Fruit> temp) {

//写数据，但是不能写父类

temp.setPlate(new Apple());

temp.setPlate(new Banana());

//编译不通过：Fruit的父类有很多，不一定就是某一个

//temp.setPlate(new Food());

//不安全--它的父类有很多，不知道是哪一个父类发生了向下转型

//Fruit fruit = (Fruit)temp.getPlate();

}

}

通配符的下界呢，，我们可以看到它是用了一个关键字super，字面意思，大家都懂，就是说能接收的类型至少是 Fruit ，以及 Fruit 的父类，所以，在读写数据这一块，它就不同于别人，它只喜欢写数据，就像咱人一样，总得有些偏执的爱好，我就喜欢敲代码，是吧，，，为啥不能读数据，这里还是得解释一下，因为 Fruit 的父类太多了，你根本不知道读谁的数据，再者就http://算你强转类型，编译器也会认为这是不安全的，所以我们在读数据和写数据这一块，？的上界和？的下界要搞清楚什么时候用哪一个，，，

下图能帮助你理解读写数据，到底适合哪一个

本来还有一个装箱和拆箱的类容要给兄弟们分享的，但是现在已经凌晨两点了（小命要紧，建议大家不要像我这样，身体是内卷的本钱，我只是一时兴起，不敢瞒着兄弟们偷偷卷），我要为那些目前还在渴望这一块知识的年轻小伙子着想，就把那些内容单独抽到下一期去了，，，下期见，兄弟们！！！

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。