public class NormalGenericsClass {
private T key;
public Generics(T key){
this.key = key;
}
public T getKey() {
return key;
}
public void setKey(T key) {
this.key = key;
}
}
// 泛型类实例
NormalGenericsClass a = new NormalGenericsClass(0);
// Java7 开始支持省略后面的参数类型
NormalGenericsClass a = new NormalGenericsClass<>(0);
普通泛型接口
// Java中的 Comparator接口
public interface Comparator {
int compare(T o1, T o2);
boolean equals(Object obj);
}
// 接口实现例子 java.text.Collator
public abstract class Collator implements java.util.Comparator
普通泛型方法
private int normalGenericsMethod(Generics i){
// 表示声明 T为泛型，写在返回值类型之前
// 也可以声明多个泛型，如：
return 0;
}
// 这是错误的，会提示 Cannot resolve symbol "T"
/*private int normalGenericsMethod(Generics i){
return 0;
}*/
public class GenericsUpperBound extends NormalGenericsClass {
public GenericsUpperBound(T key){
super(key);
}
}
上界为具体的接口
public T compareWith(T[] arr){
T start = arr[0];
for(int i = 1; i < arr.length; i++){
System.out.print(start.equals(arr[i]));
}
return start;
}
上界为其他类型参数
public class OtherUpperBound{
public void otherArgs(NormalGenericsClass a){
// E是OtherUpperBound的类型参数，T是otherArgs方法的类型参数
// T的上界限定为E
}
}
//例子：
OtherUpperBound a = new OtherUpperBound<>;
OtherUpperBound b = new OtherUpperBound<>;
a.otherArgs(b);
四、通配符
有限定通配符
//重写6中的方法
public void otherArgs(NormalGenericsClass a){
}
class Base implements Comparable
class Child extends Base
// 希望重写Comparable的比较方法
/*
class Child extends Base implements Comparable
// 错误，因为类型擦除的原因，实际实现的都是Comparable接口，接口不允许被实现两次
*/
// 正确重写Comparable的比较方法的方式
class Child extends Base {
@Override
public int compareTo(Base o){
if(!(o instanceof Child){
throw new IllegalArgumentException();
}
Child c = (Child)o;
实现代码
return 0;
}
其他代码
}
类型参数不能作为静态变量和静态方法的类型
Class Normal{
public static demo1(T param){
// 错误的方法
}
public static void demo2(E param){
// 正确的方法
}
}
不能通过类型参数创建对象
T a = new T(); // error Type parameter "T" cannot be instantiated directly
六、泛型的使用细节
Java中的泛型是通过类型擦除实现的，类型参数在编译时会被替换为Object
对于不同传入的类型实参，生成的相应对象实例一样
Generics demo = new Generics<>(123);
Generics demo2 = new Generics<>("test");
System.out.println(demo.getClass() == demo2.getClass()); // true
/**
如果在类中定义使用泛型的静态方法，需要添加额外的泛型声明（将这个方法定义成泛型方法）
即使静态方法要使用泛型类中已经声明过的泛型也不可以。
如：public static void show(T t){..},此时编译器会提示错误信息
"StaticGenerator cannot be refrenced from static context"
*/
public static void show(T t){
}
泛型的上下边界添加，必须与泛型的声明一起
//在泛型方法中添加上下边界限制的时候，必须在权限声明与返回值之间的上添加上下边界，
//即在泛型声明的时候添加
//public T showKeyName(Generic container)
编译器会报错："Unexpected bound"
public T showKeyName(Generic container){
System.out.println("container key :" + container.getKey());
T test = container.getKey();
return test;
}
基本类型不能用于实例化类型参数 泛型要求能包容的是对象类型，基本类型在java中不属于对象
运行时类型查询只适用于原始类型
NormalGenericsClass a = new NormalGenericsClass<>(0);
a instanceof NormalGenericsClass;
// Error Illegal generic type for instanceof
a instanceof NormalGenericsClass;
// Error Cannot resolve symbol "T"
a instanceof NormalGenericsClass; // Pass
a instanceof NormalGenericsClass; // Pass
a.getClass(); // class com.example.demo.generics.NormalGenericsClass
类型推断只对赋值操作有效 Eg:
public class New{
public static Map map(){
return new HashMap();
}
}
/**
-- 方法中传参
这时编译器不会执行类型判断。在这种情况下，编译器认为：调用泛型方法后，
其返回值被赋给一个Object类型的变量
*/
public class Test{
public static void main(String args[]){
fun(New.map());
}
}
public class Test{
public static void main(String args[]){
fun(New.
参考资料: [1]《Java编程的逻辑》 [2]《Thinking in Java》 [3] https://blog.csdn.net/s10461/... [4] https://www.cnblogs.com/lwbqq...
