Gorilla带您学java之泛型

泛型

泛型我理解来说就是数据类型形参了。
写法: <数据类型(泛型)>
泛型好处:
1.保证数据的安全性(提示你方法中传入的参数类型)
2.避免进行向下转型(类型强转)
3.将运行时的错误 转化到编译时报错

        // E就是泛型 Element
        // 注意: 前后泛型的类型要一致(如果填的话)
        // jdk 1.7出的菱形泛型 后面泛型可以不填 默认跟前面泛型类型一致
        // 创建一个集合保存a b c d
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("a");
        arrayList.add("b");
        arrayList.add("c");
        arrayList.add("d");

        // 迭代器遍历
        // 迭代器泛型表示 集合中保存元素的类型
        Iterator<String> iterator = arrayList.iterator();
        while (iterator.hasNext()) {
            String string = (String) iterator.next();
            System.out.println(string);
        }


        // 创建集合 保存三个学生(此处需要创建学生类 有姓名和年龄两个私有化成员变量 并有无参有参构造和get/set方法)
        ArrayList<Student> list = new ArrayList<>();
        list.add(new Student("hanhan", 12));
        list.add(new Student("hanhan2", 121));
        list.add(new Student("hanhan3", 122));
        Student student = list.get(0);
        System.out.println(student.getName());
        // 好处3
        //Worker worker = (Worker)list.get(0);
        /*
         *  数组转集合
         *  是把int数组当做一个元素放入集合中
         *  系统没有进行自动装箱
         */
        int[] array1 = {1, 2, 3, 4, 5};
        //List asList = Arrays.asList(array1);
        List<int[]> asList = Arrays.asList(array1);
        System.out.println(asList);

        // 把数组中的元素放入集合中
        Integer[] array2 = {1, 2, 3, 4, 5};
        List<Integer> list2 = Arrays.asList(array2);
        System.out.println(list2);


        //  创建一个字符串数组 保存三个名字
        //  将数组 转成集合 
        //  添加一个名字
        String[] array3 = {"han1", "han2", "han3"};
        List<String> asList2 = Arrays.asList(array3);
        /*
         *  UnsupportedOperationException 不支持操作异常
         *  注意:该方法 转完集合后 不能对集合进行长度修改
         */
        // asList2.add("han");
        // 该方法意义在于 可以使用集合类中的方法
        boolean contains = asList2.contains("han2");
        System.out.println(contains);

//控制台打印
a
b
c
d
hanhan
[[I@33909752]
[1, 2, 3, 4, 5]
true

泛型类

泛型声明的位置: 类名<泛型>
泛型使用占位符(英文字符) 一般使用大写字母

什么时候指定泛型的真正类型: 创建对象时会给泛型确定类型

public class Worker<E> {
    // 利用泛型声明成员变量
    private E e;
    // 声明set/get方法
    public E getE() {
        return e;
    }
    public void setE(E e) {
        this.e = e;
    }
    // 成员方法

    public void fun(E e) {
        System.out.println(e);
        System.out.println("fun function");
    }

    // 一个类中可不可以有多个泛型  可以
    // 需要在方法上进行泛型的声明 这个泛型将会在该方法被调用的时候被赋值
    public<A> void fun1(A a) {
        System.out.println(a);
    }

    // 静态方法能不能使用E泛型？ 不能
    // 当方法被调用的时候 泛型被赋值
    public static<Q> void fun2(Q q) {
        System.out.println(q);
    }
}

泛型接口

// 定义一个泛型接口
interface InterA<G>{
    void fun(G g);
}
// 在接口的实现类上确定泛型类型
class InterAImpl implements InterA<String>{
    @Override
    public void fun(String g) { 
    }
}