Java泛型详解

白嫖圣手fly
125 阅读5分钟

持续创作，加速成长！这是我参与「掘金日新计划 · 6 月更文挑战」的第11天

Java泛型详解

泛型

使用Object类常出现类型转换异常

泛型由此而生

简单来说，泛型就是泛泛而谈（空洞，不确定）的类型

Java泛型(generics）是JDK5中引入的一个新特性，泛型提供了编译时类型安全监测机制，该机制允许我们在编译时检测到非法的类型数据结构

泛型的本质就是参数化类型，也就是所操作的数据类型被指定为一个参数

优点

  1. 类型安全
  2. 无需进行类型转换（无类型转换异常）

如何声明泛型

使用 类名称+< 泛型标识 > 进行声明 若是变量则直接使用 泛型标识+变量名 如下：

public class Obj <T>{
	private T ele;
}

我们常见有五种泛型标识：

  1. T：用于指定类的类型
  2. E：用于指定集合中的元素
  3. K：用于指明键值对中的键
  4. V：用于指明键值对中的值
  5. ？：用于指定任意类型

泛型的类型只有在使用的时候才会知道是什么类型

如何使用泛型

正常用！ 意思是平时你怎么使用的就怎么使用 泛型不要看的那么重，他只是不确定的类型，也是一种类型，和String，Boolean，Integer那些都一样

你只要记住在使用时指明泛型具体的类型即可

泛型类

Demo1 < T >

package type;

public class Demo1 <T>{
    private T ele1;
    private T ele2;

    public Demo1(T ele1, T ele2) {
        this.ele1 = ele1;
        this.ele2 = ele2;
    }

    public Demo1() {
    }

    public T getEle1() {
        return ele1;
    }

    public void setEle1(T ele1) {
        this.ele1 = ele1;
    }

    public T getEle2() {
        return ele2;
    }

    public void setEle2(T ele2) {
        this.ele2 = ele2;
    }

    @Override
    public String toString() {
        return "Demo1{" +
                "ele1=" + ele1 +
                ", ele2=" + ele2 +
                '}';
    }
}

test1

package test;

import type.Demo1;

public class test1 {

    public static void main(String[] args) {
        Demo1<String> stringDemo1 = new Demo1<>();
        stringDemo1.setEle1("element1");
        stringDemo1.setEle2("element2");
        stringDemo1.toString();
        System.out.println(stringDemo1.toString());
        System.out.println("---------------");
        Demo1<Boolean> booleanDemo1 = new Demo1<>();
        booleanDemo1.setEle1(true);
        booleanDemo1.setEle2(false);
        System.out.println(booleanDemo1.toString());
    }
}

在这里插入图片描述

泛型类及其子类

1. 子类也是泛型类

若子类也是泛型类，子类和父类的泛型标识需要一致 即父类使用标识T子类也是T

父类

package type;

public class Parent <T>{
}

子类

package type;

public class Child1<T> extends Parent{
}

2.子类非泛型类

若子类非泛型类则父类需要在继承时指明类型

父类

package type;

public class Parent <T>{
}

子类

package type;

public class Child2 extends Parent<String>{
}

泛型接口

同泛型类一样有两种，写法相同

package type;

public interface Demo2 <T>{
    void doMethod();
}

实现一个带有2个泛型的类

package type;

public class Child2<K,V>{
    private K key;
    private V value;

    public Child2() {
    }

    public Child2(K key, V value) {
        this.key = key;
        this.value = value;
    }

    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与返回值中间< T >非常重要，可以理解为声明此方法为泛型方法。
  • 只有声明了< T >的方法才是泛型方法，泛型类中的使用了泛型的成员方法并不是泛型方法。
  • < T >表明该方法将使用泛型类型T，此时才可以在方法中使用泛型类型T。
  • 与泛型类的定义一样，此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型。
修饰符 <标识> 返回值类型 方法名（）{}

类

public <E> E met(E value){
        return value;
    }

package type;

public class Demo1 <T>{
    private T ele1;
    private T ele2;

    /*省略*/

    public <E> E met(E value){
        return value;
    }
}

测试

package test;

import type.Demo1;

public class test1 {

    public static void main(String[] args) {

        Demo1<Boolean> booleanDemo1 = new Demo1<>();
        booleanDemo1.setEle1(true);
        booleanDemo1.setEle2(false);
        System.out.println(booleanDemo1.toString());

        String test_met = booleanDemo1.met("test_met");
        System.out.println(test_met);
    }
}

在这里插入图片描述

？（类型通配符）

想象以下场景 你现在要在泛型类中对一个方法进行重载

public void met(Child<Int> child){}

public void met(Child<String> child){}

你认为可以重载成功吗？

答案是不行！因为Child< String >和Child< Int >实际上就是一个Child< T >!

所以？由此而生

public void met(Child<?> child){}

我们就可以直接通过这样一个进行多个方法的重载

所以？就代表类型实参，而不是类型形参

类型通配符的上限

我们设置可以用？进行继承，标识该泛型只能是继承的类或其子类

public void met(Child<? extends Number> child){}

这就称为类型通配符的上限

上限表示该类型至多是XX类型

类型通配符的下限

将extends改为super这表明当前传入实参类型只能是某个类型的父类


public void met(Child<? super Int> child){}

下限表示该类型至少是XX类型

类型擦除

泛型的信息只存在于代码编译阶段，进入JVM前与之相关的信息会被抹除（去掉）

这被称为类型擦除

无限制类型擦除

从泛型 → Object

即所有的泛型标识都转为Object

//擦除前
public T ele
//擦除后
public Object ele

验证（通过反射）

泛型类
package type;

public class Demo1 <T>{
    private T ele1;
    private T ele2;

    public Demo1(T ele1, T ele2) {
        this.ele1 = ele1;
        this.ele2 = ele2;
    }

    public Demo1() {
    }

    public T getEle1() {
        return ele1;
    }

    public void setEle1(T ele1) {
        this.ele1 = ele1;
    }

    public T getEle2() {
        return ele2;
    }

    public void setEle2(T ele2) {
        this.ele2 = ele2;
    }

    @Override
    public String toString() {
        return "Demo1{" +
                "ele1=" + ele1 +
                ", ele2=" + ele2 +
                '}';
    }

    public <E> E met(E value){
        return value;
    }
}
测试类
package test;

import type.Demo1;

import java.lang.reflect.Field;

public class test3 {
    public static void main(String[] args) {
        Demo1<String> stringDemo1 = new Demo1<>();
        Class<? extends Demo1> aClass = stringDemo1.getClass();
        Field[] declaredFields = aClass.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println(declaredField.getType().getSimpleName());
        }
    }
}

在这里插入图片描述

类型上下限擦除

上限变父类，向下兼容 下限变Object，顶层兼容所有

只要记住上面两句话即可 即：

//上限
public <T extends Parent> T met(){...}
//擦除后
public Parent met(){...}

//下限
public <T super Parent> T met(){...}
//擦除后
public Object met(){...}

桥接方法

当我们的类以指定的某个类型实现某个泛型接口，编译后就会产生桥接方法

桥接方法是为了让实现类向上兼容

接口

package type;

public interface Demo2 <T>{
    T doMethod(T val);
}

实现类

package type;

public class Demo3 implements Demo2<String>{
    @Override
    public String doMethod(String val) {
        System.out.println("实现接口");
        return val;
    }
}

编译后

package type;

public class Demo3 implements Demo2{
    @Override
    public String doMethod(String val) {
        System.out.println("实现接口");
        return val;
    }
//编译后生成的桥接方法
@Override
    public Object doMethod(Object val) {
        System.out.println("实现接口");
        return doMethod((String) val)
    }
}

泛型数组

声明方式

package test;

import java.util.ArrayList;

public class test4 {
    public static void main(String[] args) {
        ArrayList<String>[] lists = new ArrayList[10];
        ArrayList<String> strings = new ArrayList<>();
        strings.add("new");
        lists[0] = strings;
        String s = lists[0].get(0);
        System.out.println(s);

    }
}

问题

这时候就有人问了，我不能写出如下的形式吗？

package test;

import java.util.ArrayList;

public class test4 {
    public static void main(String[] args) {
        ArrayList<String>[] lists = new ArrayList[10];
        lists[0].add("hello");
        System.out.println(lists[0].get(0));
    }
}

这样一看从逻辑上好像解释的通 既然lists[ ]是ArrayList< String >类型那么一定有其add方法可以添加元素

但是实际上是不对的！会出现空指针

在这里插入图片描述

原因

经过调试，你可以看到在执行这一行时lists[0]是空，也就是说lists[0]仅有对象引用没有内存空间！所以null.add()根本不可能有这个方法！

在这里插入图片描述

通过Array.newInstance创建

package type;

import java.lang.reflect.Array;

public class Demo4<T> {
    private T[] ele;

    public Demo4(Class<T> ele, int length) {
        this.ele = (T[]) Array.newInstance(ele, length);
    }
}
avatar
文章
阅读
粉丝