对于泛型,我们的学习目的:看得懂就可以了。因为 泛型是 java 当中比较难的一块语法了。
一般的类和方法,只能使用具体的类型;基本类型,或者是自定义的类。如果要编写可以用于多种类型的代码,这种刻板的限制对代码的束缚就会很大。 ------- 来自《Java编程思想》
泛型是在JDK1.5引入的新语法,通俗讲:泛型 ->就是适用于很多类型。从代码上讲,就死对类型实现了参数化(将类作为参数进行传递)。
实现一个类似顺序表的类,使得底层的数组可以存放任何类型的数据,也可以根据成员方法来返回数组中某个下标的值
思路:
1.我们以前学过的数组,只能存放指定类型的元素。例如:
int[] array1 = new int[10];
String[] array2 =new String[10];
2、所有类的父类,默认为 Object 类。数组是否可以创建为 Object ?
.>
此时,我们会发现:我们的数组由于类型 是 Object 的类,说明什么类型都可以往 数组里放。因此,我们 set 方法,接收的数据类型为 Object 类型,返回值也是Object 类型。
因为你不知道下一个返回的数据是什么类型的数据。
因此,导致了一个问题的出现,哪怕我们知道下一个数据类型,用相应的数据类型去接收也是不可以的。只能使用 Object 去接收。
只有 进行 强制类型转换,才能赋值。
该代码,任何类型的数据都可以放入,但是取出需要强制类型转换。
虽然这个代码确定达到了通用的效果。但是! 取出数据很麻烦。
我们来讲修整好的代码执行一下,看一下效果。
结果表明,编译阶段没有问题。而且有了泛型指定类型之后,在编译阶段会帮我们检查一波输入的数据类型,如果和指定类型不符,则会有错误提示。
结果表明, 运行没有问题。
我们在来看看取出的数据的时候,有没有问题。
而且,不需要手动类型转换了。它会自动进行类型转换。
要向存储其他类型的数据也可以,只需要 再去new MyArray 类,利用泛型去指定你想输入的数据类型。
取出数据。
1、类名后的 代表占位符,表示当前类时一个泛型类。
2、 泛型类型的数数组,不能new/实例化。
3、基本数据类型,不能作为泛型类型的参数。要封装类。
4、类型后加入<数据类类型>,该类型只能处理 规定的数据类型。
5、编译的时候,自动进行类型的检查
6、取出数据的时候,不需要类型转换。
泛型的主要目的:就是指定当前的“容器”,要持有什么类型的对象。让编译器去做检查。
此时,就把需要类型,作为参数传递。要什么类型,就传入什么类型。
以此达到灵活使用,却不会乱套的地步。
class 泛型类名称<类型实参列表>{
// 这里可以使用类型参数
}
//示例
class ClassName<T1,T2,.......Tn>{
// 这里可以使用类型参数
}
class 泛型类名称<类型实参列表> extends 继承类/* 这里可以使用类型参数 */ {
// 这里可以使用类型参数
}
class ClassName<T1, T2, ..., Tn> extends ParentClass<T1> {
// 可以只使用部分类型参数
}
泛型类<类型实参> 变量名; // 定义一个泛型类引用
new 泛型类<类型实参>(构造方法实参); // 实例化一个泛型类对象
MyArray<Integer> list = new MyArray<Integer>();
注意:泛型只能接受类,所有的基本数据类型必须使用包装类!
编译器可以通过上下文推导出类型实参时,可以省略类型实参的填写。
MyArray<Integer> list = new MyArray<>(); // 可以推导出实例化需要的实参类型为Integer
裸类型是一个泛型类但没有带着类型实参,例如 MyArrayList 就是一个裸类型
相当于 泛型没有其作用。又回到原点了。所以请记住:使用泛型类,记得加<类型实参>。
1、泛型是将数据类型参数化,进行传递。
2、使用表示当前类时一个泛型类。
3、泛型目前为止的优点:数据类型参数化,编译时自动进行类型的检查和转换。
泛型到底是怎么编译的?这个问题 是 曾经 的一个面试问题
泛型本身就是一个非常难的语法,需要理解好它,还是需要时间的!
下面我们就用通过实战来了解 它 是 如何编译的。
通过命令: javap -c 查看字节码文件,发现所有的 T 都换成 Object。
即:在编译的过程当中,将所有的 T 替换 Object 这种机制,我们称为 擦除机制。
Java 的泛型机制是在编译阶段实现的。
编译器生成的字节码在运行期间并不包含泛型的类型信息。
有关泛型擦除机制的文章截介绍:链接
这篇文章讲得非常清楚的。
我们摘取部分重要内容讨论
什么意思呢?我们在这里再解读一下。
如果这么去写,我们又会回到最初的问题。因为我们刚开始就是这么写的。
放入数据没有限制,太灵活了。拿出数据需要强制类型准换,太麻烦了。
现在我们就是使用反证法,来简单说明一下。
假设泛型类型的数组可以实例化:public T[] objects = new T[10];
有的人可能会有疑问:不是说泛型在编译期间,会检查数据类型吗?为什么一开始不报错?
其实很简单:类型检查嘛,你指定 类型参数是 String,它就认为 getArray 返回的数组类型就是String[] 类型,所以它不会报错。
还有一个因素: 因为 public T[] objects = new T[10]; 能成立的话,根据擦除机制:T = Object,那么就是说:这个数组它可以存储任何类型的元素。故:getArray 返回的数组元素类型可以五花八门的,我们凭什么认为 String[] 能接收?答案是不能的!
其实我们的这种写法: public T[] objects = (T[])new Object[10];也是不安全的!
存在的问题也是一样的,数组的元素 也有可能存储不同类型的元素。
有的人可能就会说:那搞了半天,这泛型不跟没有一样? 答案:不是的! 它起着一定提示作用,指定我们输入某种类型的数据。能够程度上避免我们犯错。
当然,并不说泛型就这点作用,这是因为此时使用泛型的方法,不是正确的。
那么,正确的方法又是怎么样?不知道大家有没有注意到 上面那篇文章的部分截图最下面划线的地方。
通过Array.newInstance() 方法,向它转入 参数,才能真正创建一个 T[] 类型的数组。
‘如果要创建一个泛型数组,记住一定是使用 反射 来创建的。
记住!不要傻里傻气说:原码里 ArrayList 底层的数组就是 Object类型。原码有它自己的处理方式,绝大部分人又不会涉及到 jdk 的开发,所以无足轻重。有兴趣的,自己去研究。
在定义泛型类时,有时需要对传入的类型变量做一定的约束,可以通过类型边界来约束。
泛型只有上界,没有下界。另外,当泛型类没有指定边界时(class 泛型类名),默认是Object。
class 泛型类名称<类型形参 extends 类型边界> {
...
}
public class MyArray<E extends Number> {
...
}
只接受 Number 的子类型作为E的类型实参(E 可以是 Number 或者 Number的子类)。这就叫做 泛型上界。
public class MyArray<E extends Comparable<E>> {
...
}
&ensp;
所以,此时我们需要实现 Comparator 或者 Comparable 接口,来比较大小。
通过 compareTo 方法 来比较。
但是,你会发现 没有 与 Comparable 和 Comparator 相关的功能。
这是因为你怎么确定 类型参数 T 它实现了 Comparable 或者 Comparator接口的方法?
没有办法确定!
来看怎么解决!
来看看 实际效果
基本数据类型的包装类 和 String 类 都实现了 Comparable 接口
方法限定符 <类型形参列表> 返回值类型 方法名称(形参列表) { ... }
// <类型形参列表> 一般只有在静态方法中,写在static后面
细心的朋友发现,你在通过类名调用 静态方法的时候,并没有指定类型啊。
为什么就可以通过呢?
其实,是省略了。来看下面的图
public class MyArrayList<E> { ... }
// MyArrayList<Object> 不是 MyArrayList<Number> 的父类型
// MyArrayList<Number> 也不是 MyArrayList<Integer> 的父类型
理论上来说:Object 是 所有类的父类。
至于 为什么说: MyArrayList 不是 MyArrayList 的父类型, MyArrayList 也不是 MyArrayList 的父类型。 这是因为 这些 类名后面的 尖括号 和 里面的类型参数 都会被擦除掉。
findMax方法 里面的 T 会被擦成 Object,而<类型参数>会被完全擦除。
也就说:在JVM当中是没有泛型的概念的。
所以 上面的 4个类时构成不了父子关系的。
? 用于在泛型的使用,即为通配符。
通配符是用来解决泛型无法协变的问题。
协变 指的就是如果 Student 是 Person 的子类,那么List 也应该是 List的子类。
但是泛型是不支持这样样子父子类关系的。
1、泛型 T 是指定的类型,一旦你传给了我就定下了。而通配符则更为灵活或者说是不确定,更多的是用于扩充参数的范围。
2、或者我们可以这样理解:泛型 T 就是一个变量,等着你将来传给它一个具体的类型;而通配符则是一种规定:规定你只传某一个范围的参数类型。【比如说整形 short、int 都是整形范围里的类型】
泛型指定了某种类型,也就是说:类型参数 T 一定是将来指定的一个泛型参数。
public static<T> void printList1(ArrayList<T> list) {
for (T x:list) {
System.out.println(x);
}
}
//代码2中使用了通配符,和代码1相比,此时传入printList2的数据类型,
//具体是什么数据类型,我们是不清楚的。这就是通配符。
// 这也是为什么 foreach 循环中,x 是 Object 类型,就是因为不确定数据类型,
public static void printList2(ArrayList<?> list) {
for (Object x:list) {
System.out.println(x);
}
}
从效果上来看:两者效果是一样的。
唯一的区别即使程序上的区别,print1 的T 一定是指定了某种数据类型的。接收还是用 T 去接收。
而 print2 使用了通配符 ?,指定了一个类型范围,虽然扩充了参数的范围,但同时也意味着无法 确定具体类型,所以使用 Object 去接收读取的数据。
<? extends 上界>
<? extends Number>//可以传入的实参类型是Number或者Number的子类
// 可以传入类型实参是 Number 子类的任意类型的 MyArrayList
public static void printAll(MyArrayList<? extends Number> list) {
...
}
// 以下调用都是正确的
printAll(new MyArrayList<Integer>());
printAll(new MyArrayList<Double>());
printAll(new MyArrayList<Number>());
// 以下调用是编译错误的
printAll(new MyArrayList<String>());
printAll(new MyArrayList<Object>());
Animal
Cat extends Animal
Dog extends Anima
Cat 和 Dog 都继承了 Animal,也就是说 Animal 是 Cat 和 Dog 的 父类,即 Cat 和 Dog是 Animal的子类。
根据上述关旭,写一个方法,打印一个存储了Animal 或者 Animal 子类的 list、
public static void print(List<Animal> list) {
}
但是这样写不可以解决这个问题,因为 print 的 参数类型是 List list,就不能接收 List list。.
因为 List 是一个泛型,根据前面所讲 Cat 和 Dog 跟 泛型的父类 是不构成父子关系的。
所以说 通配符的出现就是为解决这一类的问题(协变类型:父子类关系)。
public static <T extends Animal> void print2(List<T> list) {
for (T animal : list) {
System.out.println(animal);
}
}
此时T类型是Animal的子类或者自己。该方法可以实现.
因为 我们通过 extends Animal 确保了 T 是 Animal 的 子类,或者本身。
这里是 泛型上界
public static void print3(List<? extends Animal> list) {
for (Animal ani : list) {
System.out.println(ani);//调用谁的toString 方法?
}
}
这方法比上一个方法更好。
通过利用 通配符的上界,将 类型参数 限制为 Animal 或者 Animal 的子类。
所以 在 foreach 循环,我们可以是使用 Animal 来接收 读取的数据。
也就是 只是 传入 Cat 或者 Dog 都是可以的。
但是输出的时候,存入的如果是Cat ,那么输出的时候就会调用 Cat 的 toString 方法、
同理:Dog 的话,那么sout的时候就会调用 Dog 的toString 方法。
Animal 就调用 Animal 的 toString 方法。
注意!如果没有 在 通配符后面添加上界,那么foreach就需要使用 Object 类型去接收。
1、对于实现泛型的 print2 方法, 对 T 进行了限制,只能是Animal 或者Animal 的子类(泛型上界),当传入Cat时,类型也就定下来了,就是Cat。
'2、对于通配符实现的print3方法,首先不用在static后面使用尖括号,其次相当于对Animal 进行了规定,允许你传入animal的子类。具体哪个子类,此时并不清楚。
【比如:传入了Cat,实际上声明的类型是 Animal,使用多态才能调用Cat的toString方法】
// 需要使用通配符来确定父子类型
MyArrayList<? extends Number> 是 MyArrayList <Integer>或者 MyArrayList<Double>的父类类型
MyArrayList<?> 是 MyArrayList<? extends Number> 的父类型
对于 MyArrayList<? extends Number>,我们只能传入 Number 或者 Number的子类。
而 后面的 MyArrayList 或者 MyArrayList中的 和 ,但是属于<? extends Number>的子类。
即:MyArrayList<? extends Number> 是 MyArrayList 或者 MyArrayList的父类类型
对于 MyArrayList<?> ,<?> 就相同与 Object了,Objet 是所有类的父类。
那么,MyArrayList<? extends Number>中的 <? extends Number> 就是 它的子类了。
即:MyArrayList<?> 是 MyArrayList<? extends Number> 的父类型
对于这个代码,我们思考:是否可以对这个List 进行写入?
答案是不可以!【具体原因注释写很清楚】
但是请记住: 通配符的上界 适合读取数据,不适合输入数据。’
<? super 下界>
<? super Integer>//代表 可以传入的实参的类型是Integer或者Integer的父类类型
注意!通配符有下界,但是泛型没有下界。
通配符的上界 与 下界的区别 就在于 extends + (上界) 与 super + (下界)
xtends + (上界) : 传参的类型只能是 上界,或者 上界的子类。
super + (下界):传参的类型只能是 下界,或者 下界的父类。
// 可以传入类型实参是 Integer 父类的任意类型的 MyArrayList
public static void printAll(MyArrayList<? super Integer> list) {
...
}
// 以下调用都是正确的
printAll(new MyArrayList<Integer>());
printAll(new MyArrayList<Number>());
printAll(new MyArrayList<Object>());
// 以下调用是编译错误的
printAll(new MyArrayList<String>());
printAll(new MyArrayList<Double>());
还是一开始说的那句话,不要较真,以看得懂代码为母的就行了。
能用到通配符,除非你被邀请参加开发 jdk,这个可能非常小。
这里我就不再多讲,看着我的这篇文章就行了!
List 接口相关知识 - ArrayList数据结构 - Java - 细节狂魔开头就讲了 泛型 和 包装类。自行学习。
版权说明 : 本文为转载文章, 版权归原作者所有 版权申明
原文链接 : https://blog.csdn.net/DarkAndGrey/article/details/123031869
内容来源于网络,如有侵权,请联系作者删除!