【JavaSE】14-泛型

最新推荐文章于 2023-03-27 16:10:52 发布
最新推荐文章于 2023-03-27 16:10:52 发布
阅读量262 收藏
点赞数 1
分类专栏： # JavaSE 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Sihang_Xie/article/details/124806836
版权
本文深入探讨了Java中的泛型，包括为什么需要泛型、如何在集合中使用泛型以及泛型类、泛型方法的定义和使用。通过实例展示了泛型在提高代码安全性和减少类型转换异常方面的作用，并介绍了泛型在继承、通配符使用上的规则。最后，给出了一个泛型类DAO的实现，用于保存、获取、更新和删除对象。
摘要由CSDN通过智能技术生成

十四、 泛型

14.1 为什么要有泛型

泛型就是一个标签。在集合的学习中，一个集合中什么类型的数据都可以放，这其实是不好的。因此在 JDK 1.5 中新增了泛型这个新特性，用来规定集合中元素的类型。

通过实际代码来体会有/无泛型的区别：

1.在集合中没有使用泛型的情况

@Test
public void test1() {

    //1.在集合中没有使用泛型的情况
    ArrayList list = new ArrayList();
    //需求：存放学生的成绩
    list.add(76);
    list.add(65);
    list.add(96);
    list.add(89);
    //问题一：类型不安全
    list.add("Tom");//老师手抖，不小心添加了其他类型的数据进去，但是编译是不会报错的

    //遍历输出
    for (Object score : list) {
        //问题二：强转时，有可能出现ClassCastException
        int stuScore = (int) score;
        System.out.println(stuScore);
    }
}

输出：

76
65
96
89

java.lang.ClassCastException

这段代码问题就出在第 12 行代码上，由于没有泛型，集合中没有作类型检查，很容易造成类型不安全问题和类型转换异常。

14.2 在集合中使用泛型

14.2.1 泛型使用

  • 泛型使用一对尖括号来表示 <> 。尖括号中放入你想规定的类型。
  • 集合接口或集合类在 JDK 5.0 时都修改为带泛型的结构。
  • 在实例化集合类时，它可以指明具体的泛型类型。
  • 指明完以后，在集合类或接口中，凡是定义类或接口时，内部结构使用到类的泛型的位置，都指定为实例化的泛型类型。如：add(E e) 方法----->实例化以后，add(Integer e) 。
  • 注意点：泛型的类型必须是类，不能是基本数据类型。需要用到基本数据类型时，用其包装类替换。
  • 如果实例化时，没有指明泛型的类型，默认类型为 java.lang.Object 类型。

例子如下代码所示：

1.在集合中使用泛型的情况：以ArrayList为例

@Test
public void test2() {

    //1.在集合中使用泛型的情况：以ArrayList为例
    ArrayList<Integer> list = new ArrayList<Integer>();
    //需求：存放学生的成绩
    list.add(76);
    list.add(65);
    list.add(96);
    list.add(89);
    //编译时就会进行类型检查，保证数据的安全
//    list.add("Tom");

    //遍历输出
    for (Integer score : list) {
        int stuScore = score;
        System.out.println(stuScore);
    }
}

输出：

76
65
96
89

image-20220416144137767

在 IDEA 中可以看到，在声明了泛型为包装类 Integer 后，add() 方法中要求的数据类型就马上变成了 Integer 。并且试图往集合中加入 String 类型的 “Tom” 时，编译器马上就标红报错。

2.在集合中使用泛型的情况：以 HashMap 为例

@Test
public void test3() {
    //2.在集合中使用泛型的情况：以 HashMap 为例
    Map<String, Integer> map = new HashMap<>();
    //需求：存放学生的姓名和对应的成绩
    map.put("Tom", 78);
    map.put("Jerry", 87);
    map.put("Jack", 65);
    map.put("Rick", 93);
    //编译时就会进行类型检查，保证数据的安全
//    map.put(123, "ABC");

    //转换成entrySet
    Set<Map.Entry<String, Integer>> entrySet = map.entrySet();//泛型的嵌套
    //遍历输出
    Iterator<Map.Entry<String, Integer>> iterator = entrySet.iterator();
    while (iterator.hasNext()) {
        Map.Entry<String, Integer> entry = iterator.next();
        String name = entry.getKey();
        Integer score = entry.getValue();
        System.out.println(name + "------>" + score);
    }
}

输出：

Tom------>78
Rick------>93
Jerry------>87
Jack------>65

14.3 自定义泛型结构

掌握自定义 3 个泛型结构：泛型类、泛型接口；泛型方法。

14.3.1 自定义泛型类

体会：当指明泛型的类之后，原本很多比较的方法、判断的方法都不需要再先去 instanceof 是什么方法了。让操作更简便了。

1.例子

① 带泛型结构的 Order 类

public class Order<T> {
    //属性
    String orderName;
    int orderId;
    //类的内部结构就可以使用类的泛型
    T orderT;//作为属性T，但是T是等到实例化才传入的参数

    //构造器
    public Order() {
    }

    //泛型T作为构造器形参
    public Order(String orderName, int orderId, T orderT) {
        this.orderName = orderName;
        this.orderId = orderId;
        this.orderT = orderT;
    }

    //属性orderT的get方法，返回T类型的orderT
    public T getOrderT() {
        return orderT;
    }

    //属性orderT的set方法，传入T类型的orderT
    public void setOrderT(T orderT) {
        this.orderT = orderT;
    }

    //重写toString方法
    @Override
    public String toString() {
        return "Order{" +
                "orderName='" + orderName + '\'' +
                ", orderId=" + orderId +
                ", orderT=" + orderT +
                '}';
    }
}

② 测试：

@Test
public void test2() {
    //如果实例化时，没有指明泛型的类型，默认类型为java.lang.Object类型
    //如果定义了类是带泛型的，建议在实例化时要指明类的泛型
    Order order = new Order();
    order.setOrderT(123);
    System.out.println(order.getOrderT());
    order.setOrderT("AA");
    System.out.println(order.getOrderT());

    //实例化时指明类的泛型
    Order<String> order1 = new Order<>("orderAA", 1001, "order:AA");
    order1.setOrderT("AA:Hello");
    System.out.println(order1.getOrderT());
}

image-20220418204820942

输出：

123
AA
AA:Hello

在没有指明泛型的类型之前，setOrder(Object obj) 可以设置任何类型的数据。但是当指明了泛型为 之后，自定义类 Order 中所有是泛型 T 的地方都变成了 String 类。如属性 orderT 变成 String 类。

2.自定义泛型类的继承

有两种情况：
泛型类的继承
子类指明泛型类
子类仍是泛型类

① 子类指明泛型类

public class SubOrder extends Order<Integer>{//SubOrder已经不是泛型类了
}

image-20220418213416567

由于子类在继承带泛型的父类时，指明了泛型类型。则实例化子类对象时，不需要指明泛型。

② 子类仍是泛型类

public class SubOrder<T> extends Order<T>{//SubOrder<T>仍然是泛型类
}

@Test
public void test3() {
    SubOrder<String> sub1 = new SubOrder<>();
    sub1.setOrderT("Tom");
}

此外，泛型继承还有下列几种情况：
泛型类的继承
子类不保留父类的泛型
子类保留父类的泛型 泛型子类
没有类型 擦除
具体类型
全部保留
部分保留

结论：子类必须是”富二代“，子类除了指定或保留父类的泛型，还可以增加自己的泛型。

image-20220419085534070

image-20220419085601120

3.自定义泛型类注意点

  • 可能有多个参数，格式为：<E1, E2, E3>。如 Map 接口中的 <K, V> 。

  • 类的构造器不需要添加 。正确的：public GenericClass(){}；错误的：public GenericClass(){}。

  • 实例化以后，操作原来泛型位置的结构必须与指定的泛型类型一致。

  • 泛型不同的引用不能相互赋值。如下代码所示：

    ArrayList<String> list1 = new ArrayList<String>();
ArrayList<Integer> list2 = new ArrayList<Integer>();
//list1 = list2;	//报错！泛型不同的引用不能相互赋值

  • 泛型要使用的话，要么一路都用，要么一路都不要用。

  • 如果泛型结构是一个接口或抽象类，则不可创建泛型类的对象。

  • 从 JDK 7 开始，泛型定义就简化成：

    ArrayList<Integer> = new ArrayList<>();

  • 在静态方法中不能使用类的泛型。原因是：指定泛型是在创建对象的时候才指明泛型的类，但静态方法是随着类加载而加载的，早于对象的创建。相当于泛型的类型还没指定呢，静态方法中就要用了，这肯定是不行的。

  • 异常类不能声明为泛型类。

    //异常类不能使用泛型结构，会报错！
//public class MyException<T> extands Exception{
//}

  • 如果想创建泛型的数组，不能使用 new T[] 。但是可以：

    T[] elements = (T[])new Object[capacity];

14.3.2 自定义泛型方法

  • 泛型方法可以声明为 static 的。原因：泛型参数是在调用方法时确定的。并非在实例化类时确定。

以下不是泛型方法：

public interface Collection<E> extends Iterable<E> {
    ...;
    boolean add(E e);//这不是泛型方法
    ...;
}

真正的泛型方法如下所示：

public interface Collection<E> extends Iterable<E> {
    ...;
    <T> T[] toArray(T[] a);//泛型<T>与类(或接口)中的<E>不一致才叫泛型方法
    ...;
}

总结：什么才叫泛型方法？就是在方法中出现了泛型的结构，且泛型参数与类(或接口) 的泛型参数不一致的，才叫泛型方法。换句话说，泛型方法所属的类是不是泛型类都没有关系。

14.3.3 泛型类和泛型方法的使用情景

  • 比如在DAO: data(base) access object 数据访问对象中，作为操纵不同表的通用类，可以声明为泛型类，具体到操作哪一张表的时候再指明泛型的具体类型。

14.4 泛型在继承上的体现

14.4.1 没有子父类关系

结论：如果类 A 是类 B 的父类，那么 G 类和 G 类没有子父类关系，二者是并列关系，不具有多态性。

例子：

Object 类是 String 类的父类，下面的操作体现了多态性，是可以的：

@Test
public void test1() {
    Object obj = null;
    String str = null;
    obj = str;
    
    Object[] arr1 = null;
    String[] arr2 = null;
    arr1 = arr2;
}

但是，List 类和 List 类并没有子父类关系，不具备多态性，因此下面的操作是错误的，编译不通过。

@Test
public void test1() {
	List<Object> list1 = null;
    List<String> list2 = new ArrayList();
//    list1 = list2;//报错！编译不通过
}

【原因】反证法、逆向思维：假设 list1 = list2 ，此时栈中的 list1 的指针指向堆中的 list2 的 String 类型的 ArrayList 集合。如果此时执行 list1.add(123) ，这样就会往 String 类型的 ArrayList 集合中添加 int 类型的元素。导致出错，相当于泛型这个结构白设计了。

14.4.2 有子父类关系

结论：如果类 A 是类 B 的父类，那么 A 类和 B 类是子父类关系，具有多态性。

例子：

List 接口是 ArrayList 的父接口，因此具有子父类关系，具备多态性，下面的操作是合法的：

@Test
public void test2() {
    List<String> list1 = null;
    ArrayList<String> list2 = null;
    list1 = list2;

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

总结：两个带泛型结构的类之间是否具有子父类关系，取决于尖括号<>左边的类，而不取决于尖括号<>中的类。

14.5 通配符的使用

14.5.1 使用方法和注意点

如上一节所述，List 类和 List 类并没有子父类关系，不具备多态性。因此，如果要写方法的话就要写很多同名的重载方法，效率比较低。为了提供 List 类和 List 的通用父类，就出现了通配符 ? 。

例子：

@Test
public void test3() {
    List<Object> list1 = null;
    List<String> list2 = null;

    List<?> list = null;//通配符<?>作为List<Object>类和List<String>类的通用父类
    list = list1;
    list = list2;

    show(list1);//show(List<?> list)方法见下方代码
    show(list2);
}

//遍历方法
public void show(List<?> list) {//通配符作为方法形参是非常方便的，相当于通用父类
    Iterator<?> iterator = list.iterator();
    while (iterator.hasNext()) {
        Object obj = iterator.next();
        System.out.println(obj);
    }
}

结论：类 A 是类 B 的父类，那么 G 类和 G 类没有子父类关系，二者的共同父类是：G<?> 。

注意点：使用通配符后，只能读不能写，除了写入 null 。

@Test
public void test4() {
    List<String> list1 = new ArrayList<>();
    list1.add("AA");
    list1.add("BB");
    list1.add("CC");

    List<?> list = null;
    list = list1;
    //通配符的写操作：是不行的
    list.add("DD");
    list.add(null);//唯一的例外，但也没什么意义
    //通配符的读操作
    Object o = list.get(0);
    System.out.println(o);
}

输出：

AA

14.5.2 有限制条件的通配符的使用

结论：如果将 <?> 比作的范围是 (-∞, +∞) ，那么：

  • <? extends A> 相当于 <= A 类，范围是 (-∞, A]；
  • <? super A> 相当于 >= A 类，范围是 [A, +∞) ；

例子：

创建了父类 Person 和子类 Student 。

@Test
public void test5() {
    List<? extends Person> list1 = null;
    List<? super Person> list2 = null;

    List<Student> list3 = null;//<A
    List<Person> list4 = null;//=A
    List<Object> list5 = null;//>A

    //<? extends Person>
    list1 = list3;//<A
    list1 = list4;//=A
//    list1 = list5;//报错！编译不通过

    //<? super Person>
//    list2 = list3;//报错！编译不通过
    list2 = list4;//=A
    list2 = list5;//>A
}

2.有限制通配符的读写

一个原则：子类可以赋值给父类；父类不能赋值给子类。

例子1：读操作

@Test
public void test5() {
    List<? extends Person> list1 = null;
    List<? super Person> list2 = null;

    List<Student> list3 = new ArrayList<>();
    List<Person> list4 = new ArrayList<>();
    List<Object> list5 = new ArrayList<>();

    //读数据
    list1 = list3;
    Person p = list1.get(0);
//    Student s = list1.get(0);//报错，list1可能是Person类，父类不能赋给子类
    list2 = list4;
    Object o = list2.get(0);//此处只能写Object了
}

例子2：写操作

//写操作
list1.add(new Student());//报错！list1是(-∞, A]，可能有比Student类还小的子类，Student作为父类不能赋给子类
list2.add(new Person());//可以加
list2.add(new Student());//可以加
list2.add(new Object());//报错！list2是[A, +∞)，list2有可能是Person类，作为Person父类的Object类不能赋给子类Person

总之记住一句话：子类可以赋值给父类；父类不能赋值给子类。

14.6 泛型应用练习

题目：

定义个泛型类 DAO，在其中定义一个Map 成员变量，Map 的键为 String 类型，值为 T 类型。

分别创建以下方法：
public void save(String id,T entity)： 保存 T 类型的对象到 Map 成员变量中
public T get(String id)：从 map 中获取 id 对应的对象
public void update(String id,T entity)：替换 map 中key为id的内容,改为entity 对象
public List list()：返回 map 中存放的所有 T 对象
public void delete(String id)：删除指定 id 对象

定义一个 User 类：
该类包含：private成员变量（int类型）id、age；（String 类型）name。

创建 DAO 类的对象， 分别调用其 save、get、update、list、delete 方法来操作 User 对象，使用 Junit 单元测试类进行测试。

我的首次答案：

① 泛型类 DAO

public class DAO<T> {

    //属性
    private Map<String, T> map;//键为String类型，值为T类型

    //构造器
    public DAO() {
    }

    /**
     * @param id
     * @param entity
     * @return {}
     * @Author: Sihang Xie
     * @Description: 保存 T 类型的对象到 Map 成员变量中
     * @Date: 2022/4/19 18:23
     */
    public void save(String id, T entity) {
        //判断Map是否为空，为空创建Map
        if (map == null) {
            map = new HashMap<String, T>();
        }
        //保存操作
        map.put(id, entity);
    }

    /**
     * @param id
     * @return {{@link T}}
     * @Author: Sihang Xie
     * @Description: 从 map 中获取 id 对应的对象
     * @Date: 2022/4/19 18:37
     */
    public T get(String id) {
        return map.get(id);
    }

    /**
     * @param id
     * @param entity
     * @return {}
     * @Author: Sihang Xie
     * @Description: 替换 map 中key为id的内容,改为entity 对象
     * @Date: 2022/4/19 18:39
     */
    public void update(String id, T entity) {
        boolean isExist = map.containsKey(id);
        if (isExist) {
            map.put(id, entity);
        } else {
            throw new RuntimeException("你所查找的id不存在");
        }
    }

    /**
     * @param
     * @return {{@link List<T>}}
     * @Author: Sihang Xie
     * @Description: 返回 map 中存放的所有 T 对象
     * @Date: 2022/4/19 18:44
     */
    public List<T> list() {
        //把Map转换成List
        Set<Map.Entry<String, T>> entrySet = map.entrySet();
        Iterator<Map.Entry<String, T>> iterator = entrySet.iterator();
        //创建用来存放map中T对象的List
        List<T> list = new ArrayList<>();
        //一个一个取出来放进List里
        while (iterator.hasNext()) {
            Map.Entry<String, T> entry = iterator.next();
            T value = entry.getValue();
            list.add(value);
        }
        return list;
    }

    /**
     * @param id
     * @return {}
     * @Author: Sihang Xie
     * @Description: 删除指定 id 对象
     * @Date: 2022/4/20 9:03
     */
    public void delete(String id) {
        T t = map.remove(id);
        System.out.println("该删除的对象为：" + t);
    }

    @Override
    public String toString() {
        return "DAO{" +
                "map=" + map +
                '}';
    }
}

② User 类：

public class User {
    private int id;
    private int age;
    private String name;

    public User() {
    }

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

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
    
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        User user = (User) o;

        if (id != user.id) return false;
        if (age != user.age) return false;
        return name != null ? name.equals(user.name) : user.name == null;
    }

    @Override
    public int hashCode() {
        int result = id;
        result = 31 * result + age;
        result = 31 * result + (name != null ? name.hashCode() : 0);
        return result;
    }
}

测试：

@Test
public void test1() {
    //创建DAO类的对象
    DAO<User> dao = new DAO<>();
    //创建User类的对象
    User u1 = new User(1001, 23, "Rick");
    User u2 = new User(1002, 12, "Jerry");
    User u3 = new User(1003, 36, "Amy");
    User u4 = new User(1004, 45, "Tom");

    //save()方法测试
    dao.save("1001", u1);
    dao.save("1002", u2);
    dao.save("1003", u3);
    dao.save("1004", u4);
    System.out.println("原始：" + dao);

    //get()方法测试
    User u = dao.get("1002");
    System.out.println("id=1002的value值为：" + u);

    //update()方法测试
    dao.update("1003", new User(1003, 51, "Henry"));
    System.out.println("update后：" + dao);

    //list()方法测试
    List<User> list = dao.list();
    System.out.println("转换成list后：" + list);

    //delete()方法测试
    dao.delete("1004");
    System.out.println("删除后：" + dao);
}

输出：

原始：DAO{map={1004=User{id=1004, age=45, name='Tom'}, 1003=User{id=1003, age=36, name='Amy'}, 1002=User{id=1002, age=12, name='Jerry'}, 1001=User{id=1001, age=23, name='Rick'}}}
id=1002的value值为：User{id=1002, age=12, name='Jerry'}
update后：DAO{map={1004=User{id=1004, age=45, name='Tom'}, 1003=User{id=1003, age=51, name='Henry'}, 1002=User{id=1002, age=12, name='Jerry'}, 1001=User{id=1001, age=23, name='Rick'}}}
转换成list后：[User{id=1004, age=45, name='Tom'}, User{id=1003, age=51, name='Henry'}, User{id=1002, age=12, name='Jerry'}, User{id=1001, age=23, name='Rick'}]
该删除的对象为：User{id=1004, age=45, name='Tom'}
删除后：DAO{map={1003=User{id=1003, age=51, name='Henry'}, 1002=User{id=1002, age=12, name='Jerry'}, 1001=User{id=1001, age=23, name='Rick'}}}
卡皮巴拉不躺平
关注
专栏目录
ArrayList
方兴未艾
09-10 1万+
ArrayList 一、ArrayList简介 1.1ArrayList概述 ArrayList是可以动态增长和缩减的索引序列，它是基于数组实现的List类 封装了一个动态再分配的Object[] 数组 /** * Default initial capacity. *一个类对象都有一个capacity属性，表示它们所封装的Object[]数组的长度，当向ArrayList中添加元素时，该属性值会...
JavaSE--泛型
xiaochengxuyuan1的博客
01-29 291
1. 泛型的引例 1 List list = new ArrayList(); 2 list.add(1022); //向集合中添加一个 Integer 类型的数据 3 list.add("Yadiel"); //向集合中添加一个 String 类型的数据 4 5 //遍历list元素 6 for(int i = 0 ; i < list.size() ; i++){ 7 Object obj = list.get(i); //注意这里每个类型都是 Obj
Java-泛型
oldwangold的博客
08-10 124
1. 集合中的泛型 不使用泛型带来的问题： ADHero（物理攻击英雄） APHero（魔法攻击英雄）都是Hero的子类。 ArrayList默认接受Object类型的对象，所以所有对象都可以放进ArrayList中。所以get(0)返回的类型是Object。 接着，需要进行强制转换才可以得到APHero类型或者ADHero类型。 如果软件开发人员记忆比较好，能记得哪个是哪个，还是可以的。...
自定义泛型类时的注意点 [Java]
m0_57001006的博客
12-15 812
自定义泛型类时的注意点: 泛型类中可能有多个类型参数,此时我们要将多个类型参数放到一个尖括号中,中间使用逗号隔开 public class Demo <T,E,K,V> {} 泛型不同的引用之间不可以相互赋值 ArrayList<String> list1 = null; ArrayList<Integer> list2 = new ArrayList<>(); list1 = list2; //这里编译会出错(list1的泛型为String,li
Java泛型<? extends Person>和<? super Man>的理解
刘伊凡2.0
12-18 1064
首先回顾一下SE5泛型的基本用法 1、用在类级别 public class Person { }//类后面 2、用在方法级别 public String function(){ return "hell genaric"; }//返回值前面 接下来今天的重头戏来了 和 这两个鬼。首先我来构建一个继承关系吧 Person >> Man  >> Boy Person >>
java8源码-javase8-sample:javase8-sample
06-04
#javase8-sample 该项目仅用于学习java8，请随意Fork，更改 #博文地址 所有博客的源代码都能在这里 src/main/java/java8sample Chapter 1: 通往lambda之路_语法篇 Chapter 2: 深入解析默认方法 Chapter 3: 解开...
java8源码-javase8-sample:javase8-sample.git
06-04
#javase8-sample 该项目仅用于学习java8，请随意Fork，更改 #博文地址 所有博客的源代码都能在这里 src/main/java/java8sample Chapter 1: 通往lambda之路_语法篇 Chapter 2: 深入解析默认方法 Chapter 3: 解开...
java基础Day14--泛型+集合
weixin_52114888的博客
02-09 371
1.泛型 1.1 概念 public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>, Deque<E>, Cloneable, java.io.Serializable{} public interface Deque<E> extends Queue<E> {} public interface Queue<E&g
就业班JavaSE--day01 每日作业卷1
08-08
在这个就业班JavaSE的day01每日作业卷1中，主要涉及了以下几个关键知识点： 1. **`this`关键字**： `this`关键字在Java中是一个非常重要的关键字，它用来指代当前对象的引用。当在类的一个方法内，`this`用于区分...
java 获取泛型对象属性值 获取注解内属性值
最新发布
qq_34873006的博客
03-27 1446
java 获取泛型对象属性值 获取注解内属性值。
使用泛型的Map集合案例
a805814077的博客
08-10 2322
HashMap:Map的主要实现类以键值对,允许使用 null键null值
Java自定义泛型类注意点
m0_46306264的博客
01-10 532
泛型的注意事项
Java中的泛型机制
Janik的博客
11-22 574
泛型的概念 所谓泛型，就是允许在定义类、接口时通过一个标识表示类中某个属性的类型或者是某个方法的返回值及参数类型。这个类型参数将在使用时（例如，继承或实现这个接口，用这个类型声明变量、创建对象时）确定（即传入实际的类型参数，也称为类型实参）。 //在集合中使用泛型 ArrayList<Integer> list = new ArrayList<>();//类型推断 list.add(78); list.add(88); list.add(77); list.add(66); //遍历
Java通过反射获取泛型类型信息
justlpf的专栏
01-31 3245
泛型的使用场景就是如上三种，当在类或接口中定义了泛型后，就可以在类或接口中的成员变量、方法参数、方法返回值中也使用泛型；当定义了含有泛型的方法后，就可以在该方法的方法参数、方法返回值和方法内局部变量中使用泛型。要获取泛型信息，必须要注意ParameterizedType类，该类中的getActualTypeArguments()方法可以有效获取泛型信息。我们先创建一个类，该类中正好有含有泛型的成员变量、含有泛型的方法返回值、含有泛型的方法参数。（3）方法返回值的泛型。（2）方法参数的泛型。
12-3 泛型 ---- 自定义范型结构练习
wp_886的博客
02-19 360
12-3 泛型 ---- 自定义范型结构练习 1.定义个泛型类 DAO，在其中定义一个Map 成员变量，Map 的键为 String 类型，值为 T 类型。 分别创建以下方法： public void save(String id,T entity)： 保存 T 类型的对象到 Map 成员变量中 public T get(String id)：从 map 中获取 id 对应的对象 public void update(String id,T entity)：替换 map 中key为id的内容,改为 enti
泛型(JAVA)
有点想法的专栏
01-12 472
文章目录背景概念泛型类自定义泛型类注意不能使用泛型类泛型和继承泛型方法通配符通配符上限和下限泛型方法和类型通配符的区别泛型方法与重载 背景 由上图可知，泛型主要解决两种情况 1.解决元素存储的安全性问题 2.解决获取数据元素时，需要类型强转的问题 概念 所谓泛型:就是允许在定义类、接口时指定类型形参,这个类型形参将在声明变量、创建对象时确定(即传入实际的类型参数,也可称为类型实参)。JDK15改...
获取java类中泛型的Class汇总
热门推荐
qq_34013220的博客
03-16 1万+
一，当前类沿用泛型接口 需要一个属性用来保存泛型的Class,生成对象时通过构造器指定 二，父类是泛型抽象类，当前类继承并指定了父类泛型 getClass()的对象为ProductTemplateFactory.class; getGenericSuperclass()是获取父类的ParameterizedType类型 getActualTypeArgumnets()是获取父类上所有的泛型类型，其中两个泛型我们都是指定了的，因此可以获得两个泛型实际的cla...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

卡皮巴拉不躺平

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值