开发者社区> garwer> 正文
阿里云
为了无法计算的价值
打开APP
阿里云APP内打开

java基础巩固-详解泛型

简介: java泛型(generics)为jdk5引入的新特性,泛型提供了编译时类型安全检测机制,可以在编译时检测到非法的类型。 泛型的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数。
+关注继续查看

java泛型(generics)为jdk5引入的新特性,泛型提供了编译时类型安全检测机制,可以在编译时检测到非法的类型。
泛型的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数。

使用泛型的好处

它的主要目标是保障java的类型安全,简化编程,泛型可以使编译器知道一个对象限定类型是什么,所有的强制转换都为自动和隐式的。

举个简单的栗子
public class test1 {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("字符串");
        list.add(1);
        for (Object a : list) {
            System.out.println("toString转换->" + a.toString());
            System.out.println("强转->" + (String)a);
        }
    }
}
执行结果
Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
toString转换字符串
强转字符串
toString转换1
    at generics.test1.main(test1.java:13)

虽然编译的时候没有报错,但是运行的时候强转为String的时候出现类型转换的错,可以看出来这种写法是不安全的。

进一步做点改良(使用泛型后,编译器报错,这样可以预防一些后续编译通过但运行报错的情况)
img_45b245978bd10221ba0b3aba0248d830.png

泛型的一个重要特性:跟反射不同的是,泛型检查只在编译期间有效,而反射则是在运行时有效。

下面做个简单的测试

public class test2 {
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        //测试泛型
        List<String> list1 = new ArrayList<String>();
        List<Integer> list2 = new ArrayList<Integer>();
        Class class1 = list1.getClass();
        Class class2 = list2.getClass();
        if(class1.equals(class2)) {
            System.out.println("类型相同");
        }
      
        //测试反射
        Map<String, String> map = new HashMap<String, String>();
        String key = "key";
        Integer val = 1;
        //通过反射获取方法
        Method m = HashMap.class.getDeclaredMethod("put", new Class[] { Object.class, Object.class });
        //invoke意在将方法参数化 动态调用Method类代表的方法 并传入参数
        m.invoke(map, key, val);
        System.out.println(map);
        System.out.println(map.get(key)); //获取key为key的值
    }
}
img_d2fbb5e890cc911cbb5efd98f175047c.png
image.png

泛型的使用方式

1.泛型类
2.泛型接口
3.泛型方法

泛型类

//T,E,K,V等均表示为泛型
public class Generic<T> {
    private T key;//成员变量类型为T,由外部指定

    public Generic(T key) {
        this.key = key;
    }

    public T getKey(){ //泛型方法getKey的返回值类型为T,T的类型由外部指定
        return key;
    }

    public static void main(String[] args) {
        //在实例化泛型类时 需指定T的具体类型(这边5就代表integer) 
        Generic<Integer> s1 = new Generic<Integer>(5);
        Generic<String> s2 = new Generic<String>("5");

        System.out.println(s1.getClass());//class generics.Generic
        System.out.println(s2.getClass());//class generics.Generic

        System.out.println(s1.getKey().getClass()); //class java.lang.Integer
        System.out.println(s2.getKey().getClass()); //class java.lang.String
      
        /**
         *     定义泛型类不一定要传入泛型类型实参,如果传入的化会在编译时做限制,不传的化可以为任一类型,
         *     但处于安全考虑一般都定义否则一些场景容易出现ClassCastException错误
         */
        Generic t1 = new Generic(5);
        Generic t2 = new Generic(0.5);
        System.out.println(t1.getKey()); //5
        System.out.println(t2.getKey()); //0.5
        System.out.println(t1.getKey().getClass()); //class java.lang.Integer
        System.out.println(t2.getKey().getClass()); //class java.lang.Double
    }
    }
}

泛型接口

泛型接口与类定义和使用大致相同,例如Map接口的一小段代码

public interface Map<K,V> {
  ...
  V put(K key, V value);
  void putAll(Map<? extends K, ? extends V> m);//指明泛型的上边界
  ...  
}

实现泛型接口,假设实现map

//假如一个类实现了泛型接口,需要将泛型声明(test3<K,V>) 一起加到类中 否则编译报错 
public class test3<K,V> implements Map<K,V>{
    @Override
    public int size() {
        return 0;
    }

    @Override
    public boolean isEmpty() {
        return false;
    }
    ...
}

泛型方法

泛型类,是在实例化类的时候指明【泛型】的具体类型;泛型方法,是在调用方法的时候指明泛型的具体类型

这样说有点绕口 举两个栗子

/**
    泛型类
**/
//定义泛型类 该类
public class Test<T> {
    public T key;
    public test5(T key) {
        this.key = key;
    };
}
//通过实例化指明【泛型】T的类型为String 
Test<String> t = new Test<Sring>("123");
/**
    泛型方法 
    定义泛型方法时 必须在返回值前面加一个 <T> 来声明这是一个泛型方法
**/
public class test5<T> {
    //在这里<T>表示返回的类型是T的 该方法的作用是新建任一指定类型并返回
    public <T> T getObject(Class<T> c) throws IllegalAccessException, InstantiationException {
        T t = c.newInstance();//创建泛型对象
        return t;
    }

    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
        test5 t = new test5();
        //调用泛型方法【在调用方法的时指明泛型具体类型 这边用User型】
        //在这object就是User的实例 这边测试别用类似java.lang.xxx这样BootStrap类加载器加载的类 否则输出为空
        Object object = t.getObject(Class.forName("generics.User"));
        System.out.println(object.getClass()); //输出class generics.User
    }
}

泛型的上下边界

使用泛型的时,可以通过传入泛型类型实参进行上下边界的限制。

如定义一个泛型类

public class Generic<T extends Number> { //此处为上边界 意为给定T类型需为Number子类 T super XX 为下边界
    private T key;
    public Generic(T key) {
        this.key = key;
    }
    public T getKey(){
        return key;
    }
}

如果这样实例化Generic类编译器会报错,因为String不是Number的子类。

Generic<String> generic = new Generic<String>("11111");

一些思考

1.下面这个getKey是否为泛型方法
public class Generic<T> { 
    private T key;
    public Generic(T key) {
    this.key = key;
    }
    public T getKey(){
       return key;
    }
}

并不是,虽然在方法中使用了泛型,这个是类中普通的成员方法,因为它的返回值是声明泛型类【Generic】时已经声明过的泛型【T】,所以在方法中可以继续使用T这个泛型。

2.经常在使用泛型的代码中看见通配符 【?】它的作用是什么,和T的区别在哪呢

比如Map源码

void putAll(Map<? extends K, ? extends V> m);

在这里?是通配符,泛指所有类型,常用于不确定类型的情况

? extends T 指T类型或T的子类型

? super T 指T类型或T的父类型

它们的区别在于

"T"是定义类或方法时声明的东西,"?"是调用时传入的东西

①T常用于声明一个泛型类或者泛型方法

②?常用于使用泛型类或泛型方法

声明泛型类时不能用无界通配符<?>

//error example
class demo<?> { 
  private ? item; 
}
通配符是可以用来使用定义好的泛型的 但是T不能用来继续使用已经定义好的泛型

当我们在外面使用一个带泛型T的类或方法时,T应该用一个实际的数据类型替代它,也可以使用?通配符

public class User {
    HashMap<T,String> map = new HashMap<String, String>(); //error example
    HashMap<?,String> map = new HashMap<String, String>(); //right example
}
看hashMap源码中的putAll方法
img_09db015e1766a7084a9b09752c2c3d9f.png
简单来说,T一般是声明时用(泛型类,泛型方法),而?通配符一般是使用时用,可以使用作为通用类。

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
JAVA基础复习之JDBC(配置动态数据源)
复习原因 在项目的开发当中,之前数据库连接信息都是写死在配置文件当中。但是突然接到一个需求: 获取外部数据源信息,然后将某些数据通过Echarts绘制成折线图展示出来(ps:数据源需要用户手动设定) 有点懵,因为之前都是写死在配置文件当中的,然后在网上也找了一些资料,发现都不是自己想要的。 最后想到,既然是简单的获取数据进行展示,直接使用JDBC连接数据库获取就可以了啊。没有必要搞什么骚操作。 JDBC 一直使用的JPA或者mybatis进行数据库连接,很少使用JDBC进行数据库连接。 因此也复习一下JDBC,毕竟无论是JPA还是Mybatis都是对JDBC的一个封装。 什么是JD
0 0
【Java 基础】Java 数据类型和 MySql 数据类型对应表
【Java 基础】Java 数据类型和 MySql 数据类型对应表MySQL 数据类型对应 Java 数据类型 类型名称 显示长度 数据库类型 JAVA 类型 JDBC 类型索引 (int) 描述 VARCHAR L+N VARCHAR java.lang.String 12 CHAR N CHAR java.lang.String 1 BLOB L+N BLOB java.lang.byte[] -4 TEXT 65535 VARCHAR java.lang.String -1 INTEGER 4 INTEGER UNSIGNED java.lang.Long 4 TINYINT
0 0
Java基础深化和提高 ---- 反射技术
Java 反射机制是Java语言一个很重要的特性,它使得Java具有了“动 态性”。
0 0
Java的学习笔记(02)基础
访问修改函数 static:它用于使成员(块、方法、变量或嵌套类)可以独立于任何其他成员使用,而无需参考特定情况。 strictfp:用于限制、浮点、浮点运算和计算,并在浮点变量中执行任务时保证每个阶段的结果相同。 synchronized:它用于在Java中获得适用于块和方法的同步。 transient:作为序列化的一部分使用的因子修饰符。在序列化的季节,如果我们不想对记录中的特定变量进行多余的估计,那么此时,我们使用transient关键字。 volatile:如果修饰符告诉编译器,由不稳定变量调整的变量通过程序的不同部分发生惊人的变化,则使用volatile。 Java关键字的
0 0
Java基础深化和提高-------容器篇(上)
为了能够更好的学习容器,我们首先要先来学习一个概念:泛型。
0 0
【Java原理探索】夯实你对AQS的认识和基础
【Java原理探索】夯实你对AQS的认识和基础
0 0
Java面试题1:Java基础篇
面向对象是一种万物皆对象的编程思想,任何物体都可以归为一类事物,而一个个个体都是一类事物的实例。面向对象的编程是以对象为中心,以消息为驱动的。
0 0
Java面向对象基础5——String类(2)
Java面向对象基础5——String类(2)
0 0
+关注
garwer
me.garwer.cn
文章
问答
文章排行榜
最热
最新
相关电子书
更多
JAVA 应用排查全景图
立即下载
Java工程师必读手册
立即下载
Java应用提速(速度与激情)
立即下载