集合框架——泛型介绍

最新推荐文章于 2024-05-20 11:32:04 发布

小菜鸟的编程路

最新推荐文章于 2024-05-20 11:32:04 发布

阅读量267

点赞数

分类专栏： java集合框架文章标签： java

本文链接：https://blog.csdn.net/qq_27007781/article/details/108356675

版权

java集合框架专栏收录该内容

2 篇文章 0 订阅

订阅专栏

泛型的由来

因为我们将数据添加进集合中时，add(object obj)会将添加进的数据会自动向上转型为object类型，而之后我们又需向下转型为我们取出时的类型，再取出数据，如果一旦强转错误，将存进去的Integer类型转换为String类型，就会出现类型转换异常，有没有办法在我们存入数据的时候就让集合记住我们存储的类型呢？这才有了我们存储时就明确我们存储时的类型，一旦加入泛型，编译器在编译时就会检查我们存入集合的数据是否符合我们规定的泛型，取出时也不用强制转换了，跟数组一样，int[] arr=new int[],数组在声明时就已经明确了存储的类型为Int类型，一旦存储类型数据有误，则编译器检查报错(当使用add或put方法存储对象时，对象会自动向上转型，但是记住堆内存存储的对象本质还是我们存进去的类型，所以我们强转时有可能发生错误，多想想多态中的向下转型，不能把堆内存中本质的猫转化成狗)

泛型的概念

泛型是一种未知的数据类型，当我们不知道使用什么数据类型的时候，就可以使用泛型，泛型也可以看做是一个变量，用来接收数据类型，我们通常在API中会看见英文E e和T t，两者都表示泛型，前者表示的是Element元素（在集合中使用，因为集合中存放的是元素），后者表示的是Type类型（java类）

使用泛型和不使用泛型的对比

创建集合对象,不使用泛型

好处:

集合不使用泛型,默认的类型就是Object类型,可以存储任意类型的数据

弊端:

不安全,在向下转型时容易引发类型转换异常

创建集合对象,使用泛型

好处:

将运行时期的classCastException的问题提前到了编译时期（写代码的时候有语法错误就会报错），泛型技术是给编译器用的，确保了类型安全
避免了类型转换的麻烦，不用再向下转型了，存入的是什么类型，取出的就是什么类型

弊端：

泛型是什么类型,只能存储什么类型的数据

泛型里面声明的都是引用数据类型，因为容器只存储对象，所以泛型不能是基本数据类型，如果想声明基本数据类型可以声明包装类，泛型两边声明的泛型类型必须一致，不能一边是Object,一边是String，从java1.7版本开始，如果声明左边，右边不写也可以，不过最好还是写上，反正不差那几个英文字母

定义和使用含有泛型的类

定义一个含有泛型的类,模拟ArrayList集合

泛型是一个未知的数据类型,当我们不确定使用什么数据类型的时候,可以使用泛型

泛型可以接收任意的数据类型,可以使用Integer,String,Student...

创建对象的时候确定泛型的数据类型

泛型类定义代码如下：

public class GenericClass<E> {
    private E name;

    public E getName() {
        return name;
    }

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

泛型类使用代码如下：

public class Demo02GenericClass {
    public static void main(String[] args) {
        //不写泛型默认为Object类型
        GenericClass gc = new GenericClass();
        gc.setName("随意");
        Object obj = gc.getName(); //获取到的类型是Object类型

        //创建GenericClass对象,泛型使用Integer类型
        GenericClass<Integer> gc2 = new GenericClass<>();
        gc2.setName(1);

        Integer name = gc2.getName();
        System.out.println(name);

        //创建GenericClass对象,泛型使用String类型
        GenericClass<String> gc3 = new GenericClass<>();
        gc3.setName("小明");
        String name1 = gc3.getName();
        System.out.println(name1);
    }
}

定义和使用含有泛型的方法

定义含有泛型的方法:泛型定义在方法的修饰符和返回值类型之间

格式:

         修饰符 <泛型> 返回值类型方法名(参数列表(使用泛型)){

                  方法体;

         }

含有泛型的方法,在调用方法的时候确定泛型的数据类型

传递什么类型的参数,泛型就是什么类型，注意泛型使用什么英文都可以，不一定要E或者是T，泛型的重点是<>尖括号

泛型方法定义如下：

public class GenericMethod {
    //定义一个含有泛型的方法
    public <M> void method01(M m){
        System.out.println(m);
    }

    //定义一个含有泛型的静态方法
    public static <S> void method02(S s){
        System.out.println(s);
    }
}

泛型方法调用如下：

public class Demo03GenericMethod {
    public static void main(String[] args) {
        //创建GenericMethod对象
        GenericMethod gm = new GenericMethod();

        /*
            调用含有泛型的方法method01
            传递什么类型,泛型就是什么类型
         */
        gm.method01(10);
        gm.method01("abc");
        gm.method01(8.8);
        gm.method01(true);

        gm.method02("静态方法,不建议创建对象使用");

        //静态方法,通过类名.方法名(参数)可以直接使用
        GenericMethod.method02("静态方法");
        GenericMethod.method02(1);
    }
}

定义和使用含有泛型的接口

定义泛型接口

public interface GenericInterface<I> {

    public abstract void method(I i);

}

使用泛型接口的第一种方式

含有泛型的接口,第一种使用方式:定义接口的实现类，实现接口，指定接口泛型的具体类型

JDK例子：

public interface Iterator<E> {

E next();

}

Scanner类实现了Iterator接口,并指定接口的泛型为String,所以重写的next方法泛型默认就是String

public final class Scanner implements Iterator<String>{

public String next() {}

}

实现GenericInterface泛型接口代码如下：

public class GenericInterfaceImpl1 implements GenericInterface<String>{
    @Override
    public void method(String s) {
        System.out.println(s);
    }
}

使用泛型接口的第二种方式

含有泛型的接口第二种使用方式:接口使用什么泛型,实现类就使用什么泛型,类跟着接口走

就相当于定义了一个含有泛型的类,创建对象的时候确定泛型的类型

JDK例子：List定义泛型，子实现类ArrayList也用什么泛型，没有明确，只有我们在创建ArrayList对象时才确定类型

public interface List<E>{

         boolean add(E e);

         E get(int index);

}

public class ArrayList<E> implements List<E>{

         public boolean add(E e) {}

         public E get(int index) {}

}

实现GenericInterface泛型接口代码：

public class GenericInterfaceImpl2<I> implements GenericInterface<I> {
    @Override
    public void method(I i) {
        System.out.println(i);
    }
}

测试含有泛型的接口

public class Demo04GenericInterface {
    public static void main(String[] args) {
        //创建GenericInterfaceImpl1对象，因为在GenericInterfaceImpl1实现类中已经明确了泛型类型为
//String，所以实例化时候不需要泛型确认
        GenericInterfaceImpl1 gi1 = new GenericInterfaceImpl1();
        gi1.method("字符串");

        //创建GenericInterfaceImpl2对象，因为在GenericInterfaceImpl2实现类中没有明确泛型类型，只
//有等到创建GenericInterfaceImpl2对象时才确定泛型的数据类型是哪个
        GenericInterfaceImpl2<Integer> gi2 = new GenericInterfaceImpl2<>();
        gi2.method(10);

        GenericInterfaceImpl2<Double> gi3 = new GenericInterfaceImpl2<>();
        gi3.method(8.8);
    }
}

泛型接口使用方式总结

泛型接口的使用方式无非两种：
第一种是实现类确定泛型接口定义的泛型类型，实例化时无需再确定泛型类型
第二种是实现类沿用接口泛型，不确定泛型类型，只有等到实例化实现类创建实现类对象时才明确类型

泛型通配符

通配符的简单使用

泛型的通配符:

      ?:代表任意的数据类型

使用方式:

         不能创建对象使用，例如ArrayList<?> list03 = new ArrayList<?>()，这种写法错误

         只能作为方法的形式参数使用

这里要注意，泛型是没有继承特性的，所以不能使用Object来代替?泛型通配符来达到什么数据类型都能传进去的效果

定义一个方法,能遍历所有类型的ArrayList集合

这时候我们不知道ArrayList集合使用什么数据类型,可以泛型的通配符?来接收数据类型

/*
    泛型的通配符:
        ?:代表任意的数据类型
    使用方式:
        不能创建对象使用
        只能作为方法的参数使用
 */
public class Demo05Generic {
    public static void main(String[] args) {
        ArrayList<Integer> list01 = new ArrayList<>();
        list01.add(1);
        list01.add(2);

        ArrayList<String> list02 = new ArrayList<>();
        list02.add("a");
        list02.add("b");

        printArray(list01);
        printArray(list02);

        //ArrayList<?> list03 = new ArrayList<?>();  这种写法错误
    }

    /*
        定义一个方法,能遍历所有类型的ArrayList集合
        这时候我们不知道ArrayList集合使用什么数据类型,可以泛型的通配符?来接收数据类型
        注意:
            泛型没有继承概念的，无法用Object对象来替代?泛型通配符
     */
    public static void printArray(ArrayList<?> list){
        //使用迭代器遍历集合
        Iterator<?> it = list.iterator();
        while(it.hasNext()){
            //it.next()方法,取出的元素是Object,可以接收任意的数据类型
            Object o = it.next();
            System.out.println(o);
        }
    }
}

通配符的高级使用

泛型的上限限定: ? extends E 代表使用的泛型只能是E类型的子类/本身（简单点就是最顶层是E类型的意思）

泛型的下限限定: ? super E 代表使用的泛型只能是E类型的父类/本身（简单点就是最底层是E类型的意思）

代码例子如下：

public class Demo06Generic {
    public static void main(String[] args) {
        Collection<Integer> list1 = new ArrayList<Integer>();
        Collection<String> list2 = new ArrayList<String>();
        Collection<Number> list3 = new ArrayList<Number>();
        Collection<Object> list4 = new ArrayList<Object>();

        getElement1(list1);
        //getElement1(list2);//报错 String不是Number的子类或本身
        getElement1(list3);
        //getElement1(list4);//报错 Object不是Number的子类或本身

        //getElement2(list1);//报错 Integer不是Number类型的父类或本身
        //getElement2(list2);//报错 String不是Number类型的父类或本身
        getElement2(list3);
        getElement2(list4);

        /*
            类与类之间的继承关系
            Integer extends Number extends Object
            String extends Object
         */
    }
    // 泛型的上限：此时的泛型?，必须是Number类型或者Number类型的子类
    public static void getElement1(Collection<? extends Number> coll){}
    // 泛型的下限：此时的泛型?，必须是Number类型或者Number类型的父类
    public static void getElement2(Collection<? super Number> coll){}
}

小菜鸟的编程路

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
集合框架——泛型介绍

目录泛型的由来泛型的概念使用泛型和不使用泛型的对比创建集合对象,不使用泛型创建集合对象,使用泛型定义和使用含有泛型的类定义和使用含有泛型的方法定义和使用含有泛型的接口定义泛型接口使用泛型接口的第一种方式使用泛型接口的第二种方式测试含有泛型的接口泛型接口使用方式总结泛型通配符通配符的简单使用通配符的高级使用泛型的由来因为我们将数据添加进集合中时，add(object obj)会将添加进的数据会自动向上转型为object类型，而之后我.
复制链接

扫一扫