精华内容
下载资源
问答
  • 2020-07-11 12:18:19

    JAVA泛型
    泛型提供了编译时类型安全检测机制,该机制允许程序员在编译时检测到非法的类型。
    泛型的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数
    你定义了一个泛型(类、接口),那么Java规定,你不能在所有的静态方法、静态初块等所有静态内容中使用泛型的类型参数!

    泛型方法
    该方法在调用时可以接收不同类型的参数。根据传递给泛型方法的参数类型,编译器适当地处理每一个方法调用
    泛型方法有一个类型参数声明部分(由尖括号分隔)表示参数的类型, 该类型参数声明部分放在在方法返回类型之前
    格式:
    访问修饰符 <类型参数列表> 返回类型 方法名(形参列表) {
    }
    例如: public void set(T t) { }

    避免歧义
    泛型方法 void test(T t1, T t2);
    调用泛型方法test(“1”,1);编译不出错,存在歧义,T是String还是Integer类型存在歧义

    void test(List l1, List l2);test(new List(), new List()); 编译报错

    每一个类型参数声明部分包含一个或多个类型参数,参数间用逗号隔开。一个泛型参数,也被称为一个类型变量,是用于指定一个泛型类型名称的标识符。
    类型参数能被用来声明返回值类型,并且能作为泛型方法得到的实际参数类型的占位符。
    泛型方法体的声明和其他方法一样。注意类型参数只能代表引用型类型,不能是原始类型(像int,double,char的等)

    有界的类型参数:

    可能有时候,你会想限制那些被允许传递到一个类型参数的类型种类范围。例如,一个操作数字的方法可能只希望接受Number或者Number子类的实例。这就是有界类型参数的目的。

    要声明一个有界的类型参数,首先列出类型参数的名称,后跟extends关键字,最后紧跟它的上界。
    *
    *
    泛型类**
    在类名后面添加了类型参数声明部分
    格式
    public class A {
    }

    类型通配符
    1、类型通配符一般是使用?代替具体的类型参数。例如 List<?> 在逻辑上是List,List 等所有List<具体类型实参>的父类。
    泛型都可以解决通配符的问题
    void func(List<? extends A> list); list不可修改
    void func(List list); list可修改
    ?泛型对象是只读的,不可修改,因为?类型是不确定的,可以代表范围内任意类型;
    ii. 而泛型方法中的泛型参数对象是可修改的,因为类型参数T是确定的(在调用方法时确定),因为T可以用范围内任意类型指定;

    !!注意,前者是代表,后者是指定,指定就是确定的意思,而代表却不知道代表谁,可以代表范围内所有类型;

    泛型和Object的区别

    public Object func(Object obj) {
    }
    返回类型可以和obj类型不同,类型只能是Object类型,若要返回指定类型,必须强转
    
    public <T> T func(T t) {
    }
    返回类型可以必须和obj类型相同,返回类型指定,无需强转
    

    下面例子

    public class ClassA<T> {
    	public <T> T func(T t) {
    	}
    }
    

    ClassA classA = new ClassA();
    Foo foo = new foo();
    Foo newFoo = classA.func(foo);

    如果是Object,必须强转

    Foo newFoo = (Foo) classA.func(foo);

    总结:
    泛型有如下优点:
    1、无须类型强转,提高效率,避免了强转出错。
    2、通配符"?"的使用提高了程序的阅读性。
    3、限制通配符(<? extends T>、<? super T>)提高了程序的健壮性。
    所以,可以使用泛型就尽量使用泛型吧!

    更多相关内容
  • 泛型:泛型类与泛型方法

    千次阅读 2022-03-16 10:40:33
    1. public 和 返回类型中间的标识符,**可以理解为**,声明该...2. 只有声明了的方法是泛型方法泛型类中的成员方法**不是**泛型方法 3. 表明,该方法使用泛型类型T,可以使用在**返回类型,传入参数列表,方法体**里

    泛型

    JDK1.5新特性

    优点:

    1. 类型安全:编译时检测类型
    2. 减少类型转换

    泛型类

    概念:在类声明体中用到了类型参数。

    语法:

    /*
    class 类型名<泛型标识,泛型标识, ...>{
        private 泛型标示 变量名;
    }
    */
    public class GenericDemo<T> {
        private T key;
    
        public GenericDemo(T key) {
            this.key = key;
        }
    
        public T getKey() {
            return key;
        }
    
        public void setKey(T key) {
            this.key = key;
        }
    
        public static void main(String[] args) {
            
            /*
            类名<具体的数据类型> 对象名 = new 类目<具体的数据类型>();
    
            JDK1.7后,可以省略成这样:
            类名<具体的数据类型> 对象名 = new 类目<>();
            */
            GenericDemo<Integer> integerGenericDemo = new GenericDemo<>(10);
            GenericDemo<String> stringGenericDemo = new GenericDemo<>("abc");
            //如果没有指定具体的数据类型,此时,操作类型是Object
            GenericDemo genericDemo = new GenericDemo("genericDemo");
    
            System.out.println(integerGenericDemo.key);
            System.out.println(stringGenericDemo.key);
            System.out.println(genericDemo.key);
            //泛型类型在逻辑上可以看成是多个不同的类型,但实际上是相同类型
          System.out.println(integerGenericDemo.getClass()==stringGenericDemo.getClass());	//输出结果为true
        }
    }
    
    
    

    注意:

    1. 泛型类只支持类类型不支持基本数据类型(如int),但可以用包装类(如Integer )

    泛型标识<>:类型形参

    由外部使用类的时候来指定

    泛型标识含义
    TType
    EElement
    KKey
    VValue

    泛型类的继承

    1. 子类也是泛型类,子类和父类的泛型标识要一致。子类也可以扩展泛型标识,但子类中至少有一个泛型标识与父类相同

    2. 子类不是泛型类,父类要明确泛型的数据类型

    //1.子类也是泛型类,子类和父类的泛型标识要一致
    
    class Child<T> extends Parent<T>{}
    
    //也可以扩展,但子类中至少有一个泛型标识与父类相同
    class Child<T,E> extends Parent<T>{}
    
    //2.子类不是泛型类,父类要明确泛型的数据类型
    
    class Child extends Parent<String>{}
    

    泛型接口

    1. 实现类不是泛型类时,接口要明确数据类型
    2. 实现类也是泛型类时,实现类和接口的泛型类型要一致

    泛型方法

    泛型方法比泛型类更加灵活

    泛型类和泛型方法的区别
    泛型类实例化类的时候指明泛型的具体类型
    泛型方法调用方法的时候指明泛型的具体类型

    语法

    修饰符 <T,E,...> 返回值类型 方法名(形参列表){
        方法体... 
    }
    
    1. public 和 返回类型中间的标识符,可以理解为,声明该方法为泛型方法
    2. 只有声明了的方法是泛型方法,泛型类中的成员方法不是泛型方法
    3. 表明,该方法使用泛型类型T,可以使用在返回类型,传入参数列表,方法体

    泛型方法与可变参数

    public class GenericDemo<T> {
    
        public static <E> void print(E... e){
            for(int i = 0; i < e.length; i++){
                System.out.println(e[i]);
            }
        }
    
        public static void main(String[] args) {
            GenericDemo.print(1,2,3,4,5);
            GenericDemo.print("a","b","c");
        }
    }
    

    类型通配符: ?

    概念:用“?”代替具体类型,是类型实参,不是类型形参

    /*
    	类型通配符上限
    	语法:
    	类/接口 <? extends 实参类型>
    	作用:要求该泛型的类型只能是《该实参类型或其子类型》  
    */
    
    public static void showAnimal(ArrayList<? extends Cat> list){
        for(int i;i<list.size();i++){
            Cat cat = list.get(i);
            System.out.println(cat);
        }
    }
    public static void main(String[] args){
        ArrayList<Animal> animals = new ArrayList<>();
        ArrayList<Cat> cats = new ArrayList<>();
        ArrayList<MiniCat> miniCats = new ArrayList<>();
        
        //showAnimal(animals); 编译报错
        showAnimal(cats);
        showAnimal(miniCats);
    }
    
    /*
    	类型通配符下限
    	语法:
    	类/接口 <? super 实参类型>
    	作用:要求该泛型的类型只能是《该实参类型或其父类型》  
    */
    

    类型擦除

    概念:

    JDK1.5以前没有泛型,但泛型代码能很好地和之前版本的代码兼容,是因为,泛型信息只存在于代码编译阶段,

    在进入JVM之前,与泛型相关的信息会被擦除

    展开全文
  • 泛型 泛型简介 泛型可以理解为参数化类型,主要作用在类,方法和接口上。 Java泛型 与 C++ 模板 : Java 中的泛型 , 是仿照 C++ 中的模板开发的 , 目的是...泛型类 : 类 也可以有参数 , 将 类型 作为 参数 传入类中 ; 泛

    泛型

    泛型简介

    1. 泛型可以理解为参数化类型,主要作用在类,方法和接口上。
    2. Java泛型 与 C++ 模板 : Java 中的泛型 , 是仿照 C++ 中的模板开发的 , 目的是让开发者可以写出通用,灵活的代码 。
    3. 伪泛型 : Java中的泛型 , 是伪泛型 , Java 泛型开发好之后 , 在编译阶段就将泛型相关的信息消除了 , 不会泛型留到运行时。

    泛型类型 :

    • 泛型方法 : 方法有参数 , 方法的参数 可以指定成一些 泛型 ;
    • 泛型类 : 类 也可以有参数 , 将 类型 作为 参数 传入类中 ;
    • 泛型接口 : 接口 的 参数 , 也可以是泛型 ;

    将类型传入泛型方法 , 泛型类, 泛型接口中 , 可以动态地指定一些类型 ;
    泛型的作用 :

    • 安全检查 : 在编译阶段 , 就可以进行 代码检查, 将更少的错误带到运行时 ;
    • 避免强转 : 避免类型的强转导致不必要的安全问题 ;
    • 提高性能 : 使用泛型可以提高 Java 的性能 ;

    泛型类

    泛型类 : 在类名后面使用声明泛型 , 则在该类中, 可以使用该泛型类型 T 类型 ;特别注意 , 该类中的 如下2个方法不是泛型方法 ; 其中的参数 , 返回值类型是T , 但这个T是作为一个正常的类型使用的 , 并不是声明在方法 中的泛型 ;
    如果类,接口,方法是泛型类, 泛型接口,泛型方法, 则该类 , 接口 , 方法必须由 修饰 , 有个带尖括号的 T ;

        public T getData() {
            return data;
        }
    
        public void setData(T data) {
            this.data = data;
        }
    

    完整的泛型类

    /**
     * 泛型类
     *  该 T 类型作为参数使用
     *  T 是参数化类型 , 可以由外部传入
     *
     * @param <T>
     */
    public class Student<T> {
    
        private String name;
        private int age;
        /**
         * 该数据的类型未知
         *  使用泛型表示 , 运行时确定该类型
         */
        private T data;
    
        public Student(String name, int age, T data) {
            this.name = name;
            this.age = age;
            this.data = data;
        }
    
        /**
         * 该方法不是泛型方法
         *  该方法是普通方法 , 返回值类型是 T 类型
         * @return
         */
        public T getData() {
            return data;
        }
    
        public void setData(T data) {
            this.data = data;
        }
    }
    

    泛型方法

    泛型方法 : 在方法的返回值前, 使用 声明泛型的方法 , 是泛型方法 ; 将某个类型作为参数传入 ;
    泛型个数 : 该方法是泛型方法, 且指定了2个泛型 , 泛型的个数可以有很多个, 多个泛型之间 , 使用逗号隔开 ;
    泛型方法 与 泛型类 中的泛型 :
    泛型不同 : 泛型方法指定的泛型T与 类中的泛型T没有任何关系 , 这两个T 可以是不同的类型 ;
    泛型相同 : 泛型方法中定义的泛型T , 与参数类型的T , 返回值类型的T , 方法内部的T , 都是同一个类型 ;

    /**
     * 泛型类
     *  该 T 类型作为参数使用
     *  T 是参数化类型 , 可以由外部传入
     *
     * @param <T>
     */
    public class Student<T> {
    
        private String name;
        private int age;
        /**
         * 该数据的类型未知
         *  使用泛型表示 , 运行时确定该类型
         */
        private T data;
    
        public Student(String name, int age, T data) {
            this.name = name;
            this.age = age;
            this.data = data;
        }
    
        /**
         * 泛型方法 , 是将某个类型作为参数传入
         *      方法指定泛型 , 写法如下
         *
         * 该方法是泛型方法
         *      方法指定了 2 个泛型
         *      泛型个数 , 泛型的个数可以有很多个
         *      多个泛型之间 , 使用逗号隔开
         *
         * 为方法指定的泛型 T 与类中的泛型 T 没有任何关系
         *      这两个 T 可以是不同的类型
         *
         * 泛型方法中定义的泛型 T
         *      与参数类型的 T
         *      返回值类型的 T
         *      方法内部的 T
         *      都是同一个类型
         *
         * 与泛型类中的 T 完全没有关系
         *
         * @param <T>
         * @param <A>
         * @return
         */
        public <T, A> T getData2(T arg){
            T data = arg;
            return data;
        }
    }
    

    静态方法的泛型

    静态方法泛型 : 如果静态方法中使用了类中的泛型T, 作为参数或返回值 , 这种使用时错误的 ;
    如果必须在静态方法中使用泛型T, 则该泛型T必须是静态方法的泛型 , 不能是类的泛型 ;
    错误用法:
    错误用法正确用法 :
    正确用法

    泛型类与泛型方法完整示例

    /**
     * 泛型类
     *  该 T 类型作为参数使用
     *  T 是参数化类型 , 可以由外部传入
     *
     * @param <T>
     */
    public class Student<T> {
    
        private String name;
        private int age;
        /**
         * 该数据的类型未知
         *  使用泛型表示 , 运行时确定该类型
         */
        private T data;
    
        public Student(String name, int age, T data) {
            this.name = name;
            this.age = age;
            this.data = data;
        }
    
        /**
         * 该方法不是泛型方法
         *  该方法是普通方法 , 返回值类型是 T 类型
         * @return
         */
        public T getData() {
            return data;
        }
    
        public void setData(T data) {
            this.data = data;
        }
    
        /**
         * 泛型方法 , 是将某个类型作为参数传入
         *      方法指定泛型 , 写法如下 ;
         *
         * 该方法是泛型方法
         *      方法指定了 2 个泛型
         *      泛型个数 , 泛型的个数可以有很多个
         *      多个泛型之间 , 使用逗号隔开
         *
         * 泛型方法指定的泛型 T 与类中的泛型 T 没有任何关系
         *      这两个 T 可以是不同的类型
         *
         * 泛型方法中定义的泛型 T
         *      与参数类型的 T
         *      返回值类型的 T
         *      方法内部的 T
         *      都是同一个类型
         *
         * 与泛型类中的 T 完全没有关系
         *
         * @param <T>
         * @param <A>
         * @return
         */
        public <T, A> T getData2(T arg){
            T data = arg;
            return data;
        }
    
        /**
         * 如果静态方法中使用类 类中的泛型
         *      这种使用时错误的
         *
         * 如果必须在 静态方法 中使用泛型 T
         *      则该泛型 T 必须是静态方法的泛型
         *      不能是类的泛型
         *
         * @param arg
         * @return
         */
        public static <T> T getData3(T arg){
            T data = arg;
            return data;
        }
    }
    
    展开全文
  • 主要给大家介绍了Spring中如何初始化泛型类,文中给出详细的介绍和方法实例,对大家的理解和学习具有一定的参考借鉴价值,有需要的朋友可以参考学习,下面来一起看看吧。
  • JAVA容器之泛型类与泛型方法

    泛型是 JDK1.5 以后增加的,它可以帮助我们建立类型安全的集合,类型参数在编译后会被替换成 Object,运行时虚
    拟机并不知道泛型。

    泛型的好处

    • 代码的可读性更好-(不用强制转换 )
    • 程序更加安全 - (只要编译没有警告,运行时就不会出现ClassCastException异常)

    泛型定义

    泛型字符是可以使用任何字符的,但一般会采用这几个来标记:E、T、K、V、N、?

    泛型标记对应单词说明
    EElement在容器中使用,表示容器中的元素
    TType表示普通的JAVA类
    KKey表示键,例如:Map中的键Key
    VValue表示值
    NNumber表示数值类型
    表示不确定的JAVA类型

    泛型类

    泛型类就是把泛型定义在类上,用户调用该类时才会确定类型,如:、<T、K、V>

    语法结构

    public class 类名<泛型表示符号>{
    }
    

    调用时如:

    方法名<String> g = new 方法名<>();
    

    泛型接口

    语法结构

    public interface 接口名<泛型表示符号>{
    }
    

    泛型方法

    泛型方法是指将方法的参数类型定义成泛型,以便在调用时接收不同类型的参数。

    调用泛型方法时,不需要像泛型类那样告诉编译器是什么类型,编译器可以自动推断出类型来,就是调用时跟普通方法一样直接调用就好。

    非静态方法语法结构

    public <泛型表示符号> void 方法名(泛型表示符号 arg){
    }
    
    public <泛型表示符号> 泛型表示符号 方法名(泛型表示符号 arg){
    }
    

    静态方法语法结构

    public static <泛型表示符号> void 方法名(泛型表示符号 arg){
    }
    
    public static <泛型表示符号> 泛型表示符号 方法名(泛型表示符号 arg){
    }
    

    泛型方法与可变参数

    如果定义泛型中参数有多个可以这样定义,这样就可以接收数组类型的参数了

    语法结果:

    public <泛型表示符号> void 方法名(泛型表示符号... args){
    }
    

    无界通配符与上下限定

    无界通配符

    就是"?",表示类型通配符,它只能在“<>”中使用,就是上面的泛型类或者方法将泛型类型符用?替代就好了

    上限限定

    上限限定表示通配符的类型是 T 类以及 T 类的子类或者 T 接口以及 T 接口的子接口。

    public void showFlag(Generic<? extends Number> generic){
    }
    

    可以使用Number类以及Number的所有子类

    下限限定

    下限限定表示通配符的类型是 T 类以及 T 类的父类或者 T 接口以及 T 接口的父接口。

    注意:该方法不适用泛型类。

    public void showFlag(Generic<? super Integer> generic){
    }
    

    即Interger以及Integer的父类都可使用

    泛型总结

    泛型主要用于编译阶段,编译后生成的字节码 class 文件不包含泛型中的类型信息。 类型参数在编译后会被替换成 Object,运行时虚拟机并不知道泛型。因此,使用泛型时,如下两种情况是错误的:

    1. 基本类型不能用于泛型
    	Student<int> s;
    

    这样是错的,要把int改成Integer,即

    	Student<Integr> s;
    
    1. 不能通过类型参数创建对象
      T elm = new T(); 运行时类型参数 T 会被替换成 Object,无法创建 T 类型的对象,容易引起误解,所以在 Java 中不支持这种写法.

    2. 注意下限限定不能使用与泛型类,只能用于泛型方法,上限限定两者都可

    展开全文
  • 【Flutter】Dart 泛型 ( 泛型类 | 泛型方法 | 特定类型约束的泛型 ) https://hanshuliang.blog.csdn.net/article/details/114059611 博客源码快照
  • 泛型类、泛型方法、泛型接口、泛型委托 泛型类、泛型方法、泛型接口、泛型委托
  • 泛型类 //注意这里PPP只是相当于一个"形参"在外界可以给PPP任何一个类型 public class generic<PPP> { PPP p; //来一个有参构造,给需要传递一个类型,在外界,可以传任何类型,Student类,worker类 ...
  • 如果被方法是用,那么泛型类的对象明确要操作的具体类型后,所有要操作的类型就已经固定了。为了让不同的方法可以操作不同类型,而且类型还不确定。那么可以将泛型定义在方法上。泛型类class Demo{public void show...
  • Java泛型、泛型类、泛型方法详解

    千次阅读 2020-05-22 16:52:10
    这种参数类型可以用在类、接口和方法的创建中,分别称为泛型类、泛型接口、泛型方法。 Java泛型被引入的好处是安全简单。在Java SE 1.5之前,没有泛型的情况的下,通过对类型Object的引用来实现参数的“任意化”,...
  • Java系列之:泛型类、泛型方法、泛型接口一、泛型二、泛型类三、泛型方法四、泛型接口五、类型通配符 一、泛型 泛型:本质是参数化类型,也就是说所操作的数据类型被指定为一个参数。将类型由原来的具体的类型参数...
  • 泛型类和泛型方法

    千次阅读 2018-07-06 11:01:05
    泛型类:直接在类/接口上定义的泛型使用泛型:保证前后类型相同List&lt;String&gt; list=new ArrayList&lt;&gt;()从Java7开始推出泛型的菱形语法泛型不存在继承的关系List&lt;Object&gt; ...
  • 下面小编就为大家带来一篇浅谈java中定义泛型类和定义泛型方法的写法。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 主要介绍了Java泛型类与泛型方法的定义,结合实例形式详细分析了java泛型类与泛型方法定义、用法及相关操作注意事项,需要的朋友可以参考下
  • 一、泛型类 一个泛型类(generic class)就是具有一个或者多个类型变量的类,类型变量用尖括号(<>)括起来,并放在类名的后面。泛型类可以有多个类型变量。类型变量使用大写形式,而且比较短。在Java类库中...
  • c#泛型类、泛型方法、泛型接口、泛型委托
  • 一、泛型类用法、 二、泛型方法用法、 三、泛型通配符 、 四、泛型安全检查、
  • 泛型Java 泛型Java 泛型是什么泛型类泛型类的格式泛型类举例泛型方法泛型方法的格式泛型方法举例泛型接口泛型接口的格式泛型接口举例 Java 泛型 Java 泛型是什么 官方定义: 泛型是Java SE 1.5的新特性,泛型的本质...
  • 自定义泛型类1. 使用泛型类2. 子类继承泛型类4. 泛型方法 1. 泛型的提出 List中默认的类型是Object,当我们向List中传入数字和字符串的时候可以执行,但是当要输出的时候就让人头疼。这时候泛型就出来了,可以指定...
  • 在定义的时候并不会设置的属性和方法的参数的具体类型,而是在实际用的时候再定义。它存在的意义是帮我们在编译期间检查我们的类型是否正确。 //定义一个Point class Point{ private Object x; private ...
  • 这种参数类型可以用在类、方法和接口中,分别被称为泛型类、泛指方法、泛指接口。 泛型定义格式: - <类型>:指定一种类型的格式。这里的类型可以看成是形参 - <类型1,类型2…>:指定多类型的格
  • 1泛型的类型参数只能是类类型包括自定义类不能是简单类型 2同一种泛型可以对应多个版本因为参数类型是不确定的不同版本的泛型类实例是不兼容的 3泛型的类型参数可以有多个 4泛型的参数类型可以使用extends语句例如...
  • 泛型类的构造方法定义

    千次阅读 2016-07-10 19:56:27
    泛型类的构造方法定义
  • java 泛型方法 泛型类

    2018-08-02 15:28:02
    泛型方法 /** * 泛型方法的基本介绍 * @param tClass 传入的泛型实参 * @return T 返回值为T类型 * 说明: ...的方法才是泛型方法泛型类中的使用了泛型的成员方法并不是泛型方法。 * 3)&lt;...
  • 泛型允许我们使用类型参数Type parameter,它用一个自定义的标识符(T、V、E)来...在使用泛型类时(区别于定义泛型类时 泛型允许我们使用类型参数Type parameter,它用一个自定义的标识符(T、V、E)来代表一个类型,...
  • 文章目录 泛型类 泛型类的继承 泛型与内部类 泛型接口 泛型接口的实现 泛型方法 形参的类型参数通过实参确定 泛型方法被多个形参... 泛型类中的成员泛型方法和静态泛型方法 匿名内部类和泛型 个人理解总结 ...
  • 详解c# 泛型类的功能

    2020-12-16 21:37:08
    泛型类中,由于不知道泛型参数T是什么类型,可能是引用类型,也可能是值类型,因此不能将null等赋予泛型类型。如何对泛型对象赋初值、如何保证泛型的正确性等,以使用泛型文档管理器为例:  文档管理器用于从队列...
  • 泛型的使用泛型类使用方法泛型类继承泛型接口使用方法泛型接口实现类泛型方法使用方法静态泛型方法所属类为泛型类/泛型接口 前言     我们在平时的开发当中基本上无时无刻都在使用泛型,尤其是涉及到集合、...
  • C#泛型类和泛型方法

    2019-10-21 20:16:46
    泛型可以理解为广泛的类型,或者不确定的...泛型类 泛型类是指这个类的某些字段的类型是不确定的,只有在构造的时候才能确定下的类。 泛型类示例 class Program { static void Main(string[] args) { MyClass&l...
  • Java 泛型 一、概述 Java 泛型(generics)是 JDK 1.5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制,该机制允许开发者在编译时检测到非法的类型。 1.1 什么是泛型泛型,即参数化类型。 一提到参数,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 271,100
精华内容 108,440
关键字:

方法 泛型类