泛型编程

泛型编程

泛型是java1.5引入的新特性，把明确的数据类型的工作放在创建对象或调用方法时进行，提供了编译时类型安全检测机制

泛型类

class Pair<T>{
	T min;
	T max;
	public Pair(T min2, T max2) {
		max = max2;
		min = min2;
	}
	public T getMax(){
		return max;
	}
	public T getMin(){
		return min;
	}
}

泛型方法

• ：限定类型变量实现了Comparable接口
• 泛型方法可以定义在普通类中，也可以定义在泛型类中

class ArrayAlg1{
	//限定类型变量实现了Comparable接口
	//这里extends继承接口，多个接口&分隔
	public static <T extends Comparable>Pair<T> minmax(T[] a)
	{
		if (a==null||a.length==0)return null;
		T min = a[0];
		T max = a[0];
		for(int j=1;j<a.length;j++){
			if(min.compareTo(a[j])>0)min = a[j];
			if(max.compareTo(a[j])<0)max = a[j];
		}
		return new Pair(min,max);
	}

	public static <T> T getMiddle(T... a){
		T b=a[a.length/2];
		return b;
	}
}

泛型接口

• 1.定义接口时确定类型
• 2.创建对象时确定类型

interface Inter<E>{
	void show(E e);
}

// 定义接口时确定类型
class InterImpl implements Inter<Integer>{
	@Override
	public void show(Integer e) {
		System.out.println(e);
	}
}

// 创建对象时确定类型
class InterImpl2<E> implements Inter<E>{
	@Override
	public void show(E e) {
		System.out.println(e);
	}
}

泛型通配符

通常约定
？： 表示不确定的 java 类型
T ： (type) 表示具体的一个java类型
K/V： (key value) 分别代表java键值中的Key Value
E ： (element) 代表Element

<? extends T>

• 如果传入的类型不是 E 或者 E 的子类，编译不成功
• 类型参数列表中如果有多个类型参数上限，用逗号分开

    private <K extends A, E extends B> E test(K arg1, E arg2){
    E result = arg2;
    arg2.compareTo(arg1);
    //.....
    return result;
    }

<? super T>

• 用 super 进行声明，表示参数化的类型可能是所指定的类型，或者是此类型的父类型，直至 Object

   // ArrayList源码foreach接收一个E或E父类类型
   class ArrayList<E> {
    public void forEach(Consumer<? super E> action) {
        Objects.requireNonNull(action);
        final int expectedModCount = modCount;
        @SuppressWarnings("unchecked")
        final E[] elementData = (E[]) this.elementData;
        final int size = this.size;
        for (int i=0; modCount == expectedModCount && i < size; i++) {
            action.accept(elementData[i]);
        }
        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
    }