java实用技巧---泛型

 泛型：
     把明确数据类型的工作，提前到了编译时期，在创建集合的时候明确存储元素的数据类型。
     这样的做法有点向把数据类型当作参数一样传递，所以泛型还有一个叫法：参数化类型

 泛型的语句定义格式：
     <引用数据类型>
     注意：尖括号中的数据类型只能是引用数据类型

 泛型的好处：
     1、将我们运行时期出现的问题，提前到编译时期
     2、不需要做强制类型转换
     3、优化了代码。消除了不必要的黄色警告线，使代码看起来更简洁

通过观察API发现，泛型可以出现在类，接口，方法上面，我们看到的类似于<E>这样的都叫泛型，一般来说，泛型出现大多使用的集合中。

public class GenericDemo {
    public static void main(String[] args) {
        //创建一个List集合对象
        //在JDK1.7之后，泛型会进行自动类型推断
        ArrayList<String> list = new ArrayList<>();

        //向集合中添加元素
        list.add("hello");
        list.add("hello");
        list.add("hello");
        list.add("hello");
        list.add("hello");
//        list.add(20);
//        list.add(12.34);
//        list.add(new Student());

        //遍历
//        Iterator iterator = list.iterator();
//        while (iterator.hasNext()) {
//            Object next = iterator.next();
//
//            String s = (String) next; //ClassCastException
//
//            System.out.println(next);
//        }

        //遍历
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()){
            String next = iterator.next();
            System.out.println(next);
        }

    }
}

泛型通配符<?>
    任意类型，如果没有明确，那么就是Object以及任意的Java类了
? extends E
    向下限定，E及其子类
? super E
    向上限定，E及其父类

public class GenericDemo1 {
    public static void main(String[] args) {
        ArrayList<Animal> list1 = new ArrayList<Animal>();
        ArrayList<Dog> list2 = new ArrayList<Dog>();
        ArrayList<Object> list3 = new ArrayList<Object>();

        //泛型通配符<?>
        //任意类型，如果没有明确，那么就是Object以及任意的Java类了
        ArrayList<?> list4 = new ArrayList<Animal>();
        ArrayList<?> list5 = new ArrayList<Dog>();
        ArrayList<?> list6 = new ArrayList<Object>();

        //? extends E  向下限定，E及其子类
        ArrayList<? extends Animal> list7 = new ArrayList<Animal>();
        ArrayList<? extends Animal> list8 = new ArrayList<Dog>();
        ArrayList<? extends Animal> list9 = new ArrayList<Cat>();
// object为animal的父类  ArrayList<? extends Animal> lis10 = new ArrayList<Object>();

        //? super E  向上限定，E及其父类
        ArrayList<? super Animal> list11 = new ArrayList<Animal>();
        ArrayList<? super Animal> list13 = new ArrayList<Object>();
//        ArrayList<? super Animal> list12 = new ArrayList<Dog>();



    }
}

泛型类
    把泛型定义在类上
    格式:public class 类名<泛型类型1,…>
    注意:泛型类型必须是引用类型
这里的<>里面的内容仅仅表示的使一种参数数据类型，参数类型是一种变量
既然是一种变量，就要符合变量的命名规则，可以使任意符合标识符起名字规则的名字。

一般情况下，在定义的时候，习惯用一个大写字母表示。

public class GenericTool1<T> {
    private T obj;

    public T getObj(){
        return obj;
    }

    public void setObj(T obj){
        this.obj = obj;
    }

}

泛型方法
    把泛型定义在方法上
    格式:public <泛型类型> 返回类型 方法名(泛型类型 .)

public class GenericTool2 {
//    public void show(String s){
//        System.out.println(s);
//    }
//
//    public void show(int i){
//        System.out.println(i);
//    }
//
//    public void show(double d){
//        System.out.println(d);
//    }

    //用泛型方法改进，将来不确定要传入什么类型的数据
    public <F> void show(F f){
        System.out.println(f);
    }

}
/*
        泛型类的测试
 */
public class GenericTest1 {
    public static void main(String[] args) {
        //如果不加泛型，默认使Object类型(创建对象调用方法)
//        GenericTool1 gt1 = new GenericTool1();
//        gt1.setObj("hello");
//        gt1.setObj(20);
//        gt1.setObj(12.34);

        GenericTool1<String> gt2 = new GenericTool1<>();
        gt2.setObj("hello");
//        gt2.setObj(20);

        String obj = gt2.getObj();


    }
}
用泛型改后的代码测试
public class GenericTest2 {
    public static void main(String[] args) {
        GenericTool2 genericTool2 = new GenericTool2();
        genericTool2.show("hello");
        genericTool2.show(10);
        genericTool2.show(12.34);

    }
}