【JAVA】11 泛型

杰西啊杰西

于 2022-10-25 10:59:33 发布

阅读量569

点赞数

分类专栏： Java基础文章标签： java

本文链接：https://blog.csdn.net/qq_43681877/article/details/127509412

版权

Java基础专栏收录该内容

11 篇文章 0 订阅

订阅专栏

https://blog.csdn.net/ChenRui_yz/article/details/122935621

1 泛型

引子

直接使用ArrayList不添加任何限制，则可以添加任意类型
如下面，本来只能保存dog类型，添加cat类型就应该报错，但是这里没有，还是添加成功了

import java.util.ArrayList;
import java.util.Iterator;

public class GenericsExercise01 {
    public static void main(String args[]){
        ArrayList arr1 = new ArrayList();
        Dog dog1=new Dog(1,"大黄");
        Dog dog2 = new Dog(2,"小黑");
        Cat cat1=new Cat(1,"花花");
        arr1.add(dog1);
        arr1.add(dog2);
        arr1.add(cat1);
        Iterator iterator = arr1.iterator();
        while(iterator.hasNext()){
            Object o = iterator.next();
            System.out.println(o);
        }
    }
}

class Dog{
    private int No;
    private String Name;
    Dog(int no,String name){
        this.No=no;
        this.Name=name;
    }

    public int getNo() {
        return No;
    }

    public String getName() {
        return Name;
    }

    public String toString(){
        return "Dog"+this.No+":"+this.Name;
    }
}

class Cat{
    private int No;
    private String Name;

    public Cat(int no, String name) {
        No = no;
        Name = name;
    }

    public int getNo() {
        return No;
    }

    public String getName() {
        return Name;
    }
    public String toString(){
        return "Cat"+this.No+":"+this.Name;
    }
}

如果像下图添加泛型约束，则cat就无法添加到arr1了

ArrayList<Dog> arr1 = new ArrayList<Dog>()

在这里插入图片描述

泛型的理解和好处
1. 编译时，检查添加元素的类型，提高了安全性
2. 减少了类型转换次数，提高效率
3. 不再提示编译警告
泛型介绍

public class GenericsExercise02 {
    public static void main(String[] args) {
        //注意，特别强调： E 具体的数据类型在定义 Person 对象的时候指定,即在编译期间，就确定 E 是什么类型
        Person<String> person = new Person<String>("teacher");
        person.show(); //String
        /*你可以这样理解，上面的 Person 类
                class Person {
                    String s ;//E 表示 s 的数据类型, 该数据类型在定义 Person 对象的时候指定,即在编译期间，就确定 E
                    是什么类型
                    public Person(String s) {//E 也可以是参数类型
                        this.s = s;
                    }
                    public String f() {//返回类型使用 E
                        return s;
                    }
                }
        */
        Person<Integer> person2 = new Person<Integer>(100);
        person2.show();//Integer
        /*
        class Person {
            Integer s ;//E 表示 s 的数据类型, 该数据类型在定义 Person 对象的时候指定,即在编译期间，就确定 E
            是什么类型
            public Person(Integer s) {//E 也可以是参数类型
            this.s = s;
            }
            public Integer f() {//返回类型使用 E
            return s;
            }
        }
        */
    }
}
//泛型的作用是：可以在类声明时通过一个标识表示类中某个属性的类型，
// 或者是某个方法的返回值的类型，或者是参数类型
class Person<E> {
    E s;//E 表示 s 的数据类型, 该数据类型在定义 Person 对象的时候指定,即在编译期间，就确定 E 是什么类型

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

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

    public void show() {
        System.out.println(s.getClass());//显示 s 的运行类型
    }
}

泛型的语法
1. 声明

interface 接口<T>{}
class类<K,V>{}
1) 其中，T，K，V不代表值，而是代表类型
2）任意字母都可以，常是使用T表示，是type的缩写

实例化：要在类名后面指定类型参数的值（类型）

List<String>strList = new ArrayList<String>();
Iterator<Customer> iterator = customers.iterator();

使用举例

import java.util.HashSet;

public class GenericsExercises03 {
    public static void main(String args[]){
        HashSet<Student> students = new HashSet<Student>();
        students.add(new Student("jack",1));
        students.add(new Student("tom",2));
        students.add(new Student("jessy",3));

        for(Student student:students){
            System.out.println(student);
        }
    }
}

class Student{
    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString(){
        return "name:"+this.name+"\t"+"age:"+this.age;
    }
}

泛型注意事项

在这里插入图片描述
在实际开发中，编译器会根据类型进行判断

//不简写
ArrayList<Integer>list = new ArrayList<Integer>();
//简写
ArrayList<Integer>list = new ArrayList<>();

泛型通配符

本质上这些个都是通配符，没啥区别，只不过是编码时的一种约定俗成的东西。比如上述代码中的 T ，我们可以换成 A-Z 之间的任何一个字母都可以，并不会影响程序的正常运行，但是如果换成其他的字母代替 T ，在可读性上可能会弱一些。spring framework三大基础知识点，泛型，反射，动态代理。通常情况下，T，E，K，V，？是这样约定的：

E - Element (在集合中使用，因为集合中存放的是元素)
T - Type（Java 类），T代表在调用时的指定类型。会进行类型推断。声明泛型类或泛型方法。
K - Key（键）
V - Value（值）
N - Number（数值类型）
？ - 表示不确定的java类型，是类型通配符，代表所有类型。？不会进行类型推断。使用泛型类或泛型方法

2 自定义泛型类

基本语法

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

普通成员可以使用泛型（属性、方法）
使用泛型的数组，不能初始化
静态方法中不能使用类的泛型
泛型类的类型，是在创建对象时确定的（因为创建对象时，需要制定确定类型）
如果在创建对象时，没有制定类型，默认为Object

举例：

import java.util.Arrays;

public class GenericsClass {
    public static void main(String[] args){
        //T=Double, R=String, M=Integer
        Tiger<Double,String,Integer> g = new Tiger<>("john");
        g.setT(10.9); //OK
        //g.setT("yy"); //错误，类型不对
        System.out.println("g1=" +g);
        Tiger g2 = new Tiger("john~~");//OK T=Object R=Object M=Object
        g2.setT("yy"); //OK ,因为 T=Object "yy"=String 是 Object 子类
        System.out.println("g2=" + g2);
        Tiger g3 = new Tiger("yes",1,99);
        System.out.println(g3);
    }
}

//老韩解读
//1. Tiger 后面泛型，所以我们把 Tiger 就称为自定义泛型类
//2, T, R, M 泛型的标识符, 一般是单个大写字母
//3. 泛型标识符可以有多个.
//4. 普通成员可以使用泛型 (属性、方法)
//5. 使用泛型的数组，不能初始化
//6. 静态方法中不能使用类的泛型
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;
    }
    public Tiger(String name, R r, M m, T t) {//构造器使用泛型
        this.name = name;
        this.r = r;
        this.m = m;
        this.t = t;
    }
//因为静态是和类相关的，在类加载时，对象还没有创建
//所以，如果静态方法和静态属性使用了泛型，JVM 就无法完成初始化
// static R r2;
// public static void m1(M m) {
//
// }
//方法使用泛型
public String getName() {
    return name;
}
    public void setName(String name) {
        this.name = name;
    }
    public R getR() {
        return r;
    }
    public void setR(R r) {//方法使用到泛型
        this.r = r;
    }
    public M getM() {//返回类型可以使用泛型.
        return m;
    }

    public void setM(M m) {
    this.m = m;
    }
    public T getT() {
        return t;
    }
    public void setT(T t) {
        this.t = t;
    }
    @Override
    public String toString() {
        return "Tiger{" +
                "name='" + name + '\'' +
                ", r=" + r +
                ", m=" + m +
                ", t=" + t +
                ", ts=" + Arrays.toString(ts) +
                '}';
    }
}

3 自定义泛型接口

在这里插入图片描述

基本语法

interface 接口名<T,R...>{
    
}

接口中，静态成员也不能使用泛型
泛型接口的类型，在继承接口或者实现接口时确定
没有制定类型，默认为Object

public class CustomInterfaceGeneric {

}

interface IUsb<U,R>{
    int n=10;   //不能使用 U name
    //普通方法中，可以使用接口泛型
    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在继承IUsb接口时，指定了U为String R为Double
//在实现IUsb接口方法时，使用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){

    }
}

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){

    }
}

class CC implements IUsb{ //建议写成：class CC implements IUsb<Object,Object> 
    @Override
    public Object get(Object o) {
        return null;
    }
    @Override
    public void hi(Object o) {}
    @Override
    public void run(Object r1, Object r2, Object u1, Object u2) {}
}

4 自定义泛型方法

基本语法

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

}

泛型方法，可以定义在普通类中，也可以定义在泛型类中
当泛型方法被调用时，类型会确定
public void it(E e){}，修饰符后面没有<T,R,…>，则eat方法不是泛型方法，而是使用了泛型

案例：

import java.util.ArrayList;

public class CustomGenericMethod {
    public static void main(String[] args) {
        Car car = new Car();
        car.fly("宝马", 100);//当调用方法时，传入参数，编译器，就会确定类型
        System.out.println("=======");
        car.fly(300, 100.1);//当调用方法时，传入参数，编译器，就会确定类型
//测试
//T->String, R-> ArrayList
        Fish<String, ArrayList> fish = new Fish<>();
        fish.hello(new ArrayList(), 11.3f);
    }
}

class Car{
    //1. 普通方法
    public void run(){

    }
    //2. 泛型方法
    public <T,R> void fly(T t,R r){
        System.out.println(t.getClass());
        System.out.println(r.getClass());
    }
}

class Fish<T, R> {//泛型类

    public void run() {//普通方法
    }

    public <U, M> void eat(U u, M m) {//泛型方法
    }

    //说明
    //1. 下面 hi 方法不是泛型方法
    //2. 是 hi 方法使用了类声明的 泛型
    public void hi(T t) {
    }

    //泛型方法，可以使用类声明的泛型，也可以使用自己声明泛型
    public <K> void hello(R r, K k) {
        System.out.println(r.getClass());//ArrayList
        System.out.println(k.getClass());//Float
    }
}

class Apple<T, R, M> {//自定义泛型类
    public <E> void fly(E e) { //泛型方法
        System.out.println(e.getClass().getSimpleName());
    }
    //public void eat(U u) {}//错误，因为 U 没有声明
    public void run(M m) {
    } //ok
}