252泛型的使用总结

泛型的使用总结

泛型的使用

1.泛型类和泛型方法

/*
class 类型名<泛型标识，泛型标识， ...>{
    private 泛型标示 变量名;
}
*/
public class GenericDemo<T> {
    private T key;

    public GenericDemo(T key) {
        this.key = key;
    }

    public T getKey() {
        return key;
    }

    public void setKey(T key) {
        this.key = key;
    }

    public static void main(String[] args) {
        
        /*
        类名<具体的数据类型> 对象名 = new 类目<具体的数据类型>();

        JDK1.7后，可以省略成这样：
        类名<具体的数据类型> 对象名 = new 类目<>();
        */
        GenericDemo<Integer> integerGenericDemo = new GenericDemo<>(10);
        GenericDemo<String> stringGenericDemo = new GenericDemo<>("abc");
        //如果没有指定具体的数据类型，此时，操作类型是Object
        GenericDemo genericDemo = new GenericDemo("genericDemo");

        System.out.println(integerGenericDemo.key);
        System.out.println(stringGenericDemo.key);
        System.out.println(genericDemo.key);
        //泛型类型在逻辑上可以看成是多个不同的类型，但实际上是相同类型
      System.out.println(integerGenericDemo.getClass()==stringGenericDemo.getClass());    //输出结果为true
    }
}

 

⒉泛型接口和泛型方法

语法

修饰符 <T,E,...> 返回值类型 方法名（形参列表）{
    方法体... 
}

 

public interface GeneratorInterface<T> {
　　public T next();
}

public class FruitGenerator<T> implements GeneratorInterface<T> {

    @Override
    public T next() {
        return null;
    }
}

public class VegetablesGenerator implements GeneratorInterface<String> {

    private String[] vegetables = new String[]{"Potato", "Tomato"};

    @Override
    public String next() {
        Random rand = new Random();
        return vegetables[rand.nextInt(2)];
    }
}

 

3.泛型通配符

package demo02;

import java.util.ArrayList;
import java.util.Iterator;

/*
  泛型的通配符：
      ？代表任意的数据类型
  使用方式：
          不能创建对象使用
          只能作为方法的参数使用
*/
public class demo02Generic {
    public static void main(String[] args) {
        ArrayList<Integer> list1=new ArrayList<>();
        list1.add(1);
        list1.add(2);

        ArrayList<String> list2=new ArrayList<>();
        list2.add("哈哈");
        list2.add("嗯嗯");
        printArray(list1);
        printArray(list2);

    }
    /*
       定义一个方法，能遍历所有类型的ArrayList集合
       这时候我们不知道ArrayList集合使用什么数据类型，可以泛型的通配符
       ？来接受数据类型
       注意：
          泛型没有继承概念
    */
    public  static void printArray(ArrayList<?> list){
        //使用迭代器遍历集合
        Iterator<?> it=list.iterator();
        while(it.hasNext()){
            //it.next()方法，取出的元素是Object,可以接收任意的数据类型
            Object i=it.next();
            System.out.println(i);

        }

    }
}

高级的泛型通配符--受限泛型

package demo02;

import java.util.ArrayList;
import java.util.Collection;

public class Demo03Generic {
    public static void main(String[] args) {
        Collection<Integer> list1=new ArrayList<Integer>();
        Collection<String> list2=new ArrayList<String>();
        Collection<Number> list3=new ArrayList<Number>();
        Collection<Object> list4=new ArrayList<Object>();

        getElement(list1);
        getElement(list2);//报错
        getElement(list3);
        getElement(list4);//报错

        getElement2(list1);//报错
        getElement2(list2);//报错
        getElement2(list3);
        getElement2(list4);

        /*
          类与类之间的继承关系
          Integer extends Number extends Object
          String extends Object
        */

    }
    //泛型的上限：此时的泛型？，必须是Number类型或者Number类型的子类
    public  static  void getElement(Collection<? extends  Number> coll) {
    }
    //泛型的下限：此时的泛型？，必须是Number类型或者Number的父类
    public  static void getElement2(Collection<? super  Number> coll){}
}