背景

在没有泛型前,一旦把一个对象丢进集合中,集合就会忘记对象的类型,把所有的对象都当成 Object 类型处理。当程序从集合中取出对象后,就需要进行强制类型转换,这种转换很容易引起 ClassCastException 异常。

定义

程序在创建集合时指定集合元素的类型。增加了泛型支持后的集合,可以记住集合中元素的类型,并可以在编译时检查集合中元素的类型,如果试图向集合中添加不满足类型要求的对象,编译器就会报错。

示例

集合使用泛型

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class DiamondTest {
    public static void main(String[] args) {
        List<String> books = new ArrayList<>();
        books.add("learn");
        books.add("java");
        books.forEach(book -> System.out.println(book.length()));

        Map<String, List<String>> schoolsInfo = new HashMap<>();
        List<String> schools = new ArrayList<>();
        schools.add("i");
        schools.add("love");
        schoolsInfo.put("java", schools);
        schoolsInfo.forEach((key, value) -> System.out.println(key + "--->" + value));
    }
}

类、接口使用泛型

public class Apple<T> {
    private T info;
    public Apple() {}
    public Apple(T info) {
        this.info = info;
    }
    public void setInfo(T info) {
        this.info = info;
    }
    public T getinfo() {
        return this.info;
    }
    public static void main(String[] args) {
        Apple<String> a1 = new Apple<>("Apple");
        System.out.println(a1.getinfo());
        Apple<Double> a2 = new Apple<>(5.67);
        System.out.println(a2.getinfo());
    }
}

类型通配符

需求分析

public void test(List<Object> c) {
    for (int i = 0; i < c.size(); i++) {
        System.out.prinln(c.get(i));
    }
}

这个方法声明没有任何问题,但是调用该方法实际传入的参数值,可能会出错。考虑如下代码:

List<String> strList = new ArrayList<>();
test(strList); // 编译出错,表明 List<String> 对象不能被当成 List<Object> 对象使用,也就是说 List<String> 并不是 List<Object> 的子类。

问题解决

为了表示各种泛型 List 的父类,可以使用类型通配符。List<?> 表示元素类型未知的 List。这个 号被称为通配符,它可以匹配任何类型。将上面的代码,改为如下形式:

public void test(List<?> c) {
    for (int i = 0; i < c.size(); i++) {
        System.out.prinln(c.get(i));
    }
}

现在传入任何类型的 List,程序可以正常打印集合 c 中的元素。

不过集合中元素的类型会被当成 Object 类型对待。

类型通配符的上限

需求分析

当使用 List<?> 时,表明它可以是任何泛型 List 的父类。如果我们只希望它代表某一类泛型 List 的父类,java 提供了被限制的泛型通配符。

看如下代码:

public abstract class Shape {
    public abstract void draw(Canvas c);
}
public class Circle extends Shape {
    @Override
    public void draw(Canvas c) {
        System.out.println("在画布上" + c + "上画一个圆");
    }
}
public class Rectangle extends Shape {
    @Override
    public void draw(Canvas c) {
        System.out.println("把一个矩形画在画布" + c + "上");
    }
}
import java.util.List;

public class Canvas {
    public void drawAll(List<Shape> shapes) {
        for (Shape s : shapes) {
            s.draw(this);
        }
    }
}

下面代码将引起编译错误,因为 List<Circle> 并不是 List<Shape> 的子类型,所以不能把 List<Circle> 对象当成 List<Shape> 类用。

// 错误示范
List<Circle> circleList = new ArrayList<>();
Canvas c = new Canvas();
c.drawAll(circleList); 

问题解决

方法一:通过类型通配符解决,即 List<?> 方式。

需要进行强制类型转换,因为 List<?> 中元素默认为 Object 类型

import java.util.List;

public class Canvas {
    public void drawAll(List<?> shapes) {
        for (Object obj : shapes) {
            Shape s = (Shape)obj // 但是需要进行强制类型转换,因为前面提到过 List<?> 中元素默认为 Object 类型
            s.draw(this);
        }
    }
}

方法二:使用被限制的泛型通配符

List<? extends Shape> 可以表示 List<Circle>List<Rectangle> 的父类。只要 List 尖括号里的类型是 Shape 的子类即可。

import java.util.List;

public class Canvas {
    public void drawAll(List<? extends Shape> shapes) { // 使用被限制的泛型通配符
        for (Shape s : shapes) {
            s.draw(this);
        }
    }
}

形参类型上的应用

在定义类型形参时设定类型通配符上限。以此来表示传递给该类型形参的实际类型必须是该上限类型或者其子类。

public class Apple<T extends Number> {
    T col;
    public static void main(String[] args) {
        Apple<Integer> ai = new Apple<>();
        Apple<Double> ad = new Apple<>();
        Apple<String> as = new Apple<>(); // 编译出错,试图将 String 类型传给 T 形参,但是 String 不是 Number 的子类型
    }
}

泛型方法

定义

泛型方法就是在声明方法时定义一个或多个类型形参。多个类型参数之间用逗号隔开。

修饰符 <T, S> 返回值类型 方法名(形参列表) {方法体}

需求分析

泛型方法解决了什么问题?

static void fromArrayToCollection(Object[] a, Collection<Object> c) {
    for (Object o : a) {
        c.add(o)
    }
}

上面定义的方法没有任何问题,关键在于方法中的 c 形参,它的数据类型是 Collection<Object>。假设传入的实际参数的类型是 Collection<String>,因为 Collection<String> 并不是 Collection<Object> 的子类,所以这个方法的功能非常有限,它只能将 Object[] 数组的元素复制到元素为 Object 类型(Object 的子类不行)的 Collection 集合中。

如果使用通配符 Collection<?> 是否可行呢?显然也不行,Collection 集合提供的的 add() 方法中有类型参数 E,而如果使用类型通配符,这样程序无法确定 c 集合中的元素类型,所以无法正确调用 add 方法。

问题解决

泛型方法。

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

public class GenericMethodTest {
    // 声明一个泛型方法
    static <T> void fromArryToCollection(T[] a, Collection<T> c) {
        for (T o : a) {
            c.add(o);
        }
    }
    public static void main(String[] args) {
        Object [] oa = new Object[100];
        Collection<Object> co = new ArrayList<>();
        fromArryToCollection(oa, co);

        String[] sa = new String[100];
        Collection<String> cs = new ArrayList<>();
        fromArryToCollection(sa, cs);
    }
}

进一步改造,如下

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

public class RightTest {
    static <T> void test(Collection<? extends T> from, Collection<T> to) {
        for (T ele : from) {
            to.add(ele);
        }
    }
    public static void main(String[] args) {
        List<String> as = new ArrayList<>();
        List<Object> ao = new ArrayList<>();
        test(as, ao);
    }
}

泛型构造器

和泛型方法类似,Java 也允许在构造器签名中声明类型形参,这就产生了所谓的泛型构造器

public class Foo {
    // 泛型构造器
    public <T> Foo(T t) {
        System.out.println(t);
    }
}

public class GenericConstructor {
    public static void main(String[] args) {
        new <String> Foo("crazy");
        new Foo("crazy"); // 与上面等价
        new <Sting> Foo(12.3) // 出错
    }
}

类型通配符下限

需求分析

实现一个方法,将 src 集合里的元素复制到 dest 集合里,且返回最后一个被复制的元素的功能。

因为 dest 集合可以保存 src 集合里的所有元素,所以 dest 集合元素的类型应该是 src 集合元素类型的父类。

为了表示两个参数间的类型依赖,考虑同时使用之前介绍过的通配符、泛型参数来实现该方法,代码如下:

public static <T> T copy(Collection<T> dest, Collection<? extends T> src) {
    T last = null;
    for (T ele : src) {
        last = ele;
        dest.add(ele);
    }
    return last;
}

List<Number> ln = new ArrayList<>();
List<Integer> li = new ArrayList<>();
// 下面代码会引起编译错误
Integer last = copy(ln, li);

上面的代码有一个问题,ln 的类型是 List<Number>,那么 T 的实际类型就是 Number,即返回值 last 类型是 Number 类型。但实际上最后一个复制元素的类型一定是 Integer。也就是说,程序在复制集合元素的过程中,丢失了 src 集合元素的类型。

问题解决

为了解决这个问题,引入通配符下限,<? super Type>。表示必须是 Type 本身或者 Type 的父类。改写后的完整代码,如下:

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

public class MyUtils {
    // 使用通配符下限
    public static <T> T copy(Collection<? super T> dest, Collection<T> src) {
        T last = null;
        for (T ele : src) {
            last = ele;
            dest.add(ele);
        }
        return last;
    }
    public static void main(String[] args) {
        List<Number> ln = new ArrayList<>();
        List<Integer> li = new ArrayList<>();
        li.add(5);
        // 此时可以准确知道最后一个被复制的元素是 Integer 类型,而不是笼统的 Number 类型
        Integer last = copy(ln, li);
        System.out.println(last);
        System.out.println(ln);
    }
}

泛型擦除

泛型基本上都是在编译器这个层次来实现的。在生成的 Java 字节代码中是不包含泛型中的类型信息的。使用泛型的时候加上的类型参数, 会被编译器在编译的时候去掉。这个过程就称为泛型擦除。如在代码中定义的 List<Object>List<String> 等类型, 在编译之后都会变成 List, JVM 看到的只是 List, 泛型附加的类型信息对 JVM 来说是不可见的。

欢迎关注我的公众号

Java 基础篇之泛型的更多相关文章

  1. java基础篇---I/O技术

    java基础篇---I/O技术   对于任何程序设计语言而言,输入输出(I/O)系统都是比较复杂的而且还是比较核心的.在java.io.包中提供了相关的API. java中流的概念划分 流的方向: 输 ...

  2. 金三银四跳槽季,BAT美团滴滴java面试大纲(带答案版)之一:Java基础篇

    Java基础篇: 题记:本系列文章,会尽量模拟面试现场对话情景, 用口语而非书面语 ,采用问答形式来展现.另外每一个问题都附上“延伸”,这部分内容是帮助小伙伴们更深的理解一些底层细节的补充,在面试中可 ...

  3. java基础篇---HTTP协议

    java基础篇---HTTP协议   HTTP协议一直是自己的薄弱点,也没抽太多时间去看这方面的内容,今天兴致来了就在网上搜了下关于http协议,发现有园友写了一篇非常好的博文,博文地址:(http: ...

  4. java基础篇---I/O技术(三)

    接上一篇java基础篇---I/O技术(二) Java对象的序列化和反序列化 什么叫对象的序列化和反序列化 要想完成对象的输入或输出,还必须依靠对象输出流(ObjectOutputStream)和对象 ...

  5. Java基础教程:泛型基础

    Java基础教程:泛型基础 引入泛型 传统编写的限制: 在Java中一般的类和方法,只能使用具体的类型,要么是基本数据类型,要么是自定义类型.如果要编写可以应用于多种类型的代码,这种刻板的限制就会束缚 ...

  6. Java基础篇 - 强引用、弱引用、软引用和虚引用

    Java基础篇 - 强引用.弱引用.软引用和虚引用 原创零壹技术栈 最后发布于2018-09-09 08:58:21 阅读数 4936 收藏展开前言Java执行GC判断对象是否存活有两种方式其中一种是 ...

  7. java基础篇 之 构造器内部的多态行为

    java基础篇 之 构造器内部的多态行为 ​ 我们来看下下面这段代码: public class Main { public static void main(String[] args) { new ...

  8. 小白—职场之Java基础篇

    java基础篇 java基础 目录 1.java是一种什么语言,jdk,jre,jvm三者的区别 2.java 1.5之后的三大版本 3.java跨平台及其原理 4.java 语言的特点 5.什么是字 ...

  9. java基础篇1

    JAVA基础篇1 注释 单行注释 //这是一个单行注释,由两个斜杠组成,不能嵌套多行注释 多行注释 /*这是一个 多行注释 ,//里面不能嵌套多行注释, 但是可以嵌套单行注释*/ 文档注释 /**ja ...

随机推荐

  1. mysql锁定单个表的方法

    mysql锁定单个表的方法mysql>lock table userstat read;mysql>unlock tables; 本文来自ChinaUnix博客,如果查看原文请点:http ...

  2. 将网页上指定的表单的数据导入到excel中

    很多时候,我们想要将网页上显示的信息,导入到Excel中,但是很多时候无法下手.可是,这个时候,下面这个例子会帮你大忙了. 将html表单指定内容导出到EXCEL中. <!DOCTYPE HTM ...

  3. [Cypress] Find Unstubbed Cypress Requests with Force 404

    Requests that aren't stubbed will hit our real backend. To ensure we've stubbed all our routes, we c ...

  4. Luogu P5022 旅行 搜索+贪心

    好吧...一直咕..现在才过...被卡常卡到爆... 写的垃圾版本,$n^2$无脑删边..可以发现走出来的是棵树...更优秀的及数据加强版先咕着...一定写.qwq #include<cstdi ...

  5. luogu 2279 [HNOI2003]消防局的设立 树形dp

    就是细节多一些,思路都非常常规. Code: #include <bits/stdc++.h> #define N 1005 #define inf 1061109567 #define ...

  6. 11.17 模拟赛&&day-2

    /* 后天就要复赛了啊啊啊啊啊. 可能是因为我是一个比较念旧的人吧. 讲真 还真是有点不舍. 转眼间一年的时间就过去了. 2015.12-2016.11. OI的一年. NOIP gryz RP++. ...

  7. 【csp模拟赛3】组合数学

    思路: 先排序,取最大的在剩余左边任意找k-1个数,所以是排列组合,费马小定理求逆元,预处理阶乘,注意要取模.. 代码: #include<cstdio> #include<iost ...

  8. 【线性代数】4-3:最小二乘近似(Least Squares Approximations)

    title: [线性代数]4-3:最小二乘近似(Least Squares Approximations) categories: Mathematic Linear Algebra keywords ...

  9. Postman使用tv4进行JSON Schema结构验证和断言

    JSON Scheme简介 对于JSON格式的请求数据或者响应数据,在不同的数据和场景下往往会有一部分动态的值及字段.此时我们可以使用JSON Scheme Validator(JSON结构验证)来验 ...

  10. 用ST解决RMQ问题

    用ST算法解决RMQ(区间最值问题) 在解决CF上的6E Exposition时,用到了RMQ+二分的方法.学习了用ST来快速解决RMQ问题,因此做一个小记 建表 用DP的方式来建ST. dp[i][ ...