二、JavaSE_集合(泛型)

泛型

一、泛型的概述

1.初步了解

首先，我们来看什么是泛型？

List list = new ArrayList();                        //没有泛型约束
List<String> list = new ArrayList<String>();//有泛型约束                                    

第一行代码，没有进行泛型约束，也就是list可以存储的类型是Object。那么这样会存在安全隐患，接下来，我们会谈谈安全隐患的问题。

第二行代码，就是有泛型进行约束的，也就是说第二个list当中只能存放String类型的数据。注：jdk1.7以后，也可以这样定义：List<String> list = new ArrayList<>()；也就是后面的类型可以不写。

我们来看Collection的API

E代表的是元素（Element）

其中那个E就代表泛型。

2.泛型的好处

•  提高了安全性（将运行期的错误转换到编译期）
• 省去强转的麻烦

3.泛型解决安全隐患

安全隐患的问题，通过代码来看：

/**
 * 早期的Object类型可以接收任意的对象类型，
 * 但是在实际的使用中，会有类型转换的问题。也就存在这隐患，所以Java提供了泛型来解决这个安全问题。
 */
public class Demo {
    public static void main(String[] args){
        //创建工具类对象
        Tool tool = new Tool();
        //往工具类设置狗类
        tool.setObject(new Dog("金毛","金黄色"));
        //获取猫对象
        Cat cat = (Cat) tool.getObject();
    }
}


//工具类
class Tool {
    private Object object;

    public Object getObject() {
        return object;
    }

    public void setObject(Object object) {
        this.object = object;
    }
}

//动物类
class Animal {
    private String name;
    private String color;

    public Animal() {
    }

    public Animal(String name, String color) {
        this.name = name;
        this.color = color;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    @Override
    public String toString() {
        return "Animal{" +
                "name='" + name + '\'' +
                ", color='" + color + '\'' +
                '}';
    }
}

//狗类
class Dog extends Animal {

    public Dog() {
    }

    public Dog(String name, String color) {
        super(name, color);
    }
}

//猫类
class Cat extends  Animal {
    public Cat() {
    }

    public Cat(String name, String color) {
        super(name, color);
    }
}

我们来看这段代码，工具类Tool，他是可以设置任意对象的，即Object，那么Cat和Dog都是继承Animal类，当往工具类设置Dog类时，Tool是可以接收的，获取时也可以强转成Cat类时编译也是可以的，但是运行时：

java.lang.ClassCastException类型转换异常，因此在这里如果没使用泛型就会导致在运行时存在类型转换异常，因此会出现安全隐患。

那么，加了泛型之后呢？请看代码：（将Tool加上泛型）

//工具类
class Tool<T> {
    private T object;

    public T getObject() {
        return object;
    }

    public void setObject(T object) {
        this.object = object;
    }
}

加上泛型之后，等于约束了Tool能存放的类型，一旦存放的不是该类型，那么就直接在编译期间就提示错误，这也就是为什么泛型将运行期的错误转移到编译期了。

 

 二、泛型方法的使用
1.成员方法的泛型

 泛型方法（扑通）也就是把泛型定义在方法上，定义格式：

public <泛型类型> 返回类型 方法名（泛型类型 变量名）

    public<T> void move(T t) {      //方法类型最好与类方形一致
        System.out.println(t);      //如果不一致，那么要在方法上声明类型
    }

 完整版：

public class Demo {
    public static void main(String[] args){
        //创建工具类对象
        Tool<Dog> tool = new Tool<>();
        tool.move(new Dog("泰迪","屎黄色"));
        tool.move(new Cat("旺财","黄色"));
    }
}


//工具类
class Tool<T> {
    private T object;

    public T getObject() {
        return object;
    }

    public void setObject(T object) {
        this.object = object;
    }

    //成员方法
    public<T> void move(T t) {      //方法类型最好与类方形一致
        System.out.println(t);      //如果不一致，那么要在方法上声明类型
    }

}

//动物类
class Animal {
    private String name;
    private String color;

    public Animal() {
    }

    public Animal(String name, String color) {
        this.name = name;
        this.color = color;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    @Override
    public String toString() {
        return "Animal{" +
                "name='" + name + '\'' +
                ", color='" + color + '\'' +
                '}';
    }
}

//狗类
class Dog extends Animal {

    public Dog() {
    }

    public Dog(String name, String color) {
        super(name, color);
    }
}

//猫类
class Cat extends  Animal {
    public Cat() {
    }

    public Cat(String name, String color) {
        super(name, color);
    }
}

结果：

2.静态方法的泛型

 定义格式：public static <泛型类型> 返回类型 方法名（泛型类型 变量名）

 

//静态成员方法泛型
public static<Q> void show(Q q){  //静态方法必须声明自己的泛型
        System.out.println(q);
}

 

为什么要声明自己的泛型，这是因为调用move方法是在创建对象以后调用，而静态方法是类加载就可以调用，他们的生命周期不一样。

看代码：

public class Demo {
    public static void main(String[] args){
        //创建工具类对象
        Tool<Dog> tool = new Tool<>();
        tool.move(new Dog("泰迪","屎黄色"));
        Tool.show(new Cat("旺财","黄色"));
    }
}


//工具类
class Tool<T> {
    private T object;

    public T getObject() {
        return object;
    }

    public void setObject(T object) {
        this.object = object;
    }

    //成员方法
    public<T> void move(T t) {      //方法类型最好与类方形一致
        System.out.println(t);      //如果不一致，那么要在方法上声明类型
    }

    //静态成员方法泛型
    public static<Q> void show(Q q){  //静态方法必须声明自己的泛型
        System.out.println(q);
    }

}

//动物类
class Animal {
    private String name;
    private String color;

    public Animal() {
    }

    public Animal(String name, String color) {
        this.name = name;
        this.color = color;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    @Override
    public String toString() {
        return "Animal{" +
                "name='" + name + '\'' +
                ", color='" + color + '\'' +
                '}';
    }
}

//狗类
class Dog extends Animal {

    public Dog() {
    }

    public Dog(String name, String color) {
        super(name, color);
    }
}

//猫类
class Cat extends  Animal {
    public Cat() {
    }

    public Cat(String name, String color) {
        super(name, color);
    }
}

注意这个：

 

结果：

 

 当通过类名.方法名时，那么还没有创建对象，不会让你去约束泛型，因此必须在静态方法上加上自己的泛型。

 

三、泛型接口的概述和使用

 1.概述

泛型接口，也就是在接口上定义泛型。

2.定义格式：

public interface 接口名<泛型类型>

如：

//接口泛型
interface Inter<String>{
    void method(String str);
}

 Code:

public class Test_Generic {
    public static void main(String[] args){
        Inter inter = new ImplInter();
        inter.method("唐豆豆，你个迷人的小妖精");
    }
}
//接口泛型
interface Inter<String>{
    void method(String str);
}
//实现接口重写方法
class ImplInter implements Inter<String>{

    @Override
    public void method(String str) {
        System.out.println(str);
    }
}

结果：

 

泛型后面还有一点会再说，将集合复习完毕之时，再补充一点关于泛型的通配符，仅作了解。

 

如有错误之处，欢迎指正。

邮箱：it_chang@126.com