java~泛型

_CYX_

已于 2024-08-07 14:47:16 修改

阅读量800

点赞数 30

分类专栏： Java 文章标签： java 开发语言

于 2024-08-07 14:33:09 首次发布

本文链接：https://blog.csdn.net/qq_65186476/article/details/140990169

版权

Java 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

泛型

检查添加元素的类型

减少了类型转换的次数，直接对这个类型进行遍历，例如arraylist<>()

public class Main {
    public static void main(String[] args) {
        Person<String> person1 = new Person<>("xiaoming");
        Person<Integer> person2 = new Person<>(100);
    }
}

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

    public Person(E s) {
        this.s = s;
    }
    public E f() {
        return s;
    }
}

泛型的声明

        interface接口 {} 和class 类<K, V...> {}
        例如： List，ArrayList
        说明：
                其中，T，K，V不代表值，而是代表类型
                任意字母都行，常用T表示。

泛型的实例化

需要在类名后面指定类型参数的值(类型)，例如：

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

迭代器取值
Iterator< Customer> iterator = customers.iterator()

泛型的使用细节

1、给泛型指定数据类型时，要求是引用类型，不能是基本数据类型，自动装箱。

2、在给泛型指定具体类型后，可以传入该类型或该类型的子类。

3、右边的尖括号可以省略，推荐 List< String > strList = new ArrayList<>();

4、如果不指明泛型类型，默认为 Object 。

5、静态方法和静态属性不能使用泛型。因为静态和类相关，在类加载时，对象还没有创建，JVM 无法实现初始化。

自定义泛型类

普通成员可以使用泛型(属性，方法)
使用泛型的数组不可初始化
静态方法不能使用类的泛型，静态只和类有关，类加载时，对象还没创建
泛型类的类型，是在创建对象时确定的（因为创建对象时，需要指定确定类型)
如果在创建对象时，没有指定类型，默认为Object，推荐写Object

class Person<E, T> {
    E s;
    T[] ts;//不能初始化，因为数组在new的时候不能确定T的类型，无法在内存开辟空间

    public Person(E s) {
        this.s = s;
    }
    public E f() {
        return s;
    }

    public Person(E s, T[] ts) {
        this.s = s;
        this.ts = ts;
    }
}

自定义泛型接口

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

自定义泛型方法

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

public class CustomMethodGeneric {
    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 {//普通类

    public void run() {//普通方法
    }
    //说明 泛型方法
    //1. <T,R> 就是泛型
    //2. 是提供给 fly使用的
    public <T, R> void fly(T t, R r) {//泛型方法
        System.out.println(t.getClass());//String
        System.out.println(r.getClass());//Integer
    }
}

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
    }

}

泛型的继承和通配符

泛型不具备继承性

< ?> ：表示支持任意泛型类型
< ? extends A >：支持A类及A类的子类，规定了泛型的上限
< ? 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);
        }
    }

}

class AA {
}

class BB extends AA {
}

class CC extends BB {
}