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;

    }

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