1、泛型

最新推荐文章于 2023-04-24 17:08:38 发布
最新推荐文章于 2023-04-24 17:08:38 发布
阅读量122 收藏
点赞数
分类专栏： 九、jdk1.5新特性 文章标签： 泛型 类型推断 泛型限定 自定义泛型
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a1974117511/article/details/84400078
版权

一、简介

 

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

二、泛型

 

  • 泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。
  • 用于解决安全问题，是一个类型安全机制。
  • 这种参数类型可以用在类、接口和方法的创建中，
  • 分别称为泛型类、泛型接口、泛型方法。
  • 泛型是提供给javac编译器使用的
  • 如集合中的泛型可以限定输入类型
  • 让编译器挡住源程序中的非法输入
  • 编译器编译带类型说明的集合时会去掉“类型”信息，使程序运行效率不受影响
  • getClass方法的返回值和原始类型完全一样
  • 由于编译生成的字节码会去掉泛型的类型信息（泛型擦除），
  • 只要能跳过编译器，就可以往某个泛型集合中加入其他类型的数据
  • 例如：用反射得到集合，再调用其add方法即可
import java.util.*;

public class GenericTest {

	public static void main(String[] args) throws Exception{
		ArrayList<String> a1 = new ArrayList<String>();
		a1.add("abc");
		ArrayList<Integer> a2 = new ArrayList<Integer>();
		a2.add(3);
		
		System.out.println(a1.getClass() == a2.getClass());
				
		//通过反射就可以将Integer添加到a1中
		a1.getClass().getMethod("add", Object.class).invoke(a1, 5);
		System.out.println(a1);
	}
}

 

三、重要结论

 

  1. 实验发现上述例子中如果将最后一句改为：System.out.println(a1.get(1))，就会出现 java.lang.ClassCastException
  2. 通过jad工具反编译class文件得出结论：
  3. 通过反射可以绕过编译器，向指定了泛型的集合中添加其他类型的元素
  4. 但是通过get方法调用时如果泛型为String将在get方法前加上强转(String)
  5. 如果泛型是其他类型，则不会强转
  6. 如果在get得到元素后还有其他操作，即像get(1).getClass()之类的操作
  7. 也会加上对应泛型类型的强转
  8. 也就是说泛型有可能会影响到class文件的内容，并不是完全擦除泛型

 

四、初步了解泛型

 

  • ArrayList<E>类定义和ArrayList<Integer>类引用中涉及的术语
  • 整个称为ArrayList<E>泛型类型
  • ArrayList<E>中的E称为类型变量或类型参数
  • ArrayList<Integer>中的Integer称为类型参数的实例或实际类型参数
  • ArrayList<Integer>中的<>念typeof
  • ArrayList称为原始类型
  • 参数化类型与原始类型的兼容性
  • 参数化类型可以引用一个原始类型的对象，编译报告警告
  • 如：Collection<String> c = new Vector();
  • 原始类型可以引用一个参数化类型的对象，编译报告警告
  • 如：Collection c = new Vector<String>();
  • 参数化类型不考虑类型参数的继承关系
  • Vector<String> v = new Vector<Object>();//错误
  • Vecotr<Object> v = new Vector<String>();//错误
  • 在创建数组实例时，数组的元素不能实用参数化的类型，例如，下面渔具有错误
  • Vector vector1[] = new Vector[10];//正确
  • Vector<Integer> vector[] = new Vector<Integer>[10];//错误cannot create a generic array of Vector<Integer>

五、规则和限定

 

  1. 泛型的类型参数只能是类类型（包括自定义类），不能是简单类型。
  2. 泛型的参数类型可以使用extends语句，例如<T extends superclass>。习惯上称为“有界类型”。
  3. 泛型的参数类型还可以是通配符类型。例如Class<?> classType = Class.forName("java.lang.String");
  4. ？通配符，也可以理解为占位符
  5. ？extends E：可以接收E类型或者E的子类型。上限 ArrayList(Collection<? extends E> c)
  6. ？super E：可以接收E类型或者E的父类型。下限 TreeSet(Comparator<? super E> comparator)
import java.util.*;

/**
 * 定义一个方法，该方法用于打印出任意集合中的数据
 * 
 * 使用？通配符可以引用其他各种参数化的类型
 * ？通配符定义的变量主要用作引用
 * 可以调用与参数无关的方法，不能调用与参数化有关的方法
 */
public class GenericTest {

	public static void main(String[] args) {
		ArrayList<String> list = new ArrayList<String>();
		list.add("abc");
		list.add("hjx");
		printCllection(list);
		
		ArrayList<Integer> list1 = new ArrayList<Integer>();
		list1.add(5);
		list1.add(8);
		printCllection(list1);
	}

	private static void printCllection(Collection<?> collection) {
		//collection.add("d12");
		System.out.println(collection.size());
		for(Object obj : collection)
			System.out.println(obj);
	}
}
想要实现添加等操作参数的方法时，就必须写成泛型T，而不是用通配符？

 

限定通配符的上边界
Vector<? extends Number> x = new Vector<Integer>();//正确
Vector<? extends Number> x = new Vector<String>();//错误
限定通配符的下边界
Vector<? super Integer> x = new Vector<Number>();//正确
Vector<? super Integer> x = new Vector<Byte>();//错误

 

六、示例

import java.util.*;

public class GenericTest {

	public static void main(String[] args){
		HashMap<String,Integer> map = new HashMap<String, Integer>();
		map.put("zhangsan", 20);
		map.put("lisi", 18);
		map.put("wangwu", 16);
		
		printMap(map);
	}

	private static void printMap(HashMap<String, Integer> map) {
		Iterator<Map.Entry<String, Integer>> entrySet = map.entrySet().iterator();
		while(entrySet.hasNext())
		{
			Map.Entry<String, Integer> mapEntry = entrySet.next();
			String key = mapEntry.getKey();
			Integer value = mapEntry.getValue();
			System.out.println(key+":"+value);
		}
	}
}

 

七、类型推断

 

  • 编译器判断泛型方法的实际类型参数的过程称为类型推断
  • 类型推断是相对于知觉推断的，其实现方法是一个非常复杂的过程
  • 根据调用泛型方法时实际传递的参数类型或返回值的类型来推断
  •     如果不接收返回值，传入的类型相同就是这个类型，传入的类型不同则取父类的最小交集，见示例1
  •     如果要接收返回值，则优先考虑接收变量的类型，并在class文件中加入强转 ，见示例2
  •     参数类型的类型推断具有传递性 ，见示例3
示例1
public class GenericTest {

	public static void main(String[] args){
		add(5,6);	//推断为Integer
		add(5,3.0); //推断为Number
		add(5,"");	//推断为Object
	}
	private static <T> T add(T x,T y)
	{
		//return x + y; 加法运算可能不适合T类型不能用
		return null;
	}
}
  
示例2
public class GenericTest {

	public static void main(String[] args) 
	{
		String str = autoConvert("abc");//推断为String
		int x = autoConvert(45);//推断为Integer
		int x = autoConvert("adf");//推断为Integer，运行时会出现转换异常
		autoConvert(45);//推断为Object
		System.out.println(str+":"+x);
	}

	private static <T> T autoConvert(Object obj) {
		return (T)obj;
	}
}
如果将autoConvert(Object obj)改为autoConvert(T t)
int x = autoConvert(45);//推断为Integer
autoConvert(45);//推断为Integer
int x = autoConvert("adb");//不能通过编译，只能传入Integer，因为类型已经确定为Integer
  
示例3
static <T> void copy(T[] a,T[] b){
}
copy(new Integer[5],new String[5]);//推断为Object
static <T> void copy(Collection<T> a,T[] b){
}
copy(new Vector<String>(),new Integer[5]);//推断为String，所以编译不能通过，只能传入String数组
 

八、泛型方法

 

  • 泛型类定义的泛型，在整个类中有效，
  • 如果被方法使用，那么泛型类的对象明确要操作的具体类型后，所有方法要操作的类型就已经固定了
  • 为了让不同方法可以操作不同类型，而且类型还不确定，那就可以将泛型定义在方法上 
  • 用于放置泛型的类型参数的尖括号应出现在方法的其他所有修饰符之后，返回类型之前
  • 按照惯例，类型参数通常用耽搁大写字母表示
  • 除了在应用泛型时可以实用extends限定符，在定义泛型时也可以
  •     如：public <A extends Annotation> A getAnnotation(Class<A> annotationClass){}
  • 并且可以用&来指定多个边界
  •     如：<V extends Serializable & Cloneable> void method(){}
  • 普通方法、构造方法、静态方法都可以用泛型
  • 特殊之处：静态方法不可以访问类上定义的泛型（因为它优先于对象存在）
  • 如果静态方法操作的引用数据类型不确定，可以将泛型定义在方法上
  • 也可以用类型变量表示异常，称为参数化的异常，可以用于方法的throws列表中，但不能用于catch子句中
  • 在泛型中可以同时有多个类型参数，用逗号隔开，如：Map<String,Integer> 
/**
 * 定义方法打印任意类型数据
 */
public class GenericTest {

	public static void main(String[] args) 
	{
		print("haha");
		print(123);
	}

	public static <T> void print(T t)
	{
		System.out.println(t);
	}
}
  
import java.util.*;

/**
 * 定义方法交换任意类型数组中的两个元素的位置
 * 
 * 因为泛型类型只能是引用数据类型，所以基本数据类型的数组，操作不了
 */
public class GenericTest {

	public static void main(String[] args) 
	{
		String[] strs = {"123","abc","hahh"};
		swap(strs,0,1);
		System.out.println(Arrays.toString(strs));
		
		Integer[] ints = {2,5,6};
		swap(ints,1,2);
		System.out.println(Arrays.toString(ints));
	}

	public static <T> void swap(T[] t,int x,int y)
	{
		T temp = t[x];
		t[x] = t[y];
		t[y] = temp;
	}
}
  
import java.util.Arrays;
import java.util.Collection;
import java.util.Date;
import java.util.Vector;

public class GenericTest {

	public static void main(String[] args) {
		String[] strs = {"56","nihao","zhangsan"};
		fillArray(strs,"liuliu");
		System.out.println(Arrays.toString(strs));
		
		copy1(new String[10],new String[10]);
		copy2(new String[10],new Vector<String>());
		
		copy1(new String[10],new Date[10]);
		//copy2(new String[10],new Vector<Date>());//因为泛型的传递性，数组应该定义为Date型，编译失败
	}

	/**
	 * 把任意类型集合中的数据安全的复制到相应类型的数组中
	 * @param dest	目标数组
	 * @param src	源集合
	 */
	private static <T> void copy2(T[] dest,Collection<T> src) {
		int x = 0;
		for(T t : src)
		{
			dest[x] = t;
			x++;
		}
	}

	/**
	 * 把任意类型数组中的数据安全的复制到相应类型的另一个数组中
	 * @param dest	目标数组
	 * @param src	源数组
	 */
	private static <T> void copy1(T[] dest,T[] src) {
		for(int x=0;x<src.length;x++)
		{
			dest[x] = src[x];
		}
	}

	/**
	 * 该方法可以将任意类型的数组中的所有元素填充为相应类型的某个对象
	 * @param t 数组
	 * @param obj  填充的对象 
	 */
	private static <T> void fillArray(T[] t,T obj) {
		for(int x=0;x<t.length;x++)
			t[x] = obj;
	}
}
 

九、自定义泛型类

 

class Gen<T> 
{
	private T ob; //定义泛型成员变量
	public Gen(T ob) 
	{
		this.ob = ob;
	}
	public T getOb() 
	{
		return ob;
	}
	public void setOb(T ob) 
	{
		this.ob = ob;
	}
	public void showType() 
	{
		System.out.println("T的实际类型是: " + ob.getClass().getName());
	}
}
public class GenDemo 
{
	public static void main(String[] args)
	{
		//定义泛型类Gen的一个Integer版本
		Gen<Integer> intOb=new Gen<Integer>(88);
		intOb.showType();
		int i= intOb.getOb();
		System.out.println("value= " + i);
		System.out.println("----------------------------------");
		//定义泛型类Gen的一个String版本
		Gen<String> strOb=new Gen<String>("Hello Gen!");
		strOb.showType();
		String s=strOb.getOb();
		System.out.println("value= " + s);
	}
}

 

十、通过反射获取泛型的实际类型

import java.lang.reflect.*;
import java.util.*;

public class GenericTest {
	public static void main(String[] args) throws Exception
	{
		//想要获得v的泛型的实际类型，要通过一个方法
		Vector<Date> v = new Vector<Date>();
		
		Method method = GenericTest.class.getMethod("apply", Vector.class);
		Type[] types = method.getGenericParameterTypes();
		ParameterizedType type = (ParameterizedType) types[0];
		System.out.println(type.getRawType());
		System.out.println(type.getActualTypeArguments()[0]);
	}
	public static void apply(Vector<Date> v)
	{
		
	}
}

 

//按照声明顺序返回 Type 对象的数组，这些对象描述了此 Method 对象所表示的方法的形参类型的
public Type[] getGenericParameterTypes(){}

//Type 是 Java 编程语言中所有类型的公共高级接口。它们包括原始类型、参数化类型、数组类型、类型变量和基本类型
public interface Type

//ParameterizedType 表示参数化类型，如 Collection<String>，从jdk5开始
public interface ParameterizedType extends Type
{
	//返回表示此类型实际类型参数的 Type 对象的数组
	Type[] getActualTypeArguments();

	//返回 Type 对象，表示声明此类型的类或接口
	Type getRawType();
}

 

S_壮
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
高级java_1泛型
weixin_45488518的博客
06-07 87
泛型1. 什么是泛型2. 泛型的好处3. 定义一个泛型接口4. 泛型实例化5. 在泛型类里可以声明泛型方法6. 泛型绑定7. 原始类型和向后兼容8. 通配符8.1 常用的 T，E，K，V，？8.2 无界、上界、下界8.5 ？和 T 的区别9. 泛型类的共享问题 1. 什么是泛型 泛型是参数化类型的能力。可以在类、接口或方法中声明泛型类型，并在使用类、接口或方法时指定具体类型。 2. 泛型的好处 通过泛型可以定义类型安全的数据结构（类型安全），而无须使用实际的数据类型，并且所有的强制转换都是自动和隐式的（可扩
java泛型机制
qq_63039989的博客
11-28 275
泛型，字面上理解就是广泛的数据类型。其实就是将数据类型进行参数化,可以达到进一步的代码复用和使得程序更安全的目的泛型的基本定义泛型的特点：在声明一个变量或者属性的时候不设置其数据类型，而是在指定结构使用的时候进行动态的配置。使用泛型解决了强制类型转化的设计缺陷。
《java基础知识》Java 泛型详解
weixin_30640769的博客
09-21 324
JDK 1.5 之后，Java 通过泛型解决了容器类型安全这一问题，而几乎所有人接触泛型也是通过Java的容器。那么泛型究竟是什么？ 泛型的本质是参数化类型；也就是说，泛型就是将所操作的数据类型作为参数的一种语法。 先对比一下有泛型和无泛型的写法。 无泛型 public class Dog{ String name; int age; /...
Java 泛型
shuaishuaipenggg的博客
09-02 81
Java 泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。假定我们有这样一个需求：写一个排序方法，能够对整型数组、字符串数组甚至其他任何类型的数组进行排序，该如何实现？答案是可以使用。使用 Java 泛型的概念，我们可以写一个泛型方法来对一个对象数组排序。然后，调用该泛型方法来对整型数组、浮点数数组、字符串数组等进行排序。
Java泛型中的那些字母是什么意思？(E、T、K、V、S)
嘻嘻哈哈学技术
04-24 3363
跟着我，嘻嘻哈哈学技术
Java基础之泛型
zhaluo_dehezi的博客
12-28 145
泛型:            java泛型.诞生于JDK1.5版本; 作用: 增强java集合,让集合可以记住你存储的类型,并在编译的时候就可以检测;  除了对集合有所增强外.java泛型还增强了接口和继承类.让子类和实现类在派生上更加灵活多样化; ↓↓↓↓↓↓↓↓↓↓ 文章下方会有实例演示↓↓↓↓↓↓↓↓↓↓↓↓↓ 历史: JDK 1.5 以前        没有泛型，...
什么是泛型？
hncboy的博客
12-13 3336
一、泛型的概念 泛型是 Java SE5 出现的新特性，泛型的本质是类型参数化或参数化类型，在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型。 二、泛型的意义 一般的类和方法，只能使用具体的类型：要么是基本类型，要么是自定义的类。如果要编写可以应用于多种类型的代码，这种刻板的限制对代码的束缚就会很大。 Java 在引入泛型之前，表示可变对象，通常使用 Object 来实现，...
C#泛型概念的简介与泛型的使用
08-26
namespace _1_3_1泛型Generic { class DyArray { private T[] arr; //泛型数组 public int Lenght; //数组大小 //构造函数 public DyArray(int size) { this.Lenght = size; arr = new T[size]; } //向...
java泛型总结
04-09
### Java泛型总结 #### 一、Java泛型概述 Java泛型是在JDK5之后引入的一个特性，它提供了一种类型安全的机制，用于指定集合或其他数据结构中的元素类型。通过使用泛型，程序员可以在编译阶段检测类型错误，避免了...
1.java泛型定义.zip
06-15
1.java泛型定义.zip1.java泛型定义.zip1.java泛型定义.zip1.java泛型定义.zip1.java泛型定义.zip1.java泛型定义.zip1.java泛型定义.zip1.java泛型定义.zip1.java泛型定义.zip1.java泛型定义.zip1.java泛型定义.zip1....
java泛型中 ?,T,S,K,字母的区别
热门推荐
古柏树下的博客
07-13 2万+
在代码中经常会看到这样的函数 public static void printColl(ArrayList<?> al){ Iterator<?> it = al.iterator(); while(it.hasNext()) { System.out.println(it.next().toString(...
java泛型中的E，K，V，T，U，S
斜阳雨陌
07-03 9541
java <s>_Java泛型PECS原则
weixin_39840606的博客
02-22 283
我们偶尔会看到针对泛型的一些用法：比如 extends T> 和 super T>，那么这两种定义有什么区别？分别适合用在什么场合？ 在回答这2个问题之前，我们先看一下几个相关的例子:假设我们有5个类，结构如下：class Animal {}class Dog extends Animal {}class SmallDog extends Dog {}class BigDog ext...
ArrayList集合基础
JIE结弦的博客
10-26 347
ArrayList构造方法： ArrayList<e>() 创建一个初始容量为 10 的空容器。 泛型<e>： 是一种特殊的数据类型，泛型； <e>括号内只能写引用数据类型； 给定类型用于对集合容器存储的数据类型进行限制。 成员方法： add(元素)： 将元素添加到集合容器的末尾； add(索引,元素) ：将元素插入此列表中的指定索引位置； remove (元素)：删除指定的元素，返回布尔结果，是否删除成功； remove (索引)：删.
黑马程序员------集合
qq_24217323的博客
11-05 382
——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-概述： 1、集合就是一个容器 2、集合中存储的对象不是实体对象，而是地址值 3、集合在jdk1.5之后可以存入基本数据类型（实际上数据会自动装箱，存入的还是对象） 为什么有不同的容器: 因为他们的数据结构不同（数据结构=存储方式）集合框架： Collection：所有容器的父类（接口）Collectio
Java泛型中的PECS原则
林北
07-05 453
本文转载自飞翔的猫咪 今天在写代码的时候使用到了这样一个方法签名：public void foo(Map<String, String> map);在写这个参数的时候正好在想一些关于泛型的东西，于是:public void foo(Map<? extends String, ? extends String> map);这两种写法有什么区别呢？记得以前和同学讨论过这个问题，但后来没有记下来，渐渐又淡忘了。今天又去翻了好多资料，总算找到一些可以参考的，赶紧记在这里方便以后温故知新啦。好
非常领先的分布式数据库Oceanbase OBCP 3.0培训教材
最新发布
09-05
非常领先的分布式数据库Oceanbase OBCP 3.0培训教材
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值