Java中的泛型Generics

最新推荐文章于 2024-03-14 09:12:37 发布

ACerXiaoLuBan

最新推荐文章于 2024-03-14 09:12:37 发布

阅读量177

点赞数

分类专栏： Java基础文章标签： java

本文链接：https://blog.csdn.net/qq_41189226/article/details/117444991

版权

Java基础专栏收录该内容

19 篇文章 0 订阅

订阅专栏

1 泛型简介

1.1 泛型的基本概念

泛型是 JDK1.5 以后增加的，它可以帮助我们建立类型安全的集合。
泛型的本质就是“数据类型的参数化”，处理的数据类型不是固定的，而是可以作为参数传入。我们可以把“泛型”理解为数据类型的一个占位符(类似：形式参数)，即告诉编译器，在调用泛型时必须传入实际类型。这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。
参数化类型：

把类型当作是参数一样传递。
<数据类型> 只能是引用类型。

1.2 泛型的好处

在不使用泛型的情况下，我们可以使用 Object 类型来实现任意的参数类型，但是在使用时需要我们强制进行类型转换。这就要求程序员明确知道实际类型，不然可能引起类型转换错误；但是，在编译期我们无法识别这种错误，只能在运行期发现这种错误。使用泛型的好处就是可以在编译期就识别出这种错误，有了更好的安全性；同时，所有类型转换由编译器完成，在程序员看来都是自动转换的，提高了代码的可读性。

1.3 类型擦除

编码时采用泛型写的类型参数，编译器会在编译时去掉，这称之为“类型擦除”。
泛型主要用于编译阶段，编译后生成的字节码 class 文件不包含泛型中的类型信息，涉及类型转换仍然是普通的强制类型转换。类型参数在编译后会被替换成 Object，运行时虚拟机并不知道泛型。

2 泛型的使用

2.1 定义泛型

泛型字符可以是任何标识符，一般采用几个标记：E、T、K、V、N、？。

泛型标记	对应单词	说明
E	Element	在容器中使用，表示容器中的元素
T	Type	表示普通的Java类
K	Key	表示键，例如：Map中的键Key
V	Value	表示值
N	Number	表示数值类型
?		表示不确定的Java类型

2.2 泛型类

泛型类就是把泛型定义在类上，用户使用该类的时候，才把类型明确下来。泛型类的具体使用方法是在类的名称后添加一个或多个类型参数声明，如：、<T,K,V>。

public class Generic<T> {
	private T flag;
	public void setFlag(T flag){
		this.flag = flag;
	}
	public T getFlag(){
		return this.flag;
	}
}

public class Test {
	public static void main(String[] args) {
		Generic<String> generic = new Generic<>();
		generic.setFlag("admin");
		String flag = generic.getFlag();
		System.out.println(flag);
		
		Generic<Integer> generic1 = new Generic<>();
		generic1.setFlag(100);
		Integer flag1 = generic1.getFlag();
		System.out.println(flag1);
	}
}

2.3 泛型接口

泛型接口和泛型类的声明方式一致。泛型接口的具体类型需要在实现类中进行声明。

public interface Igeneric<T> {
	T getName(T name);
}

public class IgenericImpl implements Igeneric<String> {
	@Override
	public String getName(String name) {
		return name;
	}
}

public class Test2 {
	public static void main(String[] args) {
		IgenericImpl igeneric= new IgenericImpl();
		String name = igeneric.getName("oldlu");
		System.out.println(name);
		Igeneric<String> igeneric1 = new IgenericImpl();
		String name1 = igeneric1.getName("bjsxt");
		System.out.println(name1);
	}
}

2.4 泛型方法

泛型类中所定义的泛型，在方法中也可以使用。但是，我们经常需要仅仅在某一个方法上使用泛型，这时候可以使用泛型方法。
泛型方法是指将方法的参数类型定义成泛型，以便在调用时接收不同类型的参数。类型参数可以有多个，用逗号隔开，如：<K,V>。定义时，类型参数一般放到返回值前面。
调用泛型方法时，不需要像泛型类那样告诉编译器是什么类型，编译器可以自动推断出类型来。

2.4.1 非静态方法

public class MethodGeneric {
	public <T> void setName(T name){
		System.out.println(name);
	}
	public <T> T getName(T name){
		return name;
	}
}

public class Test3 {
	public static void main(String[] args) {
		MethodGeneric methodGeneric = new MethodGeneric();
		methodGeneric.setName("oldlu");
		methodGeneric.setName(123123);
		MethodGeneric methodGeneric2 = new MethodGeneric();
		String name = methodGeneric2.getName("Bjsxt");
		Integer name1 = methodGeneric2.getName(123);
		System.out.println(name1);
		System.out.println(name);
	}
}

2.4.2 静态方法

静态方法中使用泛型时有一种情况需要注意一下，那就是静态方法无法访问类上定义的泛型；如果静态方法操作的引用数据类型不确定的时候，必须要将泛型定义在方法上。

public class MethodGeneric {
	public static <T> void setFlag(T flag){
		System.out.println(flag);
	}
	public static <T> T getFlag(T flag){
		return flag;
	}
}

public class Test4 {
	public static void main(String[] args) {
		MethodGeneric.setFlag("oldlu");
		MethodGeneric.setFlag(123123);
		String flag = MethodGeneric.getFlag("bjsxt");
		System.out.println(flag);
		Integer flag1 = MethodGeneric.getFlag(123123);
		System.out.println(flag1);
	}
}

2.4.3 泛型方法与可变参数

在泛型方法中，泛型也可以定义可变参数类型。

public class MethodGeneric {
	public <T> void method(T... args){
		for(T t:args){
			System.out.println(t);
		}
	}
}

public class Test5 {
	public static void main(String[] args) {
		MethodGeneric methodGeneric = new MethodGeneric();
		String[] arr = new String[]{"a","b","c"};
		Integer[] arr2 = new Integer[]{1,2,3};
		methodGeneric.method(arr);
		methodGeneric.method(arr2);
		methodGeneric.method(123, "dfd", 13.3);
	}
}

2.5 通配符和上下限定

2.5.1 无界通配符

“?”表示类型通配符，用于代替具体的类型。它只能在“<>”中使用。可以解决当具体类型不确定的问题。

public class Generic<T> {
	private T flag;
	public void setFlag(T flag){
		this.flag = flag;
	}
	public T getFlag(){
		return this.flag;
	}
}

public class ShowMsg {
	public void showFlag(Generic<?> generic){
		System.out.println(generic.getFlag());
	}
}

public class Test6 {
	public static void main(String[] args) {
		ShowMsg showMsg = new ShowMsg();
		Generic<Integer> generic = new Generic<>();
		generic.setFlag(20);
		showMsg.showFlag(generic);
		Generic<Number> generic1 = new Generic<>();
		generic1.setFlag(50);
		showMsg.showFlag(generic1);
		Generic<String> generic2 = new Generic<>();
		generic2.setFlag("oldlu");
		showMsg.showFlag(generic2);
	}
}

2.5.2 通配符的上限限定

上限限定表示通配符的类型是 T 类以及 T 类的子类或者 T 接口以及 T 接口的子接口。该方式同样适用于泛型的上限限定。

public class ShowMsg {
	public void showFlag(Generic<? extends Number> generic){
		System.out.println(generic.getFlag());
	}
}

public class Test6 {
	public static void main(String[] args) {
		ShowMsg showMsg = new ShowMsg();
		Generic<Integer> generic = new Generic<>();
		generic.setFlag(20);
		showMsg.showFlag(generic);
		Generic<Number> generic1 = new Generic<>();
		generic1.setFlag(50);
		showMsg.showFlag(generic1);
	}
}

2.5.3 通配符的下限限定

下限限定表示通配符的类型是 T 类以及 T 类的父类或者 T 接口以及 T 接口的父接口。注意：该方式不适用于泛型的下限限定。

public class ShowMsg {
	public void showFlag(Generic<? super Integer> generic){
		System.out.println(generic.getFlag());
	}
}

public class Test6 {
	public static void main(String[] args) {
		ShowMsg showMsg = new ShowMsg();
		Generic<Integer> generic = new Generic<>();
		generic.setFlag(20);
		showMsg.showFlag(generic);
		Generic<Number> generic1 = new Generic<>();
		generic1.setFlag(50);
		showMsg.showFlag(generic1);
	}
}