java基础-泛型

最新推荐文章于 2024-01-03 09:24:08 发布
最新推荐文章于 2024-01-03 09:24:08 发布
阅读量65 收藏
点赞数
分类专栏： java 泛型 文章标签： java 泛型
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jllion/article/details/116160611
版权
java 同时被 2 个专栏收录
62 篇文章 1 订阅
订阅专栏
泛型
1 篇文章 0 订阅
订阅专栏

JavaBase-泛型

为什么要有泛型

  • 泛型：标签

  • 泛型的设计背景

  • 集合容器类在设计阶段/声明阶段不能确定这个容器到底实际存的是什么类型的对象，所以在JDK1.5之前只能把元素类型设计为Object，JDK1.5之后使用泛型来解决。因为这个时候除了元素的类型不确定，其他的部分是确定的，例如关于这个元素如何保存，如何管理等是确定的，因此此时把元素的类型设计成一个参数，这个类型参数叫做泛型。Collection,List,ArrayList 这个就是类型参数，即泛型

  • public interface Collection<E> extends Iterable<E> {
}

  • 泛型的概念

    • 所谓泛型，就是允许在定义类、接口时通过一个标识表示类中某个属性的类型或者更某个方法的返回值及参数类型。这个类型参数将在使用时（例如，继承或实现这个接口，用这个类型声明变量、创建对象时）确定（即传入实际的类型参数，也称为类型实参）
    • 从JDK1.5以后，java引入了“参数化类型（Parameterized type）“的概念，允许我们在创建集合时再指定集合元素的类型，正如：List，这表明该List只能保存字符串类型的对象
    • JDK1.5改写了集合框架中的全部接口和类，为这些接口、类增加了泛型支持，从而可以在声明集合变量、创建集合对象时传入类型实参

在集合中用泛型

  • 集合接口或集合类在jdk5.0都修改为带泛型的结构

  • 实例化集合类对象时，可以指明具体泛型的类型

  • 指明完以后，在集合类或接口中凡是定义类或接口时，内部结构（比如：方法，属性，构造器等）使用到类的泛型的位置，都指定为实例化时的泛型类型

    • 比如在List接口中 add方法，在声明时是add(E e) -->实例化后：add(Integer e)

  • 泛型的类型必须是一个类（不能是基本数据类型），如果要使用到基本数据类型需要使用包装类

  • 如果实例化时，没有指明泛型的类型，默认类型为java.lang.Object

  • 在jdk1.5之前，使用Object根父类来实现定义容器的元素类型

    • 存在的问题

      • 可以添加任意类型的元素，数据类型不安全
      • 在遍历时，容易产生类型转换异常，ClassCastException
    • @Test
public void test() {
    ArrayList list = new ArrayList();
    //需求存放学生成绩
    list.add(78);
    list.add(76);
    list.add(89);
    list.add(60);
    list.add(91);

    //问题一：类型不安全
    list.add("Tom");

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

  • 在jdk1.5之后，增加了泛型的概念

    • 在编译时就保证了容器元素的类型，保证了数据类型的安全

    • 遍历时，可以确定元素类型，无需再使用强转

    • //在集合中使用泛型的情况
    @Test
    public void test1(){
        ArrayList<Integer> list = new ArrayList<Integer>();
        //需求存放学生成绩
        list.add(78);
        list.add(76);
        list.add(89);
        list.add(60);
        list.add(91);
        //问题一：类型不安全 ,已经声明了泛型了，再添加其他类型的元素，编译不通过，编译时进行类型检查，保证数据的安全
//        list.add("Tom");
        //遍历时 无需强转
        for(Integer score : list){
            System.out.println(score);
        }
    }

    • 泛型的嵌套

    • @Test
public void test2(){
    Map<String,Integer> map = new HashMap<String, Integer>();
    map.put("Tom",87);
    map.put("Jerry",92);
    map.put("Jack",81);

    //泛型的嵌套
    Set<Map.Entry<String, Integer>> entries = map.entrySet();
    Iterator<Map.Entry<String, Integer>> iterator = entries.iterator();
    while(iterator.hasNext()){
        System.out.println(iterator.next());
    }
}

自定义泛型结构

泛型类，泛型接口

  • 自定义的泛型结构：泛型类，泛型接口，泛型方法

  • 泛型类可能有多个参数，此时应将多个参数一起放在尖括号内。比如：

    • package com.jl.java.base.generic;

/**
 * @author jiangl
 * @version 1.0
 * @date 2021/4/26 14:58
 */
public class MyGeneric<E1,E2,E3> {
    private E1 name;
    private E2 age;
    private E3 address;

    public MyGeneric(E1 name, E2 age, E3 address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }

    public E1 getName() {
        return name;
    }

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

    public E2 getAge() {
        return age;
    }

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

    public E3 getAddress() {
        return address;
    }

    public void setAddress(E3 address) {
        this.address = address;
    }
}

  • 泛型类的构造器如下：public MyGeneric(E1 name, E2 age, E3 address) ；

    • public MyGeneric<E1,E2,E3>(E1 name, E2 age, E3 address) 是错误的

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

  • 泛型不同的引用不能相互赋值

    • 尽管在编译时ArrayList和ArrayList是两种类型，但是，在运行时只有一个ArrayList被加载到JVM中。

  • 泛型如果不指定，将被擦除，泛型对应的类型均按照Object处理，但不等价于Object。注意：泛型要使用一路都用。要不用，一路都不用。

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

  • jdk1.7，泛型的简化操作：ArrayList list = new ArrayList<>();

  • 泛型的指定中不能使用基本数据类型，可以使用包装类替换。

  • 在类/接口上声明的泛型，在本类或本接口中即代表某种类型，可以作为非静态属性的类型、非静态方法的参数类型、非静态方法的返回值类型。但在静态方法中不能使用类的泛型（因为静态方法早于对象的创建，所在类加载时并不能确定泛型类型，所以无法在静态方法中使用泛型）。

  • 异常类不能是泛型的。

  • 不能使用new E[]。但是可以：E[] elements = （E[]) new Object[capacity];

    • 参考：ArrayList源码中声明：Object[] elementData,而非泛型参数类型数组。

  • 父类有泛型，子类可以选择保留泛型也可以选择指定泛型类型

    • 子类不保留父类的泛型：按需实现

      • 没有类型 擦除
      • 具体类型

    • 子类保留父类的泛型：泛型子类

      • 全部保留
      • 部分保留

    • 结论：子类除了指定或保留父类的泛型，还可以增加自己的泛型

    • package com.jl.java.base.generic;

/**
 * @author jiangl
 * @version 1.0
 * @date 2021/4/26 14:43
 */
public class Order<T> {
    String orderName;
    int orderId;
    //类的内部结构可以使用泛型
    T orderT;

    public Order(String orderName, int orderId, T orderT) {
        this.orderName = orderName;
        this.orderId = orderId;
        this.orderT = orderT;
    }

    public T getOrderT() {
        return orderT;
    }

    public void setOrderT(T orderT) {
        this.orderT = orderT;
    }
}

/**
 * 子类不保留父类的泛型,没有指定类型，擦除泛型，使用Object
 */
class ChildOrder extends Order{

    public ChildOrder(String orderName, int orderId, Object orderT) {
        super(orderName, orderId, orderT);
    }
}

/**
 * 子类不保留父类的泛型,指定具体类型
 */
class ChildOrder1 extends Order<Integer>{


    public ChildOrder1(String orderName, int orderId, Integer orderT) {
        super(orderName, orderId, orderT);
    }
}

/**
 * 子类保留父类的泛型:全部保留
 * @param <T>
 */
class ChildOrder2<T> extends Order<T>{

    public ChildOrder2(String orderName, int orderId, T orderT) {
        super(orderName, orderId, orderT);
    }
}

/**
 * 子类保留父类的泛型:全部保留，并增加自己的新的泛型
 * @param <K>
 * @param <T>
 */
class ChildOrder3<K,T> extends Order<T>{

    private K key3;

    public ChildOrder3(String orderName, int orderId, T orderT, K key3) {
        super(orderName, orderId, orderT);
        this.key3 = key3;
    }
}

/**
 * 子类保留父类的泛型:部分保留，并增加自己的新的泛型
 * @param <S>
 * @param <T>
 */
class ChildOrder4<S,T> extends ChildOrder3<String,T>{

    private S key2;

    public ChildOrder4(String orderName, int orderId, T orderT, String key3, S key2) {
        super(orderName, orderId, orderT, key3);
        this.key2 = key2;
    }
}

  • 自定义泛型类或者泛型接口，泛型方法。其中为泛型

    • /**
 * @author jiangl
 * @version 1.0
 * @date 2021/4/26 14:43
 */
public class Order<T> {
    String orderName;
    int orderId;
    //类的内部结构可以使用泛型
    T orderT;

    public Order(String orderName, int orderId, T orderT) {
        this.orderName = orderName;
        this.orderId = orderId;
        this.orderT = orderT;
    }

    public T getOrderT() {
        return orderT;
    }

    public void setOrderT(T orderT) {
        this.orderT = orderT;
    }
}

  • 如果定义了泛型类，实例化没有指明类的泛型，则认为此泛型类型为Object类型（不推荐）

    • 要求如果定义了类是带泛型的，建议实例化时要指明泛型

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

  • /**
 * @author jiangl
 * @version 1.0
 * @date 2021/4/26 14:54
 */
public class SubOrder extends Order<Integer>{
    public SubOrder(String orderName, int orderId, Integer orderT) {
        super(orderName, orderId, orderT);
    }

    public static void main(String[] args) {
        SubOrder subOrder = new SubOrder("order",1,1);
    }
}

  • 如果子类在继承带泛型的父类时，未指明泛型类型。则实例化子类对象时，需要指明泛型

  • /**
 * @author jiangl
 * @version 1.0
 * @date 2021/4/26 14:54
 */
public class SubOrder1<T> extends Order<T>{
    public SubOrder1(String orderName, int orderId, T orderT) {
        super(orderName, orderId, orderT);
    }

    public static void main(String[] args) {
        SubOrder1<Integer> subOrder = new SubOrder1("order",1,1);
    }
}

泛型方法

  • 泛型方法在方法中出现了泛型的结构，泛型方法的泛型参数与类的泛型参数没有任何关系

  • 泛型方法所属的类是否是泛型类，没有关系，不一定

  • 泛型方法，在调用时确定指明泛型的类型。

  • 泛型方法可以是静态的，因为泛型方法的泛型参数是在调用方法时确定的，并非是在实例化时确定的

    • package com.jl.java.base.generic;

import java.util.ArrayList;
import java.util.List;

/**
 * @author jiangl
 * @version 1.0
 * @date 2021/4/26 15:21
 */
public class GenericFuncTest {

    public <J> List<J> get(J[] arr){
        ArrayList<J> list = new ArrayList<J>();
        for(J j : arr){
            list.add(j);
        }
        return list;
    }

    public static void main(String[] args) {
        Integer[] arr = new Integer[]{1,2,3,3,5,1};
        GenericFuncTest genericFuncTest = new GenericFuncTest();
        List<Integer> integers = genericFuncTest.get(arr);
        for(Integer i : integers){
            System.out.println(i);
        }
    }
}

泛型在继承上的体现

  • 如果类A是类B的父类，G和G是不具备子父类关系的

    • public void test1(){
        Object obj = null;
        String str = null;
        obj = str;
        Object[] arr1 = null;
        String[] arr2 = null;
        arr1 = arr2;
        
        List<Object> list1 = null;
        List<String> list2 = null;
        //此时list1和list2的类型不具备子父类关系
//        list1 = list2;
    }

  • 补充：类A是类B的父类，A 和B 是有子父类关系的 

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

  • 父类有泛型，子类可以选择保留泛型也可以选择指定泛型类型

    • 子类不保留父类的泛型：按需实现

      • 没有类型 擦除
      • 具体类型

    • 子类保留父类的泛型：泛型子类

      • 全部保留
      • 部分保留

    • 结论：子类除了指定或保留父类的泛型，还可以增加自己的泛型

    • package com.jl.java.base.generic;

/**
 * @author jiangl
 * @version 1.0
 * @date 2021/4/26 14:43
 */
public class Order<T> {
    String orderName;
    int orderId;
    //类的内部结构可以使用泛型
    T orderT;

    public Order(String orderName, int orderId, T orderT) {
        this.orderName = orderName;
        this.orderId = orderId;
        this.orderT = orderT;
    }

    public T getOrderT() {
        return orderT;
    }

    public void setOrderT(T orderT) {
        this.orderT = orderT;
    }
}

/**
 * 子类不保留父类的泛型,没有指定类型，擦除泛型，使用Object
 */
class ChildOrder extends Order{

    public ChildOrder(String orderName, int orderId, Object orderT) {
        super(orderName, orderId, orderT);
    }
}

/**
 * 子类不保留父类的泛型,指定具体类型
 */
class ChildOrder1 extends Order<Integer>{


    public ChildOrder1(String orderName, int orderId, Integer orderT) {
        super(orderName, orderId, orderT);
    }
}

/**
 * 子类保留父类的泛型:全部保留
 * @param <T>
 */
class ChildOrder2<T> extends Order<T>{

    public ChildOrder2(String orderName, int orderId, T orderT) {
        super(orderName, orderId, orderT);
    }
}

/**
 * 子类保留父类的泛型:全部保留，并增加自己的新的泛型
 * @param <K>
 * @param <T>
 */
class ChildOrder3<K,T> extends Order<T>{

    private K key3;

    public ChildOrder3(String orderName, int orderId, T orderT, K key3) {
        super(orderName, orderId, orderT);
        this.key3 = key3;
    }
}

/**
 * 子类保留父类的泛型:部分保留，并增加自己的新的泛型
 * @param <S>
 * @param <T>
 */
class ChildOrder4<S,T> extends ChildOrder3<String,T>{

    private S key2;

    public ChildOrder4(String orderName, int orderId, T orderT, String key3, S key2) {
        super(orderName, orderId, orderT, key3);
        this.key2 = key2;
    }
}

泛型的使用场景

  • 抽象数据库操作公共行为，把方法逻辑和需要操作的数据类本身分离开。提高了复用性

  • 例如：

    • 创建一个公共的Dao接口,Dao提供了增删改查方法

    • /**
 * @author jiangl
 * @version 1.0
 * @date 2021/4/26 15:34
 */
public interface Dao<T>{
    
    void add(T t);
    
    boolean update(T t);
    
    T get(int id);
    
    boolean remove(T t);
}

    • 创建一个Customer对象

      • package com.jl.java.base.generic.adv;

/**
 * @author jiangl
 * @version 1.0
 * @date 2021/4/26 15:36
 */
public class Customer {

    private String name;

    private int id;

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

    public String getName() {
        return name;
    }

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

    public int getId() {
        return id;
    }

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

    • 创建CustomerDao implements Dao

      • package com.jl.java.base.generic.adv;

/**
 * @author jiangl
 * @version 1.0
 * @date 2021/4/26 15:36
 */
public class CustomerDao implements Dao<Customer>{
    @Override
    public void add(Customer customer) {
        System.out.println("add:"+customer);
    }

    @Override
    public boolean update(Customer customer) {
        System.out.println("update:"+customer);
        return true;
    }

    @Override
    public Customer get(int id) {
        return new Customer("customer",1);
    }

    @Override
    public boolean remove(Customer customer) {
        System.out.println("update:"+customer);
        return true;
    }
}

通配符使用

  • 使用类型的通配符: <?>

    • 比如：List<?>，Map<?,?>
    • List<?>是List,List等各种泛型List的父类。

  • 读取List<?>的对象list中的元素时，永远是安全的，因为不管list的真实类型是什么，它都包含的是Object

  • 写入list<?>中的元素时，不行。因为不知道c的元素类型，不能添加对象

    • 唯一例外的是null，它是所有类型的成员

  • 类A是类B的父类，G和G是没有关系的，二者共同的父类时：G<?>

    • public void test3(){
    List<String> list1= null;
    List<Object> list2 = null;
    List<?> list = null;
    list = list2;
    list = list1;
}

  • 对于List<?>不能向其内部添加数据，除了添加null之外

    •     public void test3(){
        List<String> list1= null;
        List<Object> list2 = null;
        List<?> list = null;
        list = list2;
        list = list1;

        List<String> list3 = new ArrayList<String>();
        list3.add("dfadf");
        list = list3;
        //list<?>不能添加数据
//        list.add("dfafd");
        //list<?>可以读取数据，读取到的类型是Object
        System.out.println(list.get(0));
    }

  • 有限制的通配符：

    • <?> 允许所有泛型的引用调用

    • 通配符指定上限

      • 上限extends：使用时指定的类型必须是继承某个类，或者实现某个接口，即<=

    • 通配符指定下限：

      • 下限super：使用时指定的类型不能小于操作的类，即>=

    • 举例

      • <? extends Number> (无穷小，Number] - 只允许泛型为Number及Number子类的引用调用
      • <? super Number>[Number,无穷大) - 只允许泛型为Number及Number父类的引用调用
      • <? extends Comparable> - 只允许泛型为实现Comparable接口的实现类的引用调用 
    •     public static void main(String[] args) {
        List<? extends Person> list = null;
        List<? super Person> list2 = null;

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

        list = list3;
        //不行
//        list = list5;
        list = list4;
        list2 = list5;
        //不行
//        list2 = list3;
    }
Shacoray
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java基础-泛型学习总结
03-12
思维导图
java基础-泛型通配符
03-12
java基础-泛型通配符
Java基础-泛型
weixin_37672801的博客
11-02 325
泛型基础、类型擦除、通配符
JAVA基础-泛型
小人物的草稿本
06-19 210
* Java 泛型（generics）是JDK5中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。 ...
Java基础 - 泛型
二饭的博客
12-29 228
本文都是干货，一些理论上东西我尽可能一笔带过，只写有用的内容。 本篇目录 1- 泛型是什么 2- 泛型的作用 3- 泛型的定义 4- 泛型的使用 泛型是什么 如下代码是一个使用了泛型的实体类，E表示这里类型使用的了泛型，意思是可以为任意类型，也包括引用数据类型。 public class Test<E> { private E test; public Test(E test){ this.test=test; } public E ge
Java 基础 - 泛型
Liarboy
09-09 2085
这种方法可以解决开始遇到的问题，编译器知道类型参数的范围，如果传入的实例类型B是在这个范围内的话允许转换，这时只要一次类型转换就可以了，运行时会把对象当做A的实例看待。在使用泛型的时候，我们可以为传入的泛型类型实参进行上下边界的限制，如：类型实参只准传入某种类型的父类或某种类型的子类。擦除方法定义中的类型参数原则和擦除类定义中的类型参数是一样的，这里仅以擦除方法定义中的有限制类型参数为例。当类定义中的类型参数存在限制（上下界）时，在类型擦除中替换为类型参数的上界或者下界，比如形如。
Java 基础 - 泛型机制详解
最新发布
veno
01-03 1126
Java泛型这个特性是从JDK 1.5才开始加入的，因此为了兼容之前的版本，Java泛型的实现采取了“伪泛型”的策略，即Java在语法上支持泛型，但是在编译阶段会进行所谓的“类型擦除”（Type Erasure），将所有的泛型表示（尖括号中的内容）都替换为具体的类型（其对应的原生态类型），就像完全没有泛型一样。本文综合多篇文章后，总结了Java 泛型的相关知识，希望可以提升你对Java中泛型的认知效率。
13.java基础-泛型和可变参
qq_30635523的博客
11-30 306
泛型和可变参
大学课程讲义-Java基础-泛型.docx
08-14
Java泛型是Java编程语言中的一种特性，它允许在数据结构（如集合）中存储特定类型的元素，从而提供了编译时的类型安全性和更清晰的代码。泛型引入的主要目标是...理解并熟练使用泛型是每个Java开发者的基础技能之一。
关于java基础的泛型的练习
04-24
Java泛型是Java SE 5.0引入的一个重要特性，它极大地增强了代码的类型安全...在进行"关于Java基础的泛型的练习"时，可以尝试编写不同的泛型类、泛型方法，体验泛型带来的便利，并理解其背后的类型系统和类型擦除机制。
Java 基础(4-8) - 泛型机制详解.pdf
06-28
Java泛型是自JDK 1.5版本引入的一个重要特性，目的是为了提高代码的类型安全性和重用性。在Java中，泛型允许开发者在类、接口和方法中使用类型参数，使得代码能处理多种数据类型而无需重复编写相似的代码。然而，...
Java针对不同文件加水印
J三石的博客
03-10 3444
背景 需求需要对不同文件加水印，例如：jpg，png，pdf，word 由于不同文件不同的方式，所以进行逐个功能开发 调研 图片文件（jpg,png,e.g.)：通过ImageIO PDF：1.itextpdf 2.pdfbox Word：1.通过Free Spire for Doc 2.apache poi 分析 对比 图片文件，最好选择就是通过ImageIO，ImageIO为Java的自带工具类javax.imageio.ImageIO PDF下 itext官网url：https://it
记录服务器上，不定时出现io.lettuce.core.RedisCommandTimeoutException: Command timed out after xxx millisecond(s)
J三石的博客
04-25 2961
记录服务器上，不定时出现io.lettuce.core.RedisCommandTimeoutException: Command timed out after 12 millisecond(s) 日志 org.springframework.data.redis.RedisConnectionFailureException: Unable to connect to Redis; nested exception is org.springframework.data.redis.connec
JAVA 使用web3j接入以太坊（一）
J三石的博客
09-09 2511
第一步先创建maven项目，在项目的pom文件依赖中添加web3j <dependency> <groupId>org.web3j</groupId> <artifactId>core</artifactId> <version>4.2.0</version> </dependency>...
记录一次huawei sdk依赖 log4j导致，项目日志打印不正常的记录；log4j和Slf4j冲突导致tomcat日志不打印
J三石的博客
04-19 738
记录一次huawei sdk依赖 log4j导致，项目日志打印不正常的记录；log4j和Slf4j冲突导致tomcat日志不打印
说明所有BeanPostProcessor的触发时机
J三石的博客
09-01 677
说明所有BeanPostProcessor的触发时机 BeanPostProcessor BeanPostProcessor postProcessBeforeInitialization： 【调用时机】在initializeBean方法中，调用bean的afterProperties()方法和initMethod()方法之前。 【作用】用于对bean的属性赋值完成后，调用初始化方法前的逻辑增强操作 【例子】ApplicationContextAwareProcessor的postProcessBe
多线程-单例模式 - Double Check Lock - Volatile
J三石的博客
04-13 471
单例模式（Singleton）： 保证一个类在程序中仅有一个实例，并提供一个访问该实例的全局访问点。 单例模式的实现-饿汉模式： 设计思想：在类加载时就创建一个不可变的静态的单例对象。（如果该对象不被使用，则浪费了堆空间的资源） //问题1： 为什么加final //答：可以防止子类通过操作生成父类的对象,不适当的覆盖父类的方法，从而破坏单例 //问题2：如果实现了序列化接口，还要做什么来防止反序列化破坏单例、 //答：通过在readResolve方法中，返回INSTANCE来防止反序列化破坏单例
java基础-枚举类与注解-注解(Annotation)
J三石的博客
04-21 465
Java基础之枚举类与注解-注解(Annotation) 主要内容： 注解(Annotation)概述 常见的Annotation示例 自定义Annotation JDK中的元注解 利用反射获取注解信息 JDK8中注解的新特性 注解（Annotation）的概述 从JDK5.0开始，Java增加了对元数据(MetaData)的支持，也就是Annotation(注解) Annotation其实就是代码里的“特殊标记”，这些标记可以在编译时，类加载时，运行时被读取，并执行相应的处理。通常使用An
java基础(十二 )-----Java泛型详解
05-16
Java泛型是Java 5引入的新特性，可以提高代码的可读性和安全性，降低代码的耦合度。泛型是将类型参数化，实现代码的通用性。 一、泛型的基本语法 在声明类、接口、方法时可以使用泛型，泛型的声明方式为在类名、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值