Java中的泛型

目录

• 1. 什么是泛型
• 2. 为什么需要泛型
• 3. 如何使用泛型
  • 3.1 泛型使用
  • 3.2 自定义泛型类
    • 3.2.1 Java 源码中泛型的定义
    • 3.2.2 自定义泛型类实例1
    • 3.2.3 自定义泛型类实例2
  • 3.3 自定义泛型方法
• 4. 泛型类的子类
  • 4.1 明确类型参数变量
  • 4.2 不明确类型参数变量
• 5. 类型通配符
  • 5.1 无限定通配符
  • 5.2 extends 通配符
  • 5.3 super 通配符
• 6. 小结

1. 什么是泛型

泛型不只是 Java 语言所特有的特性，泛型是程序设计语言的一种特性。

允许程序员在强类型的程序设计语言中编写代码时定义一些可变部分，那些部分在使用前必须做出声明。

Java 中的集合类是支持泛型的，它在代码中是这个样子的

 

代码中的<Integer>就是泛型，我们把类型像参数一样传递，尖括号中间就是数据类型，我们可以称之为实际类型参数，这里实际类型参数的数据类型只能为引用数据类型。

那么为什么需要泛型呢？

2. 为什么需要泛型

我们在使用ArrayList实现类的时候，如果没有指定泛型，IDEA会给出警告，代码似乎也是可以顺利运行的。请看如下实例：

import java.util.ArrayList;

public class testDemo1 {

    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        arrayList.add("Hello");
        String str1 = (String) arrayList.get(0);
        System.out.println("str=" + str1);
    }

}

运行结果：

str1=Hello

虽然运行时没有发生任何异常，但这样做有两个缺点：

• 需要强制类型转换： 由于ArrayList内部就是一个Object[]数组，在get()元素的时候，返回的是Object类型，所以在ArrayList外获取该对象，需要强制类型转换。其它的Collection、Map如果不使用泛型，也存在这个问题；
• 可向集合中添加任意类型的对象，存在类型不安全风险。例如如下代码中，我们向列表中既添加了Integer类型，又添加了String类型

package com.caq.oop.demo08;

import java.util.ArrayList;
import java.util.List;

public class Test {
    public static void main(String[] args) {
        //实例化一个空列表
        List arrayList = new ArrayList<>();
        arrayList.add(123);
        arrayList.add("sad");
        String str = (String) arrayList.get(0);

    }
}

Exception in thread “main” java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
at com.caq.oop.demo08.Test.main(Test.java:12)

由于我们的“疏忽”，列表第 1 个元素实际上是整型，但被我们强制转换为字符串类型，这是行不通的，因此会抛出ClassCastException异常。

使用泛型可以解决这些问题。泛型有如下优点：

• 可以减少类型转换的次数，代码更加简洁；
• 程序更加健壮：只要编译期没有警告，运行期就不会抛出ClassCastException异常；
• 提高了代码的可读性：编写集合的时候，就限定了集合中能存放的类型。

3. 如何使用泛型

3.1 泛型使用

在代码中，这样使用泛型：

List<String> list = new ArrayList<String>();
// Java 7 及以后的版本中，构造方法中可以省略泛型类型：
List<String> list = new ArrayList<>();
外币巴伯

要注意的是，变量声明的类型必须与传递给实际对象的类型保持一致，下面是错误的例子：

List<Object> list = new ArrayList<String>();
List<Number> numbers = new ArrayList(Integer);

3.2 自定义泛型类

3.2.1 Java 源码中泛型的定义

在自定义泛型类之前，我们来看下java.util.ArrayList是如何定义的：

 

类名后面的<E>就是泛型的定义，E不是 Java 中的一个具体的类型，它是 Java 泛型的通配符（注意是大写的，实际上就是Element的含义），可将其理解为一个占位符，将其定义在类上，使用时才确定类型。

此处的命名不受限制，但最好有一定含义，例如java.lang.HashMap的泛型定义为HashMap<K,V>，K表示Key，V表示Value。

3.2.2 自定义泛型类实例1

下面我们来自定义一个泛型类，自定义泛型按照约定俗成可以叫<T>，具有Type的含义，实例如下：

实例演示

package com.caq.List;

public class Generic01<T> {

    private T abc;//定义在类上的泛型，在类内部可以使用

    public T getAbc() {
        return abc;
    }

    public void setAbc(T abc) {
        this.abc = abc;
    }

    public static void main(String[] args) {
        //实例化对象，指定元素类型为整型
        Generic01<Integer> integerGeneric01 = new Generic01<>();
        //调用方法
        integerGeneric01.setAbc(100);
        System.out.println("integerGeneric01="+ integerGeneric01.getAbc());

        //实例化对象，指定元素类型为长类型
        Generic01<Long> longGeneric01 = new Generic01<>();
        longGeneric01.setAbc(200L);
        System.out.println("longGeneric01="+ longGeneric01.getAbc());

        // 实例化对象，指定元素类型为双精度浮点型
        Generic01<Double> doubleGeneric01 = new Generic01<>();
        doubleGeneric01.setAbc(300.0);
        System.out.println("doubleGeneric01="+ doubleGeneric01.getAbc());

    }
}

运行结果：

integerGeneric01=100
longGeneric01=200
doubleGeneric01=300.0

我们在类的定义处也定义了泛型：Generic01<T>；在类内部定义了一个T类型的abc变量，并且为其添加了setter和getter方法。

解释：对于泛型类的使用也很简单，在主方法中，创建对象的时候指定T的类型分别为Integer、Long、Double，类就可以自动转换成对应的类型了。

3.2.3 自定义泛型类实例2

上面我们知道了如何定义含有单个泛型的类，那么对于含有多个泛型的类，如何定义呢？

我们可以看一下HashMap类是如何定义的。如下是 Java 源码的截图：

 

参照HashMap<K,V>类的定义，下面我们来看看如何定义含有两个泛型的类

package com.caq.List;

public class Generic02<K, V> {//这次是定义两个泛型在类上

    //定义类型为K的key属型
    private K key;

    //定义类型为V的value属型
    private V value;

    //封装里的知识，通过Getter和Setter方法来设置和获取私有属型的值
    public K getKey() {
        return key;
    }

    public void setKey(K key) {
        this.key = key;
    }

    public V getValue() {
        return value;
    }

    public void setValue(V value) {
        this.value = value;
    }

    public static void main(String[] args) {
        //实例化对象，分别指定类型为整型，长整型
        Generic02<Integer, Long> integerLongGeneric02 = new Generic02<>();
        //实例化对象，分别指定类型为浮点型、字符串类型
        Generic02<Float, String> floatStringGeneric02 = new Generic02<>();

        integerLongGeneric02.setKey(100);
        integerLongGeneric02.setValue(200L);
        System.out.println("key=" + integerLongGeneric02.getKey());
        System.out.println("value=" + integerLongGeneric02.getValue());

        floatStringGeneric02.setKey(0.9f);
        floatStringGeneric02.setValue("巴啦啦能量");
        System.out.println("key=" + floatStringGeneric02.getKey());
        System.out.println("value=" + floatStringGeneric02.getValue());
    }
}

运行结果：

key=100value=200key=0.9value=巴啦啦能量

3.3 自定义泛型方法

前面我们知道了如何定义泛型类，在类上定义的泛型，在方法中也可以使用。下面我们来看一下如何自定义泛型方法。

泛型方法不一定写在泛型类当中。当类的调用者总是关心类中的某个泛型方法，不关心其他属性，这个时候就没必要再整个类上定义泛型了。

直接在方法上设置泛型(generic）

package com.caq.List;public class Generic03 {        public <T> void test(T t){        System.out.println(t);    }    public static void main(String[] args) {        Generic03 generic03 = new Generic03();                generic03.test("Monkey");        generic03.test(1);        generic03.test(1.00000);        generic03.test(1L);    }}

运行结果：

Monkey11.01

实例中，使用<T>来定义test方法的泛型，它接收一个泛型的参数变量并在方法体打印；调用泛型方法也很简单，在主方法中实例化对象，调用对象下的泛型方法，可传入不同类型的参数。

4. 泛型类的子类

泛型类也是一个 Java 类，它也具有继承的特性。

泛型类的继承可分为两种情况：

• 子类明确泛型类的类型参数变量；
• 子类不明确泛型类的类型参数变量。

4.1 明确类型参数变量

例如，有一个泛型接口：

package com.caq.List;public interface GenericInterface01<T> {    default void show(T t) {            }}

泛型接口的实现类如下：

package com.caq.List;public class GenericInterfaceImple implements GenericInterface01<String> {    @Override    public void show(String s) {        System.out.println(s);    }}

子类实现明确了泛型的参数变量为String类型。因此方法show()的重写也将T替换为了String类型。

4.2 不明确类型参数变量

当实现类不确定泛型类的参数变量时，实现类需要定义类型参数变量，调用者使用子类时，也需要传递类型参数变量。

如下是GenericInterface接口的另一个实现类：

package com.caq.List;
package com.caq.List;

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

在主方法中调用实现类的show()方法：

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

    public static void main(String[] args) {
        GenericInterfaceImple<Integer> integerGenericInterfaceImple = new GenericInterfaceImple<>();
        integerGenericInterfaceImple.show(100);
    }
}


100

5. 类型通配符

我们先来看一个泛型作为方法参数的实例：

/**
 * 遍历并打印集合中的每一个元素
 * 遍历是二叉树上最重要的运算之一，是二叉树上进行其它运算之基础。 树的遍历是树的一种重要的运算。
 * 所谓遍历是指对树中所有结点的信息的访问，即依次对树中每个结点访问一次且仅访问一次。

 * @param list 要接收的集合
 */
public class Generic04 {
    public void printListElement(List<object> list){
        for (Object o :
                list) {
            System.out.println(o);
        }
    }
}

观察上面的代码，参数list的限定的泛型类型为Object， 也就是说，这个方法只能接收元素为Object类型的集合，如果我们想传递其他元素类型的集合，是行不通的。例如，如果传递装载Integer元素的集合，程序在编译阶段就会报错：

 

Tips： 泛型中的List<Object>并不是List<Integer>的父类，它们不满足继承关系。

5.1 无限定通配符

想要解决这个问题，使用类型通配符即可，修改方法参数处的代码，将<>中间的Object改为?即可：

public void printListElement(List<?> list){

此处的?就是类型通配符，表示可以匹配任意类型，因此调用方可以传递任意泛型类型的列表。

实例演示

package com.caq.List;

import java.util.ArrayList;
import java.util.List;


public class Generic04 {
//List<?>可以理解为列表的类型，可以是整数型列表，也可以是字符串类型列表，list代表的是遍历的元素代表
    public void printListElement(List<?> list){
        for (Object o : list) {
            System.out.println(o);
        }
    }

    public static void main(String[] args) {
        //实例化一个整型列表
        List<Integer> interger = new ArrayList<>();
        //加元素
        interger.add(1);
        interger.add(2);
        interger.add(2222);

        //实例化对象
        Generic04 generic04 = new Generic04();
        generic04.printListElement(interger);

        //实例化一个字符串类型列表
        ArrayList<String> strings = new ArrayList<>();
        strings.add("element1");
        strings.add("element2");
        strings.add("element3");

        generic04.printListElement(strings);
    }
}

运行结果：

2222
element1
element2
element3

5.2 extends 通配符

extends通配符用来限定泛型的上限。什么意思呢？依旧以上面的实例为例，我们来看一个新的需求，我们希望方法接收的List 集合限定在数值类型内（float、integer、double、byte 等），不希望其他类型可以传入（比如字符串）。此时，可以改写上面的方法定义，设定上界通配符：

public void printListElement(List<? extends Number> list) {

这样的写法的含义为：List集合装载的元素只能是Number自身或其子类（Number类型是所有数值类型的父类），完整实例如下：

import java.util.ArrayList;
import java.util.List;

public class Generic04 {

    public void printListElement(List<? extends Number> list) {
        for (Object o : list) {
            System.out.println(o);
        }
    }

    public static void main(String[] args) {
        // 实例化一个整型的列表
        List<Integer> integers = new ArrayList<>();
        // 添加元素
        integers.add(1);
        integers.add(2);
        integers.add(3);
        GenericDemo4 generic04 = new Generic04();
        // 调用printListElement()方法
        generic04.printListElement(integers);

    }
}

运行结果：

1
2
3

5.3 super 通配符

既然已经了解了如何设定通配符上界，也就不难理解通配符的下界了，可以限定传递的参数只能是某个类型的父类。

语法如下：

<? super Type>

6. 小结

• 使用泛型可以避免强制类型转换，也可以避免运行期就抛出的ClassCastException异常
• 在使用泛型时，要注意变量声明的泛型类型要匹配传递给实际对象的类型， Java 7 及以后的版本中，构造方法中可以省略泛型类型，推荐直接省略
• 如何自定义泛型类和泛型方法，在实际的开发中，我们想要编写比较通用的代码就避免不了使用泛型，慢慢体会星弟们~~~
• 另外，泛型也是可以继承的
• 类型通配符的概念和使用场景

到此这篇关于多方面介绍Java的泛型的文章就介绍到这了,更多相关Java 泛型内容请搜索服务器之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持服务器之家！

原文链接：https://blog.csdn.net/qq_45714272/article/details/119974269