Java集合之泛型类和泛型接口

最新推荐文章于 2021-11-30 21:47:43 发布
最新推荐文章于 2021-11-30 21:47:43 发布
阅读量373 收藏
点赞数
分类专栏： Java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sun10367/article/details/107441438
版权

目录

1. 为什么要有泛型

1.1 不使用泛型的问题

当不使用泛型时，集合中是可以存放任意类型对象的，只要把对象存储集合后，那么他们都会被提升为Object类型。当我们在取出每一个对象，并且进行相应的操作，需要进行类型转换。

观察下面代码：

public static void main(String[] args) {
    Collection coll = new ArrayList();
    coll.add("abc");
    coll.add("def");
    coll.add(5);//由于集合没有做任何限定，任何类型都可以存放
    Iterator it = coll.iterator();
    while(it.hasNext()){
        //需要打印每个字符串的长度,就要把迭代出来的对象转成String类型
        String str = (String) it.next();
        System.out.println(str.length());
    }
}

程序在运行时发生了问题 java.lang.ClassCastException。为什么会发生类型转换异常呢？
由于集合没有使用泛型，什么类型的元素都可以存储，导致取出时强转引发运行时 ClassCastException。怎么来解决这个问题呢？
Collection虽然可以存储各种类型对象，但一般只存储同一类型对象，例如都是字符串对象。因此在JDK5之后，新增了泛型(Generic)语法，让你在设计API时可以指定类或方法支持泛型，这样我们使用API的时候也变得更为简洁，并得到了编译时期的语法检查。

1.2 泛型概念

泛型：参数化类型，也就是说要操作的数据一开始不确定是什么类型，在使用的时候，才能确定是什么类型，把要操作的数据类型指定为一个参数，在使用时传入具体的类型，实现代码的模板化。

//比如ArrayList集合(含有泛型)，部分源代码如下(可以理解为模板)
public class ArrayList<E> {
    public E get(int index) {...}
    public E set(int index, E element) {...}
    public boolean add(E e) {...}
    public E remove(int index) {...}
}

//创建ArrayList集合对象指定类型为String时
List<String> list1 = new ArrayList<>();
//模板代码相当于变成如下形式
public class ArrayList<String> {
    public String get(int index) {...}
    public String set(int index, String element) {...}
    public boolean add(String e) {...}
    public String remove(int index) {...}
}
//所以使用list1集合对象，调用以上四个方法时，所有E的位置都变为了String


//创建ArrayList集合对象指定类型为Integer时
List<Integer> list2 = new ArrayList<>();
//模板代码相当于变成如下形式
public class ArrayList<Person> {
    public Integer get(int index) {...}
    public Integer set(int index, Integer element) {...}
    public boolean add(Integer e) {...}
    public Integer remove(int index) {...}
}
//所以使用list2集合对象，调用以上四个方法时，所有E的位置都变为了Integer

jdk1.7之后，泛型的简化操作：ArrayList flist = new ArrayList<>(); 可省略右侧中的数据类型。

1.3 使用泛型的好处

  • 将运行时期的ClassCastException，提前到编译时期变成了编译失败

  • 避免了类型强转的麻烦。

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class GenericDemo {
    public static void main(String[] args) {
        show02();
    }

    /**
     * 创建集合对象，使用泛型
     * 好处:
     *     1.想使用元素特有的方法，避免了类型转换的麻烦
     *     2.把运行时异常，提升到编译时期
     * 弊端:
     *     一旦确定数据类型，就只能存储该类型数据
     */
    private static void show02() {
        Collection<String> list = new ArrayList<>();
        list.add("abc");
        list.add("def");
        // list.add(5);//当集合明确类型后，存放类型不一致就会编译报错
        // 集合已经明确具体存放的元素类型，那么在使用迭代器的时候，迭代器也同样会知道具体遍历元素类型
        Iterator<String> it = list.iterator();
        while(it.hasNext()){
            String str = it.next();
            //当使用Iterator<String>控制元素类型后，就不需要强转了。获取到的元素直接就是String类型
            System.out.println(str.length());
        }
    }

    /**
     * 创建集合对象，不使用泛型
     * 好处:
     *     集合的类型默认为Object类型，可以存储任意的对象
     * 弊端:
     *     不安全，
     *     不能使用元素特有的方法
     */
    private static void show01() {
        ArrayList list = new ArrayList();
        list.add("abc");
        list.add(1);
        //使用迭代器遍历集合
        Iterator it = list.iterator();
        while(it.hasNext()){
            //取出集合中元素，Object类型
            Object obj = it.next();
            System.out.println(obj);

            /*
               想使用字符串特有的方法length
               不能使用，需要向下转型
               Object obj = "abc";多态
             */
            String s = (String)obj;
            System.out.println(s.length());
        }

    }
}

2. 泛型类

2.1 定义格式：

//其中类型参数，一般用一个大写字母表示，比如: T,E,K,V
//如果要定义多个泛型，多个类型参数之间用逗号,隔开，例如：public class HashMap<K,V> {...}
权限修饰符 class 类名<类型形参> {  }

例如，API中的ArrayList集合：

泛型在定义的时候不具体，使用的时候才变得具体。在使用的时候确定泛型的具体数据类型。

public class ArrayList<E>{ 
    public boolean add(E e){ }

    public E get(int index){ }
   	....
}

2.2 使用泛型： 即什么时候确定泛型。

在创建对象的时候指定类型

例如，ArrayList<String> list = new ArrayList<>();

此时，变量E的值就是String类型，那么我们的类型就可以理解为：

class ArrayList<String>{ 
     public boolean add(String e){ }

     public String get(int index){  }
     ...
}

再例如，ArrayList<Integer> list = new ArrayList<>();

此时，变量E的值就是Integer类型，那么我们的类型就可以理解为：

class ArrayList<Integer> { 
     public boolean add(Integer e) { }

     public Integer get(int index) {  }
     ...
}

在类、接口上声明的泛型，在本类、本接口中即代表某种数据类型，可以作为非静态成员变量的类型、非静态方法的形参类型、非静态方法的返回值类型、局部变量的类型等，但不能用于静态成员上。

自定义泛型类：

public class MyGenericClass<T> {
    // 没有T类型，在这里代表 未知的一种数据类型 未来传递什么就是什么类型
    private T t; // 用于成员变量的数据类型

    public MyGenericClass() {
    }

    public MyGenericClass(T t) { // 用于方法的形参的数据类型
        this.t = t;
    }

    public T getT() { // 用于方法的返回值的数据类型
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }
    
    public void test() { // 用于局部变量的数据类型
        T t;
    }
}

使用:

public class GenericClassDemo {
    public static void main(String[] args) {
        // 创建一个泛型为String的类
        MyGenericClass<String> gc1 = new MyGenericClass<>();
        // 调用setT
        gc1.setT("abc");
        // 调用getT
        String str = gc1.getT();
        System.out.println(str);
        //创建一个泛型为Integer的类
        MyGenericClass<Integer> gc2 = new MyGenericClass<>();
        gc2.setT(123);
        Integer num = gc2.getT();
        System.out.println(num);
    }
}

注意：

类型实参必须是一个类类型，不能用基本数据类型填充，但可以使用包装类。

继承中的使用：

父类：

public class MyGenericFuClass<T> {
    public void print(T t) {
        System.out.println(t);
    }
}
  • 定义子类继承泛型父类的同时指定泛型的类型
public class MyGenericZiClassA extends MyGenericFuClass<Integer> {
    @Override
    public void print(Integer num) {
        System.out.println(num);
    }
}

public static void main(String[] args) {
    // MyGenericZiClassA类已经没有泛型了
    MyGenericZiClassA gzA = new MyGenericZiClassA();
    gzA.print(100);
}
  • 定义子类继承泛型父类，若不指定的父类泛型类型，子类也必须声明为泛型类，创建对象时指定泛型的类型
public class MyGenericZiClassB<T> extends MyGenericFuClass<T> {
    @Override
    public void print(T t) {
        System.out.println(t);
    }
}

public static void main(String[] args) {
    //创建对象指定泛型类型为String
    MyGenericZiClassB<String> gzB = new MyGenericZiClassB<>();
    gzB.print("abc");
    //gzB.print(100);//错误，只能传递String类型的参数
    
    //创建对象指定泛型类型为Integer
    MyGenericZiClassB<Integer> gzB2 = new MyGenericZiClassB<>();
    gzB2.print(100);
}

3. 泛型接口

3.1 定义格式：

权限修饰符 interface 接口名<类型形参> {...}

例如，

public interface MyGenericInterface<T> {
    //抽象方法
    public abstract void show(T t);
}

3.2 使用方式：

1、定义实现类的同时指定泛型接口上的的具体数据类型

public class MyGenericInterfaceImplA implements MyGenericInterface<String> {
    @Override
    public void show(String s) {
        System.out.println(s);
    }
}

public class MyGenericInterfaceDemo1 {
    public static void main(String[] args) {
        MyGenericInterfaceImplA mi = new MyGenericInterfaceImplA();
        // 已指定String类型，只能传字符串
        mi.show("abc");
    }
}

2、定义实现类时，若不指定接口上的泛型的具体数据类型，实现类也必须指定为泛型类，创建对象时，确定泛型的类型

public class MyGenericInterfaceImplB<T> implements MyGenericInterface<T> {
    @Override
    public void show(T t) {
        System.out.println(t);
    }
}

public class MyGenericInterfaceDemo2 {
    public static void main(String[] args) {
        //创建对象指定泛型类型为String
        MyGenericInterfaceImplB<String> mi = new MyGenericInterfaceImplB<>();
        mi.show("abc");

        //创建对象指定泛型类型为Integer
        MyGenericInterfaceImplB<Integer> mi2 = new MyGenericInterfaceImplB<>();
        mi2.show(100);
    }
}

4. 泛型类、泛型接口小结：

  • 语法格式：

    • 在创建泛型类、泛型接口的对象时，为泛型形参指定具体类型

    • 在继承泛型类或实现泛型接口时，为泛型形参指定具体类型

  • 异常类不能是泛型的

  • 不能使用new E[]。但是可以：E[] array = (E[])new Object[size]; E[] array = (E[])new Object[]{…};等

  • 父类有泛型，子类可以选择保留泛型也可以选择指定泛型类型：

    • 子类不保留父类的泛型：按需传参
      • 没有类型 擦除
      • 具体类型
    • 子类保留父类的泛型：泛型子类
      • 全部保留
      • 部分保留
    • 结论：子类除了指定或保留父类的泛型，还可以增加自己的泛型（可类推到接口继承、接口实现）
class Father<T1, T2> {
}
// 子类不保留父类的泛型
// 1)没有类型 擦除
class Son1 extends Father {// 等价于class Son extends Father<Object,Object>{
}
// 2)具体类型
class Son2 extends Father<Integer, String> {
}
// 子类保留父类的泛型
// 1)全部保留
class Son3<T1, T2> extends Father<T1, T2> {
}
// 2)部分保留
class Son4<T2> extends Father<Integer, T2> {
}

增加自己的泛型：

class Father<T1, T2> {
}
// 子类不保留父类的泛型
// 1)没有类型 擦除
class Son<A, B> extends Father{//等价于class Son extends Father<Object, Object>{
}
// 2)具体类型
class Son2<A, B> extends Father<Integer, String> {
}
// 子类保留父类的泛型
// 1)全部保留
class Son3<T1, T2, A, B> extends Father<T1, T2> {
}
// 2)部分保留
class Son4<T2, A, B> extends Father<Integer, T2> {
}
ixcoret
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java 集合与泛型
The Hot Java
04-04 967
Java集合框架与泛型 首先整体概览,下图是Java集合框架的类图 高清类图的PDF下载地址:http://download.csdn.net/detail/mydream20130314/8574911 简单点说,List保存对象列表,Set保存无重复对象列表,Map保存键值对映射. 下面逐个简要介绍 : ArrayDeque
【Java】泛型之泛型类、泛型方法及泛型接口
qq_43464809的博客
08-07 234
目录 泛型 1.JDK1.5新特性 1.1可变参数 1.2foreach循环 2.泛型 2.1泛型类的基本使用 2.2泛型方法： 2.3泛型接口： 泛型 1.JDK1.5新特性 1.1可变参数 使用要求： 一个方法有且只能有一个可变参数，并且放在方法的最后一个参数 语法： 类型声明 ... 参数名称 int ... data 1.2foreach循环 ...
java为什么采用泛型
qq_44231797的博客
11-16 289
泛型其实就是在集合创建是就设定集合中放置何种类型的对象。这样以后读出的元素时就不需要强制转换了。如果不是泛型，则无论向集合中添加何种对象都是当做对象Object，所以取出来也是Object，因此需要强制转换。 public class Student{ private String sname,sno; private int score; public Student(String sname,String sno,int score){ this.sname=sname; this.sno=sno; t
第七章.集合及泛型
qq_51913153的博客
11-30 216
1.集合 1.1集合概述 集合与数组相似都是一种容器，可以存储一组数据,集合的出现是因为有这样一种需求（程序在运行时，数据数量会不断发生变化，） 对于数组而言： 特点：同一类型（即就是定义时需要声明数组的类型，这个数组就只能存储这类数据）； 创建时指定容量，长度不变； 在一片连续的内存空间中存储（注：必须是连续空间，如果并未指明空间是否连续，则无法确定是否可以创建一个数组） 不足之处：长度固定，无法改变 1.2集合体系（仅包含单列集合） 1.3常用的方法（即单列集合中共有的方法） 创建对
Java 集合15 泛型类/泛型接口的使用
Stitch__的博客
09-08 299
泛型除了在集合中的运用，在我们的程序开发中是否还有其他的用处？ 当我们定义了一个工具对对象（不确定）进行操作，比如：设置和获取。可以对任何的对象进行操作 package Collection; //泛型在除了集合中，其他的作用——泛型类的使用 class Tool{ private Object obj; public Object getObj() { re...
泛型、泛型擦除、泛型通配符
xingze的博客
07-30 692
1、泛型定义        将对象的类型作为参数，指定到其他类或方法上，从而保证类型转换的安全性和稳定性，这就是泛型。泛型的本质是参数化类型，也就是把所操作的数据类型指定一个参数，使代码可以用于多种类型。        泛型是JDK1.5的新特性，Java语言...
java集合类和泛型
Java鲵的专栏
03-04 1005
集合框架：       集合框架是一个用来代表和操纵集合的统一架构。所有的集合框架都包含如下内容： 接口：是代表集合的抽象数据类型。接口允许集合独立操纵其代表的细节。在面向对象的语言，接口通常形成一个层次。 实现（类）：是集合接口的具体实现。从本质上讲，它们是可重复使用的数据结构。 算法：是实现集合接口的对象里的方法执行的一些有用的计算，例如：搜索和排序。这些算法被称为多态，那是因为相同的
Java定义泛型接口和类的方法实例分析
08-25
Java定义泛型接口和类的方法实例分析 Java定义泛型接口和类的方法实例分析是Java中的一个重要概念，它允许在定义类、接口时指定类型形参，这个类型形参在将在声明变量、创建对象时确定。泛型的引入提高了Java程序的...
java集合和泛型
05-01
所谓泛型，就是参数化类型。集合框架就是一个用来表示和操作集合统一的架构，包含了集合的接口与实现类。本文件通过举例来讲解泛型和集合的基础操作。
Java如何获取泛型类型
01-21
Java类型Type 之 ParameterizedType，GenericArrayType，TypeVariabl，WildcardType 从实现的接口获取泛型参数 定义一个泛型父类： public interface SuperClass { String process(P p); } 实现类1： public class...
Java集合框架及泛型
10-11
在实际开发中，理解和熟练运用Java集合框架和泛型能够大大提高代码的可维护性和安全性，减少类型转换的麻烦，并使得代码更易于理解和复用。通过以上讲解，相信你已经对这两个主题有了更深入的理解。通过练习和应用，...
java集合与泛型[参照].pdf
10-12
Java集合框架是Java编程语言中处理对象集合的重要工具，它提供了高效的数据存储和操作机制。在Java.util包中，我们找到了Collection接口及其实现类，这是整个集合框架的基础。集合框架由两个主要部分构成：...
Java泛型（类、接口、方法、集合）
激发创造，丰富生活
12-17 332
Java泛型 概述 Java泛型是jdk1.5版本以后引入的一个新特性，其本质是参数化类型，也就是把类型作为参数传递； 常见的形式有泛型类、泛型接口、泛型方法、泛型集合； 语法： ​< T > T 称之为类型占位符，表示一种引用类型，（当然<>里边可以是其他字母，在实际应用中会转为具体的类型）； 好处： 提高代码的重用性，如重载 防止类型转换异常，提高代码安全性
Java--泛型（为什么要使用泛型、使用泛型的好处、泛型类、泛型方法、泛型接口）
天行健 君子以自强不息，地势坤 君子以厚德载物。
03-24 1928
为什么要使用泛型 泛型的好处是在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的，以提高代码的重用率。 我们来看这段代码: public class test { public static class ShowUncheckedWarning { public static void main(String[] args) { java.util.ArrayList list = new java.util.ArrayList();
Java学习总结——泛型、集合（一）
zzzyw
01-05 638
泛型机制 泛型是JavaSE5.0引入的新特性，它的本质是参数化类型。在类、接口和方法的定义过程中，所操作的数据类型通过传入的 参数进行指定。广泛应用在集合框架中，所有的集合类型都带有泛型参数， 创建集合对象时可以直接指定放入集合中的元素类型，Java编译器可以根据此类型进行类型检查，可以减少代码在运行时出现的错误可能性 为什么要有泛型？ 现在有以下的实例要求： 现在要求设计一个可以表示出...
java获得集合的泛型类型_Java集合之泛型类和泛型接口
weixin_32512261的博客
02-28 811
1. 为什么要有泛型1.1 不使用泛型的问题当不使用泛型时，集合中是可以存放任意类型对象的，只要把对象存储集合后，那么他们都会被提升为Object类型。当我们在取出每一个对象，并且进行相应的操作，需要进行类型转换。观察下面代码：public static void main(String[] args) {Collection coll = new ArrayList();coll.add("ab...
Java泛型
weixin_34074740的博客
04-26 231
1. 引言 JDK1.5增加泛型支持很大程度上都是为了让集合能记住其元素的数据类型。在没有泛型之前，一旦把一个对象放入Java集合中，集合就会忘记对象的类型，把所有的对象当成Object类型处理。当程序从集合中取出对象后，就需要进行强制类型转换，这种强制类型转换不仅使代码臃肿，而且容易引起ClassCastException异常。增加了泛型支持后的集合，完全可以记住集合中元素的类型，B并可以在编...
Java异常处理的两种方式
sun10367的博客
07-23 3960
目录1 方式1：try…catch...finally捕获异常1.1 try…catch代码块1.2 finally 代码块2 方式2：throws声明抛出异常2.1 throw关键字2.3 throws关键字 异常处理方式一：在当前方法中直接用try…catch处理 异常处理方式二：在当前方法中不处理，throws 异常抛给调用者处理 1 方式1：try…catch…finally捕获异常 1.1 try…catch代码块 try-catch的方式就是捕获异常。 **try：**该代码块中编写可能

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值