Java 泛型

1、泛型的由来

  我们先看下面这段代码:

                List list = new ArrayList();
		list.add(24);  //向集合中添加一个 Integer 类型的数据
		list.add("Tom");	//向集合中添加一个 String 类型的数据
		
		for(int i = 0 ; i < list.size() ; i++){
			Object obj = list.get(i);  //注意这里每个类型都是 Object
			System.out.println(obj);
		}
		
		//如果我们遍历的时候就想得到自己想要的数据类型
		for(int i = 0 ; i < list.size() ; i++){
			String obj = (String) list.get(i);  //在取 Integer 的时候会报类型转换错误
			System.out.println(obj);
		}

  报错信息如下:

  也就是 集合中第二个数据是 Integer,但是我们取出来的时候将其转换为 String 了,所以报错。

  那么这个如何解决呢?

  ①、我们在遍历的时候,根据每个数据的类型判断,然后进行强转。

那么我们说这个集合只有两条数据,我们可以进行判断强转,如果数据有成千上万条呢,我们都通过这样判断强转肯定不可取

  ②、在往集合中加入数据的时候,我们就做好限制,比如这个集合只能添加 String 类型的;下一个集合只能添加 Integer 类型的,那么我们在取数据的时候,由于前面已经限制了该集合的数据类型,那么就很好强转了。

  这第二种解决办法,也就是我们这篇文章讲的 泛型

2、什么是泛型?

泛型是Java SE 1.5的新特性,泛型的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中,分别称为泛型类、泛型接口、泛型方法。

  在Java SE 1.5之前,没有泛型的情况的下,通过对类型Object的引用来实现参数的“任意化”,“任意化”带来的缺点是要做显式的强制类型转换,而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况,编译器可能不提示错误,在运行的时候才出现异常,这是一个安全隐患。

3、泛型的基本用法

3.1 对于上面的问题我们只需要将上述代码的 List list = new ArrayList()  改为   List<String> list = new ArrayList<String>();

                List<String> list = new ArrayList<String>();
		//list.add(22);  //向集合中添加一个 Integer 类型的数据时,编译器会报错
		list.add("Bob");  //向集合中添加一个 String 类型的数据
		list.add("Tom");	//向集合中添加一个 String 类型的数据
		
		//如果我们遍历的时候就想得到自己想要的数据类型
		for(int i = 0 ; i < list.size() ; i++){
			String obj = list.get(i);  //这里就不需要强转了,前面添加的是什么类型,这里获取的就是什么类型
			System.out.println(obj);
		}            

3.2 泛型是在编译阶段有效

        List<String> list1 = new ArrayList<String>();
	List list2 = new ArrayList();
	Class c1 = list1.getClass();
	Class c2 = list2.getClass();
	System.out.println(c1==c2); //true    

  上述代码,由于我们知道反射是在运行时阶段,c1==c2为 true,说明了编译之后的 class 文件中是不包含任意的泛型信息的。如果不信,我们可以看 class 文件的反编译信息

        java.util.List list1 = new ArrayList();
        java.util.List list2 = new ArrayList();
        Class c1 = list1.getClass();
        Class c2 = list2.getClass();
        System.out.println(c1.equals(c2));

  我们可以看到 反编译之后的 list1和 list2完全一样。

结论:Java 泛型只在编译阶段有效,即在编译过程中,程序会正确的检验泛型结果。而编译成功后,class 文件是不包含任何泛型信息的

  3.3 泛型类和泛型方法

public class Box<T> {
	private T box;
	public T getBox(T t){
		this.box = t;
		return t;
	}
	public void getType(){
		System.out.println("T的实际类型为:"+box.getClass().getName());
	}
	
	public static void main(String[] args) {
		Box box = new Box();
		System.out.println(box.getBox(1));
		box.getType();
		
		System.out.println(box.getBox("Tom"));
		box.getType();
	}

}

  输出结果为:

1
T的实际类型为:java.lang.Integer
Tom
T的实际类型为:java.lang.String

3.4 泛型通配符

在泛型中,我们可以用 ? 来代替任意类型

     public List wildCard(List<?> list){
		
		return list;
	}

	public static void main(String[] args) {
		GenericTest gt = new GenericTest();
		//构造一个 Interger 类型的集合
		List<Integer> integer = new ArrayList<Integer>();
		integer.add(1);
		System.out.println(gt.wildCard(integer));
		//构造一个 String 类型的集合
		List<String> str = new ArrayList<String>();
		gt.wildCard(str);
		//构造一个 Object 类型的集合
		List<Object> obj = new ArrayList<Object>();
		obj.add(1);
		obj.add("a");
		System.out.println(gt.wildCard(obj));
		//构造一个 任意类型的 集合,这和 List<Object> 存放数据没啥区别
		List list = new ArrayList();
		gt.wildCard(list);
		
	}

  3.5 泛型的上限和下限

①、上限: 语法(? extends className),即只能为 className 或 className 的子类

//通配符的下限,只能是 Number 或 Number的子类
	public List wildCard(List<? extends Number> list){
		
		return list;
	}

	public static void main(String[] args) {
		GenericTest gt = new GenericTest();
		//构造一个 Interger 类型的集合
		List<Integer> integer = new ArrayList<Integer>();
		integer.add(1);
		System.out.println(gt.wildCard(integer));
		//构造一个 String 类型的集合
		List<String> str = new ArrayList<String>();
		//gt.wildCard(str);   //编译报错
		//构造一个 Object 类型的集合
		List<Object> obj = new ArrayList<Object>();
		obj.add(1);
		obj.add("a");
		//System.out.println(gt.wildCard(obj)); //编译报错
		
	}

①、下限: 语法(? super className),即只能为 className 或 className 的父类

//通配符的上限,只能是 Number 或 Number的父类
	public List wildCard(List<? super Number> list){
		
		return list;
	}

	public static void main(String[] args) {
		GenericTest gt = new GenericTest();
		//构造一个 Interger 类型的集合
		List<Integer> integer = new ArrayList<Integer>();
		integer.add(1);
		//System.out.println(gt.wildCard(integer));  //编译报错
		//构造一个 String 类型的集合
		List<String> str = new ArrayList<String>();
		//gt.wildCard(str);   //编译报错
		//构造一个 Object 类型的集合
		List<Object> obj = new ArrayList<Object>();
		obj.add(1);
		obj.add("a");
		System.out.println(gt.wildCard(obj)); 
	}

4、泛型的注意事项

4.1、不能用基本类型来定义泛型,如 int、float

List<int> list = new ArrayList<int>(); //不能用 int 这样的基本类型定义泛型

  关于这一点很好想明白,因为 集合中只能存放引用类型的数据,即使你存入基本类型的,Java还是会通过自动拆箱和自动装箱机制将其转换为引用类型

4.2、如果使用 ? 接收泛型对象时,则不能设置被泛型指定的内容

List<?> list = new ArrayList<>();
		list.add("aa");  //错误,无法设置

4.3、泛型方法的定义与其所在的类是否是泛型类是没有任何关系的,所在的类可以是泛型类,也可以不是泛型类

  4.4、泛型类没有继承关系,即String 为 Object 类型的子类,则 List<String> 是 List<Object> 的子类这句话是错误的

原因:假设上面那句话是正确的,那么由于泛型的产生机制就是放什么类型的数据进去,取出来的就是什么类型,而不用进行类型转换,这里把 String 类型的数据放入Object 类型的泛型集合中,那么取出来的应该就是 String      类型的数据,而实际上取出来的是 Object 类型的数据,这与泛型的产生机制相违背,故不成立!

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏Java技术栈

Java集合从菜鸟到大神演变

先来看一张集合概况图,这里从上到下列举了几个最经常用的集合 ? 1、集合接口 java.util.Collection 是一个集合接口。它提供了对集合对象进行基...

4036
来自专栏纯洁的微笑

一个高频面试题,考考大家对 Java String 常量池的理解。

作为最基础的引用数据类型,Java 设计者为 String 提供了字符串常量池以提高其性能,那么字符串常量池的具体原理是什么,我们带着以下三个问题,去理解字符串...

832
来自专栏青枫的专栏

java基础学习_基础语法(上)03_day04总结

============================================================================= ==...

531
来自专栏Java帮帮-微信公众号-技术文章全总结

【Java提高十六】集合List接口详解

在编写java程序中,我们最常用的除了八种基本数据类型,String对象外还有一个集合类,在我们的的程序中到处充斥着集合类的身影!java中集合大家族的成员实在...

2353
来自专栏老九学堂

【必读】C语言基础知识大全

C语言程序的结构认识 用一个简单的c程序例子,介绍c语言的基本构成、格式、以及良好的书写风格,使小伙伴对c语言有个初步认识。 例1:计算两个整数之和的c程...

2878
来自专栏java学习

Java每日一练(2017/7/19)

本期题目: (单选题) 1、设int x=1,float y=2,则表达式x/y的值是:() A 0 B 1 C 2 D 以上都不是 ---- (单选题)2、若...

2698
来自专栏小樱的经验随笔

【Java学习笔记之一】java关键字及作用

Java关键字及其作用 一、 总览: 1 访问控制 2 private protected public 3 4 类,方法和变量修饰符 ...

3078
来自专栏闻道于事

Java常见问题

自古深情留不住,总是套路得人心 最近经历了一次惨无人道的程序员笔试,真的是“笔”试,默默地来整理一下…… 以后遇到问题要多整理…… 常见套路: 当一个变量被赋值...

3486
来自专栏我的博客

JS闭包

闭包定义 闭包是一个拥有许多变量和绑定了这些变量的环境的表达式(通常是一个函数),因而这些变量也是该表达式的一部分。就是在另一个作用域中保存了一份它从上一级函...

33611
来自专栏Java大联盟

Java面试手册:核心基础-4

5.comparable/comparator区别。 用Comparable简单,只要实现Comparable接口的对象直接就成为一个可以比较的对象但...

512

扫码关注云+社区