【Java 泛型】泛型用法 ( 泛型类用法 | 泛型方法用法 | 泛型通配符 ? | 泛型安全检查 )
【摘要】
文章目录
一、泛型类用法二、泛型方法用法三、泛型通配符 <?>四、泛型安全检查五、完整代码示例1、泛型类 / 方法2、main 函数
一、泛型类用法
...
一、泛型类用法
泛型类用法 : 使用时先声明泛型 , 如果不声明泛型 , 则表示该类的泛型是 Object 类型 ;
泛型类代码 :
public class Student<T> {
private String name;
private int age;
/**
* 该数据的类型未知
* 使用泛型表示 , 运行时确定该类型
*/
private T data;
public Student(String name, int age, T data) {
this.name = name;
this.age = age;
this.data = data;
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
指明泛型类型 : 指定 泛型类 的泛型为 String 类型 , 那么在该类中凡是使用到 T 类型的位置 , 必须是 String 类型 , 泛型类的 泛型声明 , 使用时在 类名后面 声明 ;
// 指定 泛型类 的泛型为 String 类型
// 那么在该类中凡是使用到 T 类型的位置 , 必须是 String 类型
// 泛型类的 泛型声明 , 使用时在 类名后面 声明
Student<String> student = new Student("Tom", 16, "Cat");
String data = student.getData();
- 1
- 2
- 3
- 4
- 5
不指明泛型类型 : 如果不 指明泛型类型 , 则 泛型类型 默认为 Object 类型 ; 如下面的示例 , 获取的 泛型类型的变量也是 Object 类型 , 需要强转为 String 类型 ;
// 如果不 指明泛型类型
// 则 泛型类型 默认为 Object 类型
Student student1 = new Student("Tom", 16, "Cat");
// 获取的 泛型类型的变量也是 Object 类型 , 需要强转为 String
String data1 = (String) student1.getData();
- 1
- 2
- 3
- 4
- 5
二、泛型方法用法
泛型方法 : 给下面的泛型方法 , 传入 String 作为参数 , 则 泛型方法中的 T 的类型就是 String 类型 ;
public <T, A> T getData2(T arg){
T data = arg;
return data;
}
- 1
- 2
- 3
- 4
指定泛型的方法 : 指定 泛型方法 的泛型类 , 泛型方法 的泛型声明 , 在调用时 方法名的前面 声明 ; 这种用法很少见 ;
// 指定 泛型方法 的泛型类
// 泛型方法 的泛型声明 , 在调用时 方法名的前面 声明
student.<String, Integer>getData2("Mouse");
- 1
- 2
- 3
不指定泛型的方法 : 泛型方法 中 也可以不声明泛型类型 , 传入的参数是 泛型 T 类型 , 如果给传入参数设置 String , 隐含将泛型 T 设置为 String 类型 ;
// 泛型方法 中 也可以不声明泛型类型
// 传入的参数是 泛型 T 类型
// 如果给传入参数设置 String , 隐含将泛型 T 设置为 String 类型
String data2 = student.getData2("Mouse");
- 1
- 2
- 3
- 4
三、泛型通配符 <?>
如果现在的泛型类型不确定 , 则使用 ? 作为通配符 , 该用法与将泛型类型指定为 Object 类型用法相同 ;
? 通配符用法示例 :
// 使用 <?> 通配符作为泛型
// 默认将泛型指定为 Object 类型
Student<?> student2 = new Student("Tom", 16, "Cat");
String data2 = (String) student1.getData();
- 1
- 2
- 3
- 4
上述 ? 通配符用法等效于下面的不指定泛型的用法 :
// 如果不 指明泛型类型
// 则 泛型类型 默认为 Object 类型
Student student1 = new Student("Tom", 16, "Cat");
// 获取的 泛型类型的变量也是 Object 类型 , 需要强转为 String
String data1 = (String) student1.getData();
- 1
- 2
- 3
- 4
- 5
四、泛型安全检查
注意下面 2 2 2 种泛型的用法 , 推荐使用第一种方法 ;
// 泛型的安全检查
// 推荐写法
Student<String> student3 = new Student<>("Tom", 16, "Cat");
// 不推荐写法
Student student4 = new Student<String>("Tom", 16, "Cat");
- 1
- 2
- 3
- 4
- 5
使用 new 关键字创建对象 , 是发生在运行时 , 也就是 new Student<String>("Tom", 16, "Cat") 代码是在运行时才会执行 , 根本起不到 编译时 安全检查 的作用 , 从 安全检查 方面考虑 , 这种写法没有意义 ;
以 List 泛型为例 :
- 编译期进行安全检查示例 :
// 编译器 在 编译期 进行检查
List<String> list1 = new ArrayList<>();
list1.add(1);
- 1
- 2
- 3
会报如下错误 ;
- 编译期不进行安全检查示例 :
// 编译器 在 编译期 不进行检查
List list2 = new ArrayList<String>();
list2.add(1);
- 1
- 2
- 3
该代码没有任何报错 ;
五、完整代码示例
1、泛型类 / 方法
/**
* 泛型类
* 该 T 类型作为参数使用
* T 是参数化类型 , 可以由外部传入
*
* @param <T>
*/
public class Student<T> {
private String name;
private int age;
/**
* 该数据的类型未知
* 使用泛型表示 , 运行时确定该类型
*/
private T data;
public Student(String name, int age, T data) {
this.name = name;
this.age = age;
this.data = data;
}
/**
* 该方法不是泛型方法
* 该方法是普通方法 , 返回值类型是 T 类型
* @return
*/
public T getData() {
return data;
}
public void setData(T data) {
this.data = data;
}
/**
* 泛型方法 , 是将某个类型作为参数传入
* 方法指定泛型 , 写法如下 ;
*
* 该方法是泛型方法
* 方法指定了 2 个泛型
* 泛型个数 , 泛型的个数可以有很多个
* 多个泛型之间 , 使用逗号隔开
*
* 泛型方法指定的泛型 T 与类中的泛型 T 没有任何关系
* 这两个 T 可以是不同的类型
*
* 泛型方法中定义的泛型 T
* 与参数类型的 T
* 返回值类型的 T
* 方法内部的 T
* 都是同一个类型
*
* 与泛型类中的 T 完全没有关系
*
* @param <T>
* @param <A>
* @return
*/
public <T, A> T getData2(T arg){
T data = arg;
return data;
}
public <T> T getData4(T arg){
T data = arg;
return data;
}
/**
* 如果静态方法中使用类 类中的泛型
* 这种使用时错误的
*
* 如果必须在 静态方法 中使用泛型 T
* 则该泛型 T 必须是静态方法的泛型
* 不能是类的泛型
*
* @param arg
* @return
*/
public static <T> T getData3(T arg){
T data = arg;
return data;
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
2、main 函数
import java.util.ArrayList;
import java.util.List;
public class Main {
public static void main(String[] args) {
// 指定 泛型类 的泛型为 String 类型
// 那么在该类中凡是使用到 T 类型的位置 , 必须是 String 类型
// 泛型类的 泛型声明 , 使用时在 类名后面 声明
Student<String> student = new Student("Tom", 16, "Cat");
String data = student.getData();
// 如果不 指明泛型类型
// 则 泛型类型 默认为 Object 类型
Student student1 = new Student("Tom", 16, "Cat");
// 获取的 泛型类型的变量也是 Object 类型 , 需要强转为 String
String data1 = (String) student1.getData();
// 使用 <?> 通配符作为泛型
// 默认将泛型指定为 Object 类型
Student<?> student2 = new Student("Tom", 16, "Cat");
String data2 = (String) student1.getData();
// 泛型的安全检查
// 推荐写法
Student<String> student3 = new Student<>("Tom", 16, "Cat");
// 不推荐写法
Student student4 = new Student<String>("Tom", 16, "Cat");
// 指定 泛型方法 的泛型类
// 泛型方法 的泛型声明 , 在调用时 方法名的前面 声明
student.<String, Integer>getData2("Mouse");
// 泛型方法 中 也可以不声明泛型类型
// 传入的参数是 泛型 T 类型
// 如果给传入参数设置 String , 隐含将泛型 T 设置为 String 类型
String data3 = student.getData2("Mouse");
// 编译器 在 编译期 进行检查
List<String> list1 = new ArrayList<>();
list1.add(1);
// 编译器 在 编译期 不进行检查
List list2 = new ArrayList<String>();
//list2.add(1);
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
文章来源: hanshuliang.blog.csdn.net，作者：韩曙亮，版权归原作者所有，如需转载，请联系作者。
原文链接：hanshuliang.blog.csdn.net/article/details/120146649
【版权声明】本文为华为云社区用户转载文章，如果您发现本社区中有涉嫌抄袭的内容，欢迎发送邮件进行举报，并提供相关证据，一经查实，本社区将立刻删除涉嫌侵权内容，举报邮箱：
cloudbbs@huaweicloud.com
- 点赞
- 收藏
- 关注作者
评论（0）