泛型总结
泛型标记
泛型标记 对应单词 说明
E Element 在容器中使用,表示容器中的元素
T Type 表示普通的Java类
K Key 表示键,比如Map中的key
V Value 表示值
N Number 表示数值类型
定义泛型类
package com.example.test;
/**
* 定义泛型类
* @param <T>
*/
public class Generic<T> {
private T flag;
public void setFlag(T flag){
this.flag = flag;
}
public T getFlag() {
return this.flag;
}
}
package com.example.test;
/**
* 测试泛型类
*/
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);
}
}
定义泛型接口
package com.example.test;
/**
* 定义泛型接口
* @param <T>
*/
public interface Igeneric<T> {
T getName(T name);
}
package com.example.test;
/**
* 泛型接口实现类
*/
public class IgenericImpl implements Igeneric<String> {
@Override
public String getName(String name) {
return name;
}
}
package com.example.test;
/**
* 测试
*/
public class Test {
public static void main(String[] args) {
Igeneric<String> igeneric = new IgenericImpl();
String str = igeneric.getName("example");
System.out.println(str);
}
}
定义泛型方法
非静态方法
语法结构
public <泛型表示符号> void getName(泛型表示符号 name){ }
public <泛型表示符号> 泛型表示符号 getName(泛型表示符号 name){ }
package com.example.test;
/**
* 泛型方法
*/
public class MethodGeneric {
public <T> void setName(T name){
System.out.println(name);
}
public <T> T getName(T name){
return name;
}
}
package com.example.test;
/**
* 测试
*/
public class Test {
public static void main(String[] args) {
MethodGeneric methodGeneric = new MethodGeneric();
methodGeneric.setName("example");
String str = methodGeneric.getName("example");
System.out.println(str);
}
}
静态方法
语法结构
public static <泛型表示符号> void setName(泛型表示符号 name){ }
public static <泛型表示符号> 泛型表示符号 getName(泛型表示符号 name){ }
静态方法中使用泛型时有一种情况需要注意一下:
那就是静态方法无法访问类上定义的泛型;如果静态方法操作的引用数据类型不确定的时候,必须要将泛型定义在方法上
package com.example.test;
/**
* 泛型方法
*/
public class MethodGeneric {
public static <T> void setName(T name) {
System.out.println(name);
}
public static <T> T getName(T name) {
return name;
}
}
package com.example.test;
/**
* 测试
*/
public class Test {
public static void main(String[] args) {
MethodGeneric.setName("example");
String str = MethodGeneric.getName("example");
System.out.println(str);
}
}
泛型方法可变参数
可变参数的特点:
(1)只能出现在参数列表的最后
(2)调用可变参数的方法时,编译器为该可变参数隐含创建一个数组,在方法体中一数组的形式访问可变参数
package com.example.test;
/**
* 泛型方法
*/
public class MethodGeneric {
/**
* 泛型方法可变参数
* 传过来的可以是数组也可以是多个单独的参数
* 但是这边都会当数组处理
* @param args
* @param <T>
*/
public <T> void method(T... args) {
for (T t : args) {
System.out.println(t);
}
}
}
package com.example.test;
/**
* 测试
*/
public class Test {
public static void main(String[] args) {
//(1)
MethodGeneric methodGeneric = new MethodGeneric();
methodGeneric.method("a","b","c");
//(2)
String[] arr = new String[]{"a", "b", "c"};
methodGeneric.method(arr);
}
}
无界通配符
“?” 表示类型通配符,用于代替具体的类型。它只能在“<>”中使用。可以解决当具体类型不确定的问题
语法结构
public void showFlag(Generic<?> generic){ }
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());
}
}
@Test
public void test() {
ShowMsg showMsg = new ShowMsg();
Generic<Integer> generic = new Generic<>();
generic.setFlag(20);
showMsg.showFlag(generic);
}
通配符的上限限定
语法结构 ?只能是Number或者Number的子类
public void showFlag(Generic<? extends Number> generic){ }
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<? extends Number> generic){
System.out.println(generic.getFlag());
}
}
@Test
public void testSix() {
ShowMsg showMsg = new ShowMsg();
Generic<Integer> generic = new Generic<>();
generic.setFlag(20);
showMsg.showFlag(generic);
}
通配符的下限限定
语法结构 ?只能是Integer或者Integer的父类 不适用于泛型类
public void showFlag(Generic<? super Integer> generic){ }
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<? super Number> generic){
System.out.println(generic.getFlag());
}
}
@Test
public void testSix() {
ShowMsg showMsg = new ShowMsg();
Generic<Number> generic = new Generic<>();
generic.setFlag(50);
showMsg.showFlag(generic);
}
泛型总结
泛型主要用于编译阶段,编译后生成的字节码 class 文件不包含泛型中的类型信息。 类型参数在编译后会被替换成 Object,运行时虚拟机并不知道泛型。因此,使用泛型时,如下几种情况是错误的:
一:基本类型不能用于泛型
Test<int> t; 这样写法是错误,我们可以使用对应的包装类;Test<Integer> t ;
二:不能通过类型参数创建对象
T elm = new T(); 运行时类型参数 T 会被替换成 Object,无法创建 T 类型的对象,容 易引起误解,所以在 Java 中不支持这种写法