java学习(泛型编程generics)

以下代码实现了对三个不同类型的数组的打印

public class Generics {
    public static void main(String[] args){
        Integer[] intArray = {1, 2, 3, 4, 5};
        Double[] doubleArray = {1.1, 2.2, 3.3, 4.4, 5.5};
        Character[] charArray = {'H', 'E', 'L', 'L', 'O'};

        printArray(intArray);
        printArray(doubleArray);
        printArray(charArray);
    }

    public static <E> void printArray(E[] inputArray){
        for(E element : inputArray){
            System.out.printf("%s ",element);
        }
        System.out.println();
    }

}

说明
1. Integer与int的区别：Integer是一个类，int是基本数据类型，这是他们的根本区别。因此，如果需要往ArrayList或HashMap等里面放东西，必须使用Integer而不能用int。泛型也不支持int这种基本数据类型而必须用Integer类。double和Double，string和String，char和Character，float和Float类似
2. 泛型方法都有一个类型参数声明，该类型参数申明部分在返回值类型之前（）
3. 若有多个类型参数，用逗号隔开
4. 类型参数也可以用来声明返回值类型

若想限制泛型类型参数的类型范围，直接在类型参数声明后面加extends+类或接口名，如下例

public class Generics{
    public static <T extends Comparable<T>> T maximun(T x,T y,T z){
        T max = x;
        if(y.compareTo(max) > 0){
            max = y;
        }
        if(z.compareTo(max) > 0){
            max = z;
        }
        return max;
    }

    public static void main(String[] args){
        System.out.printf("%d,%d,%d中最大的是：%d",3,5,4,maximun(3, 5, 4));
        System.out.println();

        System.out.printf("%f,%f,%f中最大的是：%f",1.1,3.3,2.2,maximun(1.1, 3.3, 2.2));
        System.out.println();

        System.out.printf("%s,%s,%s中最大的是：%s","hello","world","java",maximun("hello", "world", "java"));
        System.out.println();
    }
}

该泛型类型参数只能接受实现了Comparable接口的类

泛型类

泛型类的申明和非泛型类的声明类似，区别仅在于泛型类在类名后添加了类型参数声明，若有多个类型参数，用逗号隔开

public class Generics{
    public static void main(String[] args){
        Box<Integer> integerBox = new Box<Integer>();
        Box<String> stringBox = new Box<String>();

        integerBox.set(new Integer(5));
        System.out.println(integerBox.get());

        stringBox.set(new String("hello"));
        System.out.println(stringBox.get());

    }
}

class Box<T>{
    private T t;
    public T get(){
        return this.t;
    }
    public void set(T t){
        this.t = t;
    }
}

在new一个泛型类的实例的时候，需要给出特定的类初始化泛型类的类型参数

泛型通配符

public class Generics{
    public static void main(String[] args){
        List<String> name = new ArrayList<String>();
        List<Integer> age = new ArrayList<Integer>();
        List<Number> number = new ArrayList<Number>();

        name.add("icon");
        age.add(18);
        number.add(314);

        getData(name);
        getData(age);
        getData(number);

        //getNumber(name);
        getNumber(age);
        getNumber(number);

    }

    public static void getData(List<?> data){
        System.out.println("data: " + data.get(0));
    }

    public static void getNumber(List<? extends Number> data){
        System.out.println("data: " + data.get(0));
    }
}

1. 使用?代替具体的参数类型，比如上面的List

理解

public class Generics{
    public static <T extends Comparable<T>> void mySort1(List<T> list){
        Collections.sort(list);

    }

    public static <T extends Comparable<? super T>> void mySort2 (List<T> list){
        Collections.sort(list);
    }

    public static void main(String[] args){
        List<Animal> animals = new ArrayList<Animal>();
        animals.add(new Animal(15));
        animals.add(new Animal(30));

        List<Dog> dogs = new ArrayList<Dog>();
        dogs.add(new Dog(20));
        dogs.add(new Dog(28));

        mySort1(animals);
        mySort2(animals);
        //mySort1(dogs);
        mySort2(dogs);
    }
}

class Animal implements Comparable<Animal>{
    protected int age;

    public Animal(int age){
        this.age = age;
    }

    @Override
    public int compareTo(Animal o) {
        // TODO Auto-generated method stub

        return this.age - o.age;
    }

}


class Dog extends Animal{
    public Dog(int age){
        super(age);
    }
}

上面这个程序，用sort1排序dogs时报错，而sort2排序时正确，说明sort2的T的条件更宽松，允许实现了该接口的类和它的子类使用。若子类想实现自己的Comparable接口，直接重写该接口的方法覆盖父类的该方法即可

参考： http://www.cnblogs.com/xiaomiganfan/p/5390252.html