Java基础知识总结（第九篇）：泛型

随遇而安622&508

已于 2024-04-07 21:07:33 修改

阅读量1.1k

点赞数 19

分类专栏： java基础知识文章标签： java 开发语言

于 2024-04-05 16:46:10 首次发布

本文链接：https://blog.csdn.net/2301_76144723/article/details/137350518

版权

java基础知识专栏收录该内容

9 篇文章 0 订阅

订阅专栏

声明:
1. 本文根据韩顺平老师教学视频自行整理，以便记忆
2. 若有错误不当之处, 请指出

系列文章目录

Java基础知识总结（第一篇）：基础语法

Java基础知识总结（第二篇）：流程控制语句(分支控制和循环控制)

Java基础知识总结（第三篇）：数组、排序和查找

Java基础知识总结（第四篇）：面向对象编程基础(类、对象、方法、包以及封装继承多态)

Java基础知识总结（第五篇）：面向对象编程进阶(代码块，抽象类、接口和内部类)

Java基础知识总结（第六篇）：枚举、注解和异常

Java基础知识总结（第七篇）：常用类：包装类、日期类以及String、StringBuffer、Builder、Math 、Arrays 、System 、BigInteger和BigDecimal

Java基础知识总结（第八篇）：集合：Collection(List、Set)、Map、Collections 工具类

一、泛型的介绍

（1）泛型又称参数化类型，是Jdk5.0出现的新特性，解决数据类型的安全性问题

（2）在类声明或实例化时只要指定好需要的具体的类型即可。

（3）Java泛型可以保证如果程序在编译时没有发出警告，运行时就不会产生ClassCastException异常。

（4）泛型的作用是：可以在类声明时通过一个标识表示类中某个属性的类型，或者是某个方法的返回值的类型，或者是参数类型。

示例：

class Person<E> {
    E s;//E 表示 s 的数据类型, 该数据类型在定义 Person 对象的时候指定,即在编译期间，就确定 E 是什么类型

    public Person(E s) {//E 也可以是参数类型
        this.s = s;
    }

    public E f() {//返回类型使用 E
        return s;
    }
}

二、泛型的语法

1.泛型的声明

interface接口<T>{}和class类<K,V>{}

1)其中，T,K,V不代表值，而是表示类型。

2)任意字母都可以。常用T表示，是Type的缩写

2.泛型的实例化

List<String> strList = new Arravlist<String>();

3.泛型使用的注意事项

（1）interface List<T>{},public class HashSet<E>{}中T,E只能是引用类型

（2）在给泛型指定具体类型后，可以传入该类型或者其子类类型

（3）泛型使用形式

List<Integer> list1 =new ArrayList<Integer>()

List<Integer> list2 =new ArrayList<>()

（4）如果这样写List list3 =new ArrayList()（默认给它的泛型是<E>，E就是Object)

三、自定义泛型类

1.基本语法

class 类名<T,R…> {//.…表示可以有多个泛型

成员

}

2.说明

（1）普通成员可以使用泛型(属性、方法、返回值)

（2）使用泛型的数组，不能初始化

（3）静态方法和静态属性不能使用泛型（因为静态是和类相关的，静态的加载在泛型之前，在类加载时，对象还没有创建，泛型还没有指定类型，所以，如果静态方法和静态属性使用了泛型，JVM 就无法完成初始化）

（4）泛型类的类型，是在创建对象时确定的(因为创建对象时，需要指定确定类型)

（5）如果在创建对象时，没有指定类型，默认为Object

class Tiger<T, R, M> {
    String name;
    R r; //属性使用到泛型
    M m;
    T t;
    //因为数组在new的时候不能确定 T 的类型，就无法在内存开空间
    T[] ts;
    public Tiger(String name) {
        this.name = name;
    }
    public Tiger(R r, M m, T t) {//构造器使用泛型
        this.r = r;
        this.m = m;
        this.t = t;
    }
}

四、自定义泛型接口

1.基本语法

interface接口名<T,R…>{

}

2.说明

（1）接口中，静态成员也不能使用泛型(原因和泛型类一样)

（2）因为接口中属性默认的修饰符是public final static，所以属性不能使用泛型

（3）泛型接口的类型，在继承接口或者实现接口时确定

（4）没有指定类型，默认为Object

interface IUsb<U, R> {
    int n = 10;
    //普通方法中，可以使用接口泛型
    R get(U u);
    void hi(R r);
    void run(R r1, R r2, U u1, U u2);
    //在 jdk8 中，在接口中，使用默认方法, 也是可以使用泛型
    default R method(U u) {
        return null;
    }
}

//在继承接口 指定泛型接口的类型
interface IA extends IUsb<String, Double> {
}

//实现 IA 接口时，因为 IA 在继承 IUsu 接口时，指定了 U 为 String R 为 Double
//，在实现 IUsu 接口的方法时，使用 String 替换 U, 是 Double 替换 R
class AA implements IA {
    @Override
    public Double get(String s) {
        return null;
    }
    @Override
    public void hi(Double aDouble) {
    }
    @Override
    public void run(Double r1, Double r2, String u1, String u2) {
    }
}

//实现接口时，直接指定泛型接口的类型
//给 U 指定 Integer 给 R 指定了 Float
//所以，当我们实现 IUsb 方法时，会使用 Integer 替换 U, 使用 Float 替换 R
class BB implements IUsb<Integer, Float> {
    @Override
    public Float get(Integer integer) {
        return null;
    }
    @Override
    public void hi(Float aFloat) {
    }
    @Override
    public void run(Float r1, Float r2, Integer u1, Integer u2) {
    }
}

五、自定义泛型方法

1.基本语法

修饰符 <T,R..>返回类型方法名(参数列表) {

}

2.说明

（1）泛型方法，可以定义在普通类中，也可以定义在泛型类中

（2）当泛型方法被调用时，类型才会确定。每次方法调用时，类型可以不一样。

（3）public void eat(E e){},修饰符后没有<T,R..>，则eat方法不是泛型方法，而是使用了泛型

class Bird<T,R,M>{
        public <E> void fly(E t) {
            System.out.println(t);
        }
}
class Fish {
    public <A> A show(A t){
            System.out.println("t的值："+t);
            System.out.println("t的类型："+t.getClass().getSimpleName());
            return t;
    }
}

六、泛型的继承和通配

（1）泛型不具备继承性

List<Object> list =new ArrayList<String>();//不能这样写

（2）<?>:支持任意泛型类型

（3）<?extends A>:支持A类以及A类的子类，规定了泛型的上限

（4）<?super A>:支持A类以及A类的父类，不限于直接父类，规定了泛型的下限

public class GenericExtends {
    public static void main(String[] args) {

        Object o = new String("xx");

        //泛型没有继承性
        //List<Object> list = new ArrayList<String>();

        //举例说明下面三个方法的使用
        List<Object> list1 = new ArrayList<>();
        List<String> list2 = new ArrayList<>();
        List<AA> list3 = new ArrayList<>();
        List<BB> list4 = new ArrayList<>();
        List<CC> list5 = new ArrayList<>();

        //如果是 List<?> c ，可以接受任意的泛型类型
        printCollection1(list1);
        printCollection1(list2);
        printCollection1(list3);
        printCollection1(list4);
        printCollection1(list5);

        //List<? extends AA> c： 表示 上限，可以接受 AA或者AA子类
//        printCollection2(list1);//×
//        printCollection2(list2);//×
        printCollection2(list3);//√
        printCollection2(list4);//√
        printCollection2(list5);//√

        //List<? super AA> c: 支持AA类以及AA类的父类，不限于直接父类
        printCollection3(list1);//√
        //printCollection3(list2);//×
        printCollection3(list3);//√
        //printCollection3(list4);//×
        //printCollection3(list5);//×

    }
    // ? extends AA 表示 上限，可以接受 AA或者AA子类
    public static void printCollection2(List<? extends AA> c) {
        for (Object object : c) {
            System.out.println(object);
        }
    }

    //说明: List<?> 表示 任意的泛型类型都可以接受
    public static void printCollection1(List<?> c) {
        for (Object object : c) { // 通配符，取出时，就是Object
            System.out.println(object);
        }
    }



    // ? super 子类类名AA:支持AA类以及AA类的父类，不限于直接父类，
    //规定了泛型的下限
    public static void printCollection3(List<? super AA> c) {
        for (Object object : c) {
            System.out.println(object);
        }
    }

}

//AA是BB的父类，BB是CC的父类
class AA {
}
class BB extends AA {
}
class CC extends BB {
}