一、泛型使用

1、泛型类

// 含一个泛型参数
public class Chirld1<T> {
    private T value1;

    private void set(T v) { value1 = v; }
}

// 含两个泛型参数
public class Chirld2<T, K> {
    private T value1;
    private K value2;

    private void set(T v) { value1 = v; }

    private K get() { return value2; }
}

2、泛型函数

public <T, K> T soller(K parsm1, T parsm2) {
    return parsm1 == null ? parsm2 : null;
}

二、泛型限定符

1、泛型上限

• 泛型上限使用 extends 限制

public class N<T extends Number> {
    private T value;
    public N(T value) { this.value = value; }
    public T get() { return value; }
}

public <T extends Comparable> boolean compare(T n1, T n2) {
    return n1.compareTo(n2) >= 0;
}

public void main(String[] args) {
    N<Integer> t1 = new N<Integer>(3);
    N<Integer> t2 = new N<Integer>(4);
    boolean result = compare(t1.get(), t2.get());
    System.out.println(result);
}

• 多个限制，使用 & 追加；接口可以由多个，类只能有一个，并且类必须放在第一位；

public class BaseClazz { }
public interface Interface1 { void method1(); }
public interface Interface2 { void method2(); }

public class Child extends BaseClazz implements Interface1, Interface2 {
    @Override
    public void method1() { }
    @Override
    public void method2() { }
}

public <T extends BaseClazz & Interface1 & Interface2> void doMethod(T obj) {
    obj.method1();
    obj.method2();
}

public void main(String[] args) {
    Child child = new Child();
    doMethod(child);
}

2、泛型下限

• 泛型下限使用 super 限制，super 只能和通配符 ? 一起使用

public class Food { }
public class Fruit extends Food { }
public class Apple extends Fruit { }
public class ApplePie extends Apple { }

public void doMethod() {
    List<? super Apple> list1 = new ArrayList<Apple>();     // ok
    List<? super Apple> list2 = new ArrayList<Fruit>();     // ok
    List<? super Apple> list3 = new ArrayList<ApplePie>();  // error
}

3、无界通配符 ?

• 无界通配符 ？ 只能用于声明，不能用于定义

List<?> list = new ArrayList<Integer>(); // ok
public class Apple<?> { } // error

• 上界通配符：<? extends Food>

List<? extends Fruit> list1 = new ArrayList<Fruit>();   // ok
List<? extends Fruit> list2 = new ArrayList<Apple>();   // ok
List<? extends Fruit> list3 = new ArrayList<Food>();    // error

• 下界通配符：<? super Apple>

List<? super Fruit> list1 = new ArrayList<Fruit>();   // ok
List<? super Fruit> list2 = new ArrayList<Food>();    // ok
List<? super Fruit> list3 = new ArrayList<Object>();  // ok
List<? super Fruit> list4 = new ArrayList<Apple>();   // error