- 泛型有三种使用方式:泛型类、泛型接口、泛型方法
- 泛型通配符,比如T、E、K、V等,为了增加可读性,通常情况下
“?”,表示不确定的java类型
“T(type)”,表示具体的一个java类型
“K V(key value)”,分别代表java键值中的key、value
“E(element)”,表示Element
一、泛型类
泛型类用于类的定义中,被称为泛型类。最典型的就是各种容器类,如List、Set和Map。
泛型类的最基本用法:
class 类名称<泛型标识:可以随便写任意标识号,标识指定的泛型的类型>{
private 泛型标识 var; //定义一个变量
··· ···
}
例子:
public class Test<T> {
private T key;
public Test(T key) {
this.key = key;
}
public T getKey() {
return key;
}
public static void main(String args[]) {
Test<Integer> testInteger = new Test<Integer>(12345);
Test<String> testString = new Test<String>("test");
Test testBoolean = new Test(true); //不一定要传入泛型实参
System.out.println("testInteger:::" + testInteger.getKey());
System.out.println("testString:::" + testString.getKey());
System.out.println("testBoolean:::" + testBoolean.getKey());
}
}
注意:不能对确切的泛型类型使用instanceOf操作,下面的操作是非法的
if(testInteger instanceOf Test<Integer>) {}
二、泛型接口
泛型接口与泛型类的定义及基本使用相同。泛型接口常被用在各种类的生产器中
//定义一个泛型接口
public interface Test<T> {
public T next();
//实现泛型接口的类,未传入泛型实参
//在声明类的时候,需将泛型的声明也一起加到类中
class One<T> implements Test<T>{
@Override
public T next() {
return null;
}
}
//实现泛型接口的类,传入泛型实参
//所有使用泛型的地方都要替换成传入的参数类型
class Two implements Test<String>{
private String[] fruits = new String[] {"apple", "Banana", "Pear"};
@Override
public String next() {
Random random = new Random();
return fruits[random.nextInt(2)];
}
}
}
三、泛型方法
3.1 泛型方法的使用
java中,泛型方法的定义较为复杂
泛型类,在实例化类的时候指明泛型的具体类型;
泛型方法,在调用方法的时候指明泛型的具体类型
泛型方法的定义例子:
public <T> T genericMethod(Class<T> tClass){
T instance = tClass.newInstance();
return instance;
}
注意:
- public 与 返回值T 中间的 < T>非常重要,有了这个,表示声明此方法为泛型方法
- 只有声明了< T>的方法才是泛型方法,泛型类中使用了泛型的成员变量并不表示其实一个泛型方法
- < T>表明该方法将使用泛型类型 T
- 泛型方法能使方法独立于类而产生变化,如果static方法要使用泛型能力,就必须使其成为泛型方法
下面的两个例子,注意看注释哦!
例1:
//泛型类
public class Generic<T>{
private T key;
public Generic(T key) {
this.key = key;
}
//不是一个泛型方法,只是类中一个普通的成员方法
public T getKey(){
return key;
}
/**
* 这个方法显然是有问题的,在编译器会给我们提示这样的错误信息"cannot reslove symbol E"
* 因为在类的声明中并未声明泛型E,所以在使用E做形参和返回值类型时,编译器会无法识别。
public E setKey(E key){
this.key = keu
}
*/
}
例2:
public class GenericTest {
/**
* 这才是一个真正的泛型方法。
* 首先在public与返回值之间的<T>必不可少,这表明这是一个泛型方法,并且声明了一个泛型T
* 这个T可以出现在这个泛型方法的任意位置.
* 泛型的数量也可以为任意多个
* 如:public <T,K> K showKeyName(Generic<T> container){
* ...
* }
*/
public <T,K> T showKeyName(Generic<T> container){
System.out.println("container key :" + container.getKey());
//当然这个例子举的不太合适,只是为了说明泛型方法的特性。
T test = container.getKey();
return test;
}
//这也不是一个泛型方法,这就是一个普通的方法,只是使用了Generic<Number>这个泛型类做形参而已。
public void showKeyValue1(Generic<Number> obj){
Log.d("泛型测试","key value is " + obj.getKey());
}
//这也不是一个泛型方法,这也是一个普通的方法,只不过使用了泛型通配符?
//同时这也印证了泛型通配符章节所描述的,?是一种类型实参,可以看做为Number等所有类的父类
public void showKeyValue2(Generic<?> obj){
Log.d("泛型测试","key value is " + obj.getKey());
}
/**
* 这个方法是有问题的,编译器会为我们提示错误信息:"UnKnown class 'E' "
* 虽然我们声明了<T>,也表明了这是一个可以处理泛型的类型的泛型方法。
* 但是只声明了泛型类型T,并未声明泛型类型E,因此编译器并不知道该如何处理E这个类型。
public <T> T showKeyName(Generic<E> container){
...
}
*/
/**
* 这个方法也是有问题的,编译器会为我们提示错误信息:"UnKnown class 'T' "
* 对于编译器来说T这个类型并未项目中声明过,因此编译也不知道该如何编译这个类。
* 所以这也不是一个正确的泛型方法声明。
public void showkey(T genericObj){
}*/
}
泛型方法可以出现在任何地方和任何场景中使用,但是 “泛型方法出现在泛型类中” 这种情况是非常特殊的
public class GenericFruit {
static class Fruit{
@Override
public String toString() {
return "fruit";
}
}
static class Apple extends Fruit{
@Override
public String toString() {
return "apple";
}
}
static class Person{
@Override
public String toString() {
return "Person";
}
}
static class GenerateTest<T>{
public void show_1(T t){
System.out.println(t.toString());
}
//在泛型类中声明了一个泛型方法,使用泛型E,这种泛型E可以为任意类型。可以类型与T相同,也可以不同。
//由于泛型方法在声明的时候会声明泛型<E>,因此即使在泛型类中并未声明泛型,编译器也能够正确识别泛型方法中识别的泛型。
public <E> void show_3(E t){
System.out.println(t.toString());
}
//在泛型类中声明了一个泛型方法,使用泛型T,注意这个T是一种全新的类型,可以与泛型类中声明的T不是同一种类型。
public <T> void show_2(T t){
System.out.println(t.toString());
}
}
public static void main(String[] args) {
Person person = new Person(); //如果Person不声明为静态类时,会报错
Apple apple = new Apple();
GenerateTest<Fruit> generateTest = new GenerateTest<Fruit>();
//apple是Fruit的子类,所以这里可以
generateTest.show_1(apple);
//编译器会报错,因为泛型类型实参指定的是Fruit,而传入的实参类是Person
//generateTest.show_1(person);
//使用这两个方法都可以成功
generateTest.show_2(apple);
generateTest.show_2(person);
//使用这两个方法也都可以成功
generateTest.show_3(apple);
generateTest.show_3(person);
}
}
3.2 泛型方法与可变参数
public class Test{
public static <T> void printMsg(T... args){
for(T t:args){
System.out.println(t);
}
}
public static void main(String args[]) {
printMsg("111", 222, 2.333);
}
}
3.3 静态方法与泛型
如果静态方法要使用泛型的话,必须将静态方法也定义成泛型方法;
静态方法无法访问类上定义的泛型;
如果静态方法操作的引用数据类型不确定的时候,必须要将泛型定义在方法上。
//静态类
public class StaticGenerator<T> {
....
....
/**
* 如果在类中定义使用泛型的静态方法,需要添加额外的泛型声明(将这个方法定义成泛型方法)
* 即使静态方法要使用泛型类中已经声明过的泛型也不可以。
* 如:public static void show(T t){..},此时编译器会提示错误信息:
"StaticGenerator cannot be refrenced from static context"
*/
public static <T> void show(T t){
}
}
//非静态类
public class Test{
/**
* 如果在类中定义使用泛型的静态方法,需要添加额外的泛型声明(将这个方法定义成泛型方法)
* 即使静态方法要使用泛型类中已经声明过的泛型也不可以。
* 如:public static void show(T t){..},此时编译器会提示错误信息:
"StaticGenerator cannot be refrenced from static context"
*/
public static <T> void show(T t){
System.out.println(t);
}
}
3.4 泛型上下界(宽泛地指定泛型类型)
3.4.1 为泛型添加上边界(传入的类型实参必须是指定类型的子类型)
class TestEphemeral<T extends Number>{
private T key;
public TestEphemeral(T key) {
this.key = key;
}
public T getKey() {
return key;
}
}
public class Test<T>{
public static void showKeyValue(TestEphemeral<? extends Number> obj) {
System.out.println("泛型测试::key is:::" + obj.getKey());
}
public static <T extends Number> T showKeyName(TestEphemeral<T> container) {
System.out.println("contains key :::" + container.getKey());
T test = container.getKey();
return test;
}
public static void main(String args[]) {
TestEphemeral<Integer> ephemeral = new TestEphemeral<Integer>(666);
TestEphemeral<Float> ephemeral2 = new TestEphemeral<Float>(2.33f);
TestEphemeral<Double> ephemeral3 = new TestEphemeral<Double>(3.1415);
// 报错
// TestEphemeral<String> ephemeral4 = new TestEphemeral<String>("test");
showKeyName(ephemeral);
showKeyName(ephemeral2);
showKeyName(ephemeral3);
}
}
四、泛型数组
在java中是不能创建一个确切的泛型类型的数组的
List<String>[] ls = new ArrayList<String>[10]; //错误
但是,使用通配符创建泛型数组时可以的:
List<?>[] ls = new ArrayList<?>[10];
//或
List<String>[] ls = new ArrayList[10];
五、使用Object表示泛型
class MemoryCell{
private Object storedValue;
public Object read() {
return storedValue;
}
public void write(Object x) {
storedValue = x;
}
}
public class Test<T>{
public static void main(String args[]) {
MemoryCell m = new MemoryCell();
m.write("22222");
String val = (String)m.read(); // 注意这里的强转
}
}
注意:
- 为了方法对象的特定的方法,必须要强制转换成正确的类型
- 不能使用基本类型,只能使用引用类型。
六、使用接口类表示泛型
首先说一下Java中的 IS-A关系和 Has-A 关系
IS-A 关系是继承关系,例如:苹果是一种水果
class Apple extends Fruit{}
Has-A关系是组成关系,例如:一个房间有一张桌子
class Room{
··· ···
Table table = new Table();
··· ···
}
Has-A 关系是动态(运行时)绑定,而继承关系是静态(编译时)绑定。
class FindMaxDemo{
public static Comparable findMax(Comparable[] arr){
int maxIndex = 0;
for(int i = 1; i < arr.length; i++ ){
if(arr[i].compareTo(arr[maxIndex])>0){
maxIndex = i;
}
}
return arr[ maxIndex ];
}
public static void main(String [] args){
Shape[] sh1 = {new Circle(2.0)),
new Square(2.0)),
new Rectangle(2.0)};
System.out.println(findMax(sh1)); //假设shape implements Comparable
}
}
// 泛型findMax 案例,使用Shape和String 演示pre-Java 5
七、数组类型的兼容性(这里还不是很懂)
Employee IS-A Person,那么这是不是就代表数组 Employee[] IS-A Person[]?即一个方法接收 Person[] 作为参数,但是能不能把 Employee[] 作为参数传递进去?
假设除了Employee外,还有 Student IS-A Person,并且假设 Employee[] 和 Person[] 类型是兼容的。
//Student IS-A Person, Employee IS-A Person
Person[] arr = new Employee[5];
arr[0] = new Student(); //出现ClassCastException异常
参考文章:
Java泛型详解:https://blog.csdn.net/s10461/article/details/53941091
Java泛型指南:https://blog.csdn.net/qq_36622496/article/details/108998744
什么是泛型:https://www.liaoxuefeng.com/wiki/1252599548343744/1265102638843296