Java基础篇-泛型

elkz

已于 2022-05-24 09:47:16 修改

阅读量392

点赞数 1

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

于 2022-05-14 17:30:22 首次发布

本文链接：https://blog.csdn.net/XXXanghongin/article/details/124769736

版权

Java基础篇专栏收录该内容

7 篇文章 0 订阅

订阅专栏

1.分析使用传统方法的问题

不能对加入到集合ArrayList中的数据类型进行约束（不安全）
遍历的时候，需要进行类型转换，如果集合中的数据量较大，会对效率造成影响

2. 泛型的理解和好处

编译时，检查添加元素的类型，提高了安全性
减少了类型转换的次数，提高了效率
不再提示编译警告

3. 泛型介绍

泛型又称参数化类型，是JDK5.0出现的新特性，解决数据类型的安全性问题
在类声明或实例化时只要指定好需要的具体的类型即可
Java泛型可以保证如果程序在编译时没有发出警告，运行时就不会产生ClassCastException异常，同时代码更加简洁，健壮
泛型的作用是：可以在类声明时通过一个标识表示类中某个属性的特性，或者是某个方法的返回值的类型，或者是参数类型

public class box1 {
    public static void main(String[] args) {
        Person<String> person1 = new Person<>("hello,world");
        person1.show();//显示person1的运行类型
        Person<Integer> person2 = new Person<>(2);
        person2.show();//显示person2的运行类型
    }
}

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 的运行类型
    }
}

运行结果：

class java.lang.String
class java.lang.Integer

4.泛型的语法

4.1 泛型的声明

interface 接口<T>{}和class<k,v>{}
其中，T，V，K，不代表值，而是表示类型
任意字母都可以，常用T表示，是Type的缩写

4.2 泛型的实例化

要在类后面指定类型参数的值（类型）。如：

Person<String> person1 = new Person<>("hello,world");

Iterator<Customer>iterator = customers.iterator();

4.3 泛型使用的注意事项和细节

interface List<T>{},public class HashSet<E>{}....等等，T，E，只能是引用类型
在给泛型指定具体类型后，可以传入该类型或其子类类型
如果我们这样写 List list = new ArrayList(); 默认给他的泛型是Object

public class GenericDetail {
    public static void main(String[] args) {
//1.给泛型指向数据类型是，要求是引用类型，不能是基本数据类型
        List<Integer> list = new ArrayList<Integer>(); //OK
        //List<int> list2 = new ArrayList<int>();//错误
//2. 在给泛型指定具体类型后，可以传入该类型或者其子类类型
        Pig<A> aPig = new Pig<A>(new A());
        aPig.f();
        Pig<A> aPig2 = new Pig<A>(new B());
        aPig2.f();
//3. 泛型的使用形式
        ArrayList<Integer> list1 = new ArrayList<Integer>();
        List<Integer> list2 = new ArrayList<Integer>();
//在实际开发中，我们往往简写
//编译器会进行类型推断, 推荐使用下面写法
        ArrayList<Integer> list3 = new ArrayList<>();
        List<Integer> list4 = new ArrayList<>();
        ArrayList<Pig> pigs = new ArrayList<>();
//4. 如果是这样写 泛型默认是 Object
        ArrayList arrayList = new ArrayList();//等价 ArrayList<Object> arrayList = new ArrayList<Object>();
        
    }
}
class A {}
class B extends A {}
class Pig<E> {//
    E e;
    public Pig(E e) {
        this.e = e;
    }
    public void f() {
        System.out.println(e.getClass()); //运行类型
    }
}

5. 自定义泛型

5.1 自定义泛型类

class 类名<T,R....>{} 可以有多个泛型成员
普通成员可以使用泛型（属性，方法..）
使用泛型的数组不能初始化，因为数组在 new 不能确定 T 的类型，就无法在内存开空间
静态方法（类方法）中不能使用类的泛型，因为静态是和类相关的，在类加载时，对象还没有创建，所以，如果静态方法和静态属性使用了泛型，JVM 就无法完成初始化
泛型类的类型，是在创建对象时确定的（因为创建对象时，需要指定类型）
如果在创建对象时没有指定类型，默认为Object

public class GenericDetail_ {
    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(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);
    }
}
//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) +
                '}';
    }
}

5.2 自定义泛型接口

基本语法 interface 接口名 <T,R..>
接口中，静态成员也不能使用泛型（和泛型类一样）
泛型接口的类型，在继承接口或实现接口时确定
没有指定类型，默认为Object

//在继承接口 指定泛型接口的类型
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) {
    }
}
//没有指定类型，默认为 Object
//建议直接写成 IUsb<Object,Object>
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) {
    }
}
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;
    }
}

5.3 自定义泛型方法

基本语法：修饰符<T,R...>返回类型方法名（参数列表）{}
泛型方法，可以定义在普通类中，也可以定义在泛型类中
当泛型方法被调用时，类型会确定

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> 就是泛型，是fly自己声明的
    //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
    }
}

elkz

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java基础篇-泛型

1.分析使用传统方法的问题不能对加入到集合ArrayList中的数据类型进行约束（不安全）遍历的时候，需要进行类型转换，如果集合中的数据量较大，会对效率造成影响2. 泛型的理解和好处编译时，检查添加元素的类型，提高了安全性减少了类型转换的次数，提高了效率不再提示编译警告3. 泛型介绍泛型又称参数化类型，是JDK5.0出现的新特性，解决数据类型的安全性问题在类声明或实例化时只要指定好需要的具体的类型即可 Java泛型可以保证如果程序在编译时没有发出警告，运行时就不会产..
复制链接

扫一扫