java 泛型基础总结

一：为啥要使用泛型

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

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

泛型，JDK1.5新加入的，解决数据类型的安全性问题，其主要原理是在类声明时通过一-个标识表示类中某个属性的类型或者是某个方法的返回值及参数类型。这样在类声明或实例化时只要指定好需要的具体的类型即可。

Java泛型可以保证如果程序在编译时没有发出警告，运行时就不会产生ascastxcetion异常。同时，代码更加简洁、健壮。

 二：使用泛型

三：泛型的几个重要使用

3.1在集合中使用泛型

    @Test
    public void test1()//在集合中未使用泛型,就可以添加任何类型，但是强转类型的时候容易发生异常
    {
        ArrayList arrayList = new ArrayList();
        arrayList.add(1);
        arrayList.add("AAA");////1.没有使用泛型，任何Object及其子类的对象都可以添加进来
        arrayList.add(1.2);
        for (int i = 0; i < arrayList.size(); i++) {
            int score = (Integer)arrayList.get(i);////2.强转为int型时，可能报ClassCastException的异常
            System.out.println(score);
        }
    }
    @Test
    public void test2(){//在集合中使用泛型，限制了加入数据的类型，在编译是就可以判断类型正确与否
        List<Integer> list = new ArrayList<Integer>();
        list.add(78);
        list.add(87);
//        list.add("AA");//直接在编译的时候就会显示错误
    }
    @Test
    public void test3(){//在集合中使用泛型
        Map<String ,Integer> map = new HashMap<>();
        map.put("AA", 78);
        map.put("BB", 87);
        map.put("DD", 98);
        Set<Map.Entry<String, Integer>> entries = map.entrySet();
        Iterator iterator = entries.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());//整体输出
        }
        for (Map.Entry<String,Integer> o:entries){
            System.out.println(o.getKey()+"------->"+o.getValue());
        }
    }

3.2自定义泛型类

3.2.1对象实例化时不指名泛型，默认为Object类型

3.2.2泛型不同的引用不能相互赋值

3.2.3加入集合的对象类型必须与指定的泛型类型一致

3.2.4静态方法中不能使用类的泛型

3.2.5如果泛型类是一个接口或抽象类，则不可以创建泛型类的对象，必须子类指明泛型的类别

3.2.6不能在catch中使用泛型

3.2.7从泛型类派生子类，泛型类型需要具体化

 定义一个泛型类Order，泛型类型为T，一旦实例化对象指明泛型T的类别时，类中所有T就都确定了，

public class Order<T> {
    private String orderName;
    private int orderId;
    private T t;
    List<T> list = new ArrayList<>();
    public void add(){
        list.add(t);
    }
    public  T getT(){
        return t;
    }
    public void setT(T t){
        this.t = t;
    }
//    public static T show(){//static方法属于类，不被实例化就可以加载，所以不能在static方法中使用泛型的声明
//        System.out.println(t);
//    }
//    public void info()
//    {
//        try{//不可以在try-catch中使用类的泛型的声明
//
//        }catch(T e){
//
//        }
//    }
    //声明一个泛型方法,这个类型不同于类的泛型，因此类实例化不会决定该类型，只会在调用的时候确定
public static <E> E getE(E e){
    return e;
}
//实现数组到集合的复制
    public <E> List<E> fromArrayToList(E[]e,List<E> list){
        for (E e1:e){
            list.add(e1);
        }
        return list;
    }

}

子类指明泛型的具体类型

 //继承泛型或泛型接口时，可以指定泛型具体的类型 2 class SubOrder extends Order<Integer>{} 

 @Test
    public void test4()
    {
        //1：当实例化泛型的对象时，指明泛型的类型
        //指明以后，对应的泛型中所有使用泛型的位置，都变为实例化指定的类型
        //2：如果我们自定义了泛型类，但是实例化时没有使用，那么默认时Object类的
        Order<Boolean> booleanOrder = new Order<Boolean>();
        booleanOrder.add();
        System.out.println(booleanOrder.getT());
        booleanOrder.setT(true);
        System.out.println(booleanOrder.getT());
        //当通过对象调用泛型方法时，指明泛型方法的类型
        Integer i =booleanOrder.getE(23);
        Double i1 =booleanOrder.getE(2.3);
        Integer [] id = new Integer[]{1,2,34};
        ArrayList<Integer> arrayList = new ArrayList<>();
        booleanOrder.fromArrayToList(id,arrayList);
        System.out.println(arrayList);
    }

    /**
     * 泛型与继承的关系：若类A是类B的子类，那么List<A>就不是List<B>的子类
     */
    @Test
    public void test5(){
        Object object= null;
        String str = "";
        object = str;

        Object[] objects = null;
        String[] strs = new String[]{"AA","BB","CC"};
        objects = strs;

        List<Object> list = new ArrayList<>();
        List<String> list1 = new ArrayList<>();
//        list = list1 //Object是String的父类，，但是List<Object>和List<String>是同级，不能直接赋值
    }

3.3泛型方法

3.4泛型与继承的关系

        List<Object> list = new ArrayList<>();
        List<String> list1 = new ArrayList<>();
//        list = list1 //Object是String的父类，，但是List<Object>和List<String>是同级，不能直接赋值

下面是泛型使用在继承上的一个demo例子

DAO父类

package Generic;

public class DAO<T> {
    public void add(T t){
        //...
    }
    public T get(int index){
        return null;
    }
    public void delete(int index){

    }
}

子类CustomerDAO继承父类，泛型类型是Customer

package Generic;

public class CustomerDAO extends DAO<Customer>{
}

自定义类型Customer的实现

  package Generic; 2 3 public class Customer { } 

测试

package Generic;

public class TestCustomer {
    public static void main(String[] args) {
        CustomerDAO c = new CustomerDAO();
        c.add(new Customer());
        c.get(0);
    }
}

3.5通配符

   @Test
    public void test7(){
        List<String> list = new ArrayList<>();
        list.add("AA");
        list.add("BB");
        List<?> list1 = new ArrayList<>();
        list1 = list;
        Iterator<?> iterator = list1.iterator();//可以对通配符的对象赋值进行遍历
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
//        list1.add("vv");//不允许向声明为通配符的集合类中调用add写入对象，唯一例外的是null
//        list1.add(123);
        list1.add(null);
    }

    @Test
    public void test6(){
        List<?> list = null;
        List<Object> list1 = new ArrayList<>();
        List<String> list2 = new ArrayList<>();
        list = list1;
        list = list2;

        show(list1);
//        show(list2);
        show1(list1);
        show1(list);

        List<? extends Number> list3 = null;
        List<Integer> list4 = null;
        list3 = list4;
//        list3 = list1;
        List<? super Number> list5 = null;
        list5 = list1;
    }

 3.6 类中的泛型方法

public class GenericFruit {
    class Fruit{
        @Override
        public String toString() {
            return "fruit";
        }
    }

    class Apple extends Fruit{
        @Override
        public String toString() {
            return "apple";
        }
    }

    class Person{
        @Override
        public String toString() {
            return "Person";
        }
    }

    class GenerateTest<T>{
        public void show_1(T t){
            System.out.println(t.toString());
        }

        //在泛型类中声明了一个泛型方法，使用泛型E，这种泛型E可以为任意类型。可以类型与T相同，也可以不同。
        //由于泛型方法在声明的时候会声明泛型<E>，因此即使在泛型类中并未声明泛型，编译器也能够正确识别泛型方法中识别的泛型。
        public <E> void show_3(E t){
            System.out.println(t.toString());
        }

        //在泛型类中声明了一个泛型方法，使用泛型T，注意这个T是一种全新的类型，可以与泛型类中声明的T不是同一种类型。
        public <T> void show_2(T t){
            System.out.println(t.toString());
        }
    }

    public static void main(String[] args) {
        Apple apple = new Apple();
        Person person = new Person();

        GenerateTest<Fruit> generateTest = new GenerateTest<Fruit>();
        //apple是Fruit的子类，所以这里可以
        generateTest.show_1(apple);
        //编译器会报错，因为泛型类型实参指定的是Fruit，而传入的实参类是Person
        //generateTest.show_1(person);

        //使用这两个方法都可以成功
        generateTest.show_2(apple);
        generateTest.show_2(person);

        //使用这两个方法也都可以成功
        generateTest.show_3(apple);
        generateTest.show_3(person);
    }
}

 对于静态方法要使用泛型的话，必须要将泛型定义在方法上

3.7 泛型数组

 不能创建一个具体的泛型数组，因为jvm会在运行期间擦除泛型类型，可以用通配符，这样任意类型的都可以加入，不会出现错误。

一篇不错的泛型博文