java中的泛型

为什么要有泛型(Generic)?

1. 解决元素存储的安全性问题

2. 解决获取数据元素时，需要类型强转的问题

1.泛型的声明

  interfaceList<T> 和 class TestGen<K,V>

  其中，T,K,V不代表值，而是表示类型。这里使

           用任意字母都可以。常用T表示，是Type的缩写。

 

2.泛型的实例化：

     一定要在类名后面指定类型参数的值（类型）。如：

          List<String>strList = newArrayList<String>();

        Iterator<Customer> iterator = customers.iterator();

T 只能是类，不能用基本数据类型填充。

泛型的几个重要使用：

1.在集合中使用泛型

2.自定义泛型类

3.泛型方法

4.泛型接口

在集合中使用泛型：

List<Integer> list = new ArrayList<Integer>();
        list.add(78);
        list.add(87);
        Iterator<Integer> it = list.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }

Map<String,Integer> map = new HashMap<>();
        map.put("AA", 78);
        map.put("BB", 87);
        map.put("DD", 98);
        
        Set<Map.Entry<String,Integer>> set = map.entrySet();
        for(Map.Entry<String,Integer> o : set){
            System.out.println(o.getKey() + "--->" + o.getValue());
        }

自定义泛型类（仿照着colletion接口编写）：

public class TestT<T>{} 类名后面加泛型。

然后程序中就可以使用T了。

//1.当实例化泛型类的对象时，指明泛型的类型。
        //指明以后，对应的类中所有使用泛型的位置，都变为实例化中指定的泛型的类型
        //2.如果我们自定义了泛型类，但是在实例化时没有使用，那么默认类型是Object类的

例子：

public class TestT<T> {
    private String id;
    private String name;
    private T t;
    private List<T> list=new ArrayList<>();

}

使用时：

TestT<String> t=new TestT<>();//指明泛型为String
        t.setT("Aa");
        String t2 = t.getT();
        System.out.println(t2);

//继承泛型类或泛型接口时，可以指明泛型的类型，则子类中所有的泛型都变成指明的泛型。如果没有指明泛型，则子类也为泛型类

class subT extends TestT<Integer>{}；//指明泛型

class subT<T> extends TestT<T>{}//未指明泛型

dao中使用泛型举例：

//父类

public class TestDaoI<T> {
    public void add(T t){
        
    }
    public void delete(String index){
        
    }
    public T getT(String index){
        return null;
    }
    public List<T> getForList(){
        return null;
    }
}

//具体子类，指明泛型

public class TestPersonDaoI extends TestDaoI<Person> {
    
}

泛型方法：（泛型方法中的泛型不一定要跟该类的泛型一致，该类的泛型是T,泛型方法可以是E）

public  <E> E getE(E e){
        return e;
    }

泛型与继承的关系:
     * 若类A是类B的子类，那么List<A>就不是List<B>的子接口，List<A>与List<B>是并列关系。

 * 通配符 ?
     * List<A>、List<B>、。。。。都是List<?>的子类
     *
     * ? extends A :可以存放A及其子类
     * ? super A:可以存放A及其父类
     */
    @Test
    public void test6(){
        List<?> list = null;
        List<Object> list1 = new ArrayList<Object>();
        List<String> list2 = new ArrayList<String>();
        list = list1;
        list = list2;
        //Number是Integer的父类
        List<? extends Number> list3 = null;
        List<Integer> list4 = null;
        list3 = list4;
        List<? super Number> list5 = null;
        list5 = list1;
    }

静态方法中不能使用类的泛型。（类具有泛型，则在实例化时要指明该类的泛型，静态方法可以类名直接调用，此时还没有对象，泛型还未指明。）