java泛型

Java 1.5 泛型

泛型本质：参数化类型，避免类型转换，代码可复用

1. 泛型类：ArrayList，HashSet，HashMap等
2. 泛型方法：Collections.binarySearch，Arrays.sort等
3. 泛型接口：List，Iterator等

public class ArrayList<E> extends AbstractList<E> implements List<E>,RandomAccess,Cloneable,java.io.Serializable{
    public E get(int index){
        rangeCheck(index);
        
        return elementData(index);
    }
}

自定义泛型

泛型类

• 具有泛型变量的类

• 在类名后用 代表引入类型

• 多个字母表示多个引入类型，如<T,U>等

• 引入类型可以修饰成员变量/局部变量/参数/返回值

• 没有专门的template关键字

约定俗称：

• ArrayList E表示元素Element

• HashMap<K,V>，K表示Key，V白哦是Value

• 自定义泛型变量常用T，T表示Template

泛型类

//泛型类
public class Interval<T> {
    private T lower;
    private T upper;
    
    public Interval(T lower, T upper){
        this.lower = lower;
        this.upper = upper;
    }
    
    public T getLower(){
        return lower;
    }
    //部分get/set方法省略
    
    //注意：
    //	此处修饰词static <T>代表整个方法的引入类型（泛型）
    //	第一处Interval<T>代表返回值类型
    //	第二处Interval<T>代表参数类型
    public static <T> Interval<T> getReverse(Interval<T> interval){
        return new Interval<T>(interval.getUpper(), interval.getLower());
    }
}

//泛型类使用
public TestMain{
    public static void main(String[] agrs){
     	//创建自定义泛型类
        Interval<Integer> v1 = new Interval<Integer>(1,2);
        Interval<Integer> v2 = new Interval<>(1,2);
        //调用获取泛型类的方法
        Interval<Integer> v3 = Interval<Integer>.getReverse(v1);
    }
}

• 泛型类之间的继承
• Pair< S > 和Pair< T >没有任何关系，无论S和T之间是什么关系
• 泛型类可以扩展或实现其他的类，如ArrayList实现List

泛型方法

public class ArrayUtils{
    //注意：此处<T> 代表整个方法的引入参数类型，T代表返回值是泛型(必须为指定的引入参数类型)
    public static <T> T getMiddle(T...a){
        return a[a.length/2];
    }
}

//泛型参数使用
public TestMain{
    public static void main(String[] agrs){
		//<String>可以省略
        String s1 = ArrayUtils.getMiddle("aaa");
        String s2 = ArrayUtils.getMiddle("aaa", "bbb");
        //null is ok
        String s3 = ArrayUtils.getMiddle("aaa", "bbb", null);
        
        Interger i1 = ArrayUtils.getMiddle(1);
        Interger i2 = ArrayUtils.getMiddle(1,2);
    }
}

泛型接口

public interface Calculator<T>{
    public T add(T operand1, T operand2);
}

public class IntergerCalculator implements Calculator<Integer>{
    public Integer add(Integer operand1, Integer operand2){
        return operand1+operand2;
    }
}

//省略类型指定
IntergerCalculator c1 = new IntergerCalculator();
c1.add(1,2);

IntergerCalculator<Integer> c2 = new IntergerCalculator();
c2.add(1,2);

接口实现，接收泛型类

// Calcuator接口需要一个引入类型(泛型)，引入类型为含有泛型的类，
public class IntergerCalculator implements Calculator<Interval<Interger>>{
    //实现接口方法
    public Interger add(Interval<Interger> operand1, Interval<Interger> operand2){
        int lower = operand1.getLower()+operand2.getLower();
        int upper = operand1.getUpper()+operand2.getUpper();
        return new Interval<Interger>(lower,upper);
    }
}

泛型限制

• <T extends Comparable> 约定T必须是Comparable的子类
• extends 固定，后面可以多个，以&拼接，如<T extends Comparable & Serializable>
• extends 限定可以有多个接口，但只能一个类，且类必须排第一位
• 逗号分隔参数，<T extends File & Cloneable,U extends Serializabl>
• ？ 为通配符
• 上限界定符，Pair<? extends S>
  • Pair能接收的参数类型，S自身及其子类
  • 例如：Pair，Pair，Pair等
• 下限界定符，Pair<? super S>
  • Pair能接收的类型参数，是S的自身及其超类
  • 例如：Pair