泛型的几种用法与集合安全问题

泛型

• Java泛型是JDK1.5中引入的新特性，其本质就是参数化类型，把类型作为参数进行传递。
• 常见形式有泛型、泛型接口，泛型方法。
• 语法** <T…>** T成为占位符，表示一种引用类型
• 好处
  1. 提高代码的重用性
  2. 防止类型转换异常，提高代码的安全性

泛型类

• 泛型类：

  • 语法：类名 <T>
    T是类型占位符，表示一种引用类型，如果编写多个使用逗号隔开
  1. 泛型只能是引用类型
  2. 不同泛型类型对象之间不能相互复制

package com.list.demo.generic;

public class GenericClass<T> {
    /*
    * 泛型类：
    * 语法：类名<T>
      T是类型占位符，表示一种引用类型，如果编写多个使用逗号隔开
    * */
//    1.使用泛型T
//    1.创建变量
    T t;

    //    2.泛型作为方法的参数
    public void setT(T t) {
        this.t = t;
    }

//    3.泛型作为方法的返回值
    public T getT(){
        return t;
    }
}

package com.list.demo;

import com.list.demo.generic.GenericClass;

public class Demo4 {
    public static void main(String[] args) {
//        注意：1.泛型只能是引用类型 2.不同泛型类型对象之间不能相互复制
        GenericClass<String> stringGenericClass = new GenericClass<>();
        stringGenericClass.setT("泛型");
        System.out.println(stringGenericClass.getT());

        GenericClass<Integer> integerGenericClass = new GenericClass<>();
        integerGenericClass.setT(100);
        System.out.println(integerGenericClass.getT());
    }
}

泛型接口

• 泛型接口：

  • 语法：接口名<T>

    注意：不能创建泛型静态变量

package com.list.demo.generic;

/*
* 泛型接口：
* 语法：接口名<T>
  注意：不能创建泛型静态变量
* */
public interface GenericInterface<T> {
    //    static T t;  // 会报错，因为静态变量是先加载的，无法预知类型
    T server(T t);
}

package com.list.demo;

import com.list.demo.generic.GenericInterface;

public class Demo6Impl<T> implements GenericInterface<T> {
    @Override
    public T server(T t) {
        return t;
    }
}

package com.list.demo;

import com.list.demo.generic.GenericInterface;

public class Demo5Impl implements GenericInterface<String>{
    @Override
    public String server(String s) {
        return s;
    }
    public static void main(String[] args) {
        Demo5Impl demo5 = new Demo5Impl();
        System.out.println(demo5.server("你好"));


        Demo6Impl<Integer> integerDemo6 = new Demo6Impl<>();
        System.out.println(integerDemo6.server(100));
    }
}

泛型方法

• 泛型方法：
  • 语法 <T> 返回值类型

package com.list.demo;

public class Demo7 {

    public static void main(String[] args) {

        Demo7 demo7 = new Demo7();
        demo7.show("你好");  // 泛型方法不需要我们传参数类型，它会根据我们传的参数自动匹配
        demo7.show(100);
        demo7.show(3.14);

        get(1);
        get("！！！");
        get(3.1415926535);

    }

    public static <T> T get(T t) {
        System.out.println(t);
        return t;
    }

    public <T> T show(T t) {
        System.out.println(t);
        return t;
    }
}

泛型集合

• 概念：参数化类型，类型安全的集合，强制集合元素的类型一致。

• 特点：

  • 编译时即可检查，而非运行时抛出异常
  • 访问时，不必进行类型转换（拆箱）
  • 不同泛型之间引用不能相互赋值，泛型不存在多态。

• 我们之前Demo写的集合没有用泛型强制类型，这样的集合是不安全的

package com.list.demo;

import java.util.ArrayList;

public class Demo8 {
    public static void main(String[] args) {

        ArrayList arrayList = new ArrayList<>();

        arrayList.add(10);
        arrayList.add(3.14);
        arrayList.add("10");

        for (int i = 0; i <arrayList.size() ; i++) {
//            ClassCastException  这种集合是不安全的
            String s = (String) arrayList.get(i);
            System.out.println();
        }
    }
}

• 为了使得我们的集合更加安全，程序更加健壮，我们要将泛型加上

package com.list.demo;

import java.util.ArrayList;

public class Demo9 {
    public static void main(String[] args) {

        ArrayList<Integer> integers = new ArrayList<>();
        integers.add(100);
//        integers.add(3.14); // 报错
//        integers.add("100");  // 报错
        integers.add(50);
        integers.add(80);

        for (int i = 0; i < integers.size(); i++) {
            Integer integer = integers.get(i);
            System.out.println(integer);
        }

    }
}