泛型《自学笔记》

最新推荐文章于 2025-06-04 17:43:56 发布

Lipp Chan

最新推荐文章于 2025-06-04 17:43:56 发布

阅读量96

点赞数

文章标签： java 开发语言后端泛型

本文链接：https://blog.youkuaiyun.com/quentien/article/details/123110587

版权

本文详细介绍了Java泛型的概念、好处、泛型类、泛型接口、泛型方法的创建与使用，以及如何限定类型变量、使用通配符等。通过实例代码展示了泛型在集合操作、接口定义及方法中的应用，旨在提升代码的可读性和安全性，减少类型转换的麻烦。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

笔记发布时间：2022/02/24

java泛型学习

笔记介绍：在进行集合学习时，经常会用到泛型，所以先来掌握一些泛型基本知识。

泛型是什么

解释：用具体的规则约束我们所使用的类型
类似我昨天学习的ArrayList集合

List<String> list = new ArrayList<>();

泛型好处

若底层存储为object类，添加的元素可以向上转型为Object类，更重要的是我们可以通过规则按照自己的想法存储的数据类型。
可以增加代码可读性，让集合在编译期就添加我们所项目存储的类型，在后期get集合元素时候，无需进行强制类型转换，保证代码的安全性。

泛型类

泛型标识符：一般用大写字母字符

如果是表示集合的元素，一般用字母E
表示键值对的set话，用的是K&V
表示类型的话，用大写字母T

构造一个泛型

public class Person<T> {
    private T t;
    public Person(T t){
        this.t = t;
    }
    //构造函数
    public void run(){
        System.out.println(t);
    }
}

测试代码

    //正规用法
    Person<String> s1 = new Person<String>("张三");
    //jdk7.0后可以省略后面的参数类型，现在大部分用的是下面写法
    Person<String> s2 = new Person<>("张三");
    s2.run();

    //泛型的定义是可以帮助我们按照某种规则去做事，如果不做限制，也不会编译错误，但泛型就毫无意义了
    Person tp = new Person(111);
    tp.run();

    //泛型的类型不能是八大基本类型，下面会编译出错
    Person<int> s = new Person<>(1);

输出结果

张三
111

泛型接口

public interface Person<T> {
    public T parent();
    public String eat();
}
public class Teacher<T> implements Person<T> {
    @Override
    public T parent() {
        return null;
    }

    @Override
    public String eat() {
        return "爱吃火锅";
    }
}
public class Test {
public static void main(String[] args) {
	Teacher<String> teacher =new Teacher<>();
	System.out.println(teacher.eat());
}
}

泛型方法

泛型方法可以定义在普通类与泛型类里面，一般优先使用泛型方法，而不使用泛型类。

public class Test {
public static void main(String[] args) {
	String s =Teacher.println("调用泛型");
}
}
public class Teacher {
	public static <T> T println(T t) {
		System.out.println(t);
		return t;
	}
}

泛型类的泛型变量T与泛型类内的泛型方法的变量T没有关系
代码例子：

public class Test {
public static void main(String[] args) {
	Teacher<String> teacher = new Teacher<>("张三");
	Integer in = teacher.println(123456);
	System.out.println(teacher.teacher);
}
}
public class Teacher<T> {
    T teacher;
    public Teacher(T t){
        this.teacher = t;
    }
    public <T> T println(T t){
        System.out.println(t);
        return t;
    }
}

限定类型变量

想传递参数类型仅仅只是大类包含里面的小类，可以直接在编写方法时候，用extends关键字来传参，绑定的意思。
example:

public class Test {
public static void main(String[] args) {
	@SuppressWarnings("unused")
	ArrayFlag af =new ArrayFlag();
	String[] array = {"ni","hao","zhongguo"};
	System.out.println(ArrayFlag.getMax(array));
}

}
class ArrayFlag {
    @SuppressWarnings({ "rawtypes", "unchecked" })
	public static <T extends Comparable> T getMax(T[] array){
        if(array == null || array.length == 0){
            return null;
        }
        T maxValue = array[0];
        for(int i = 0; i < array.length; i++){
            if(array[i].compareTo(maxValue) > 0){
                maxValue = array[i];
            }
        }
        return maxValue;
    }
}

通配符

test效果演示

//定义了一个书籍类
public class Book {}
//定义了一个小说书籍类继承书籍类
public class Novel extends Book {}
//定义了一个书柜类用来装书
public class Bookcase<T> {
    T b; 
    public Bookcase(T t){
        this.b = t;
    }
    public void set(T t) {
        b=t;
    } 
    public T get() {
        System.out.println(b.getClass());
        return b;
    }
}

ex1：

Bookcase<Book> bc = new Bookcase<>(new Novel());
	System.out.println(bc.getClass());
	bc.get();

结果：

class com.day0224.fanxingjiaoxue.demo01.Bookcase
class com.day0224.fanxingjiaoxue.demo01.Novel

类型参数< T >声明一个泛型类或泛型方法
无限定通配符< ? >使用泛型类或泛型方法