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