基础储备----Java泛型

最新推荐文章于 2023-10-11 17:26:22 发布
最新推荐文章于 2023-10-11 17:26:22 发布
阅读量210 收藏
点赞数
分类专栏： Java基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BraveLoser/article/details/82423884
版权

1. 前言

Java源码中有大量泛型的使用, 但是, 日常开发中, 对泛型特性的了解却仅限于表面的浅浅一层, 所以这里记录泛型相关的一些知识.

2. 泛型概述

2.1 什么是泛型

泛型, 即”参数化类型”. 一提到参数, 最熟悉的就是定义方法时有形参, 然后调用此方法时传递实参. 那么参数化类型怎么理解呢? 顾名思义, 就是将类型由原来的具体的类型参数化, 类似于方法中的变量参数, 此时类型也定义成参数形式(可以称之为类型形参), 然后在使用/调用时传入具体的类型(类型实参). 泛型的本质是为了参数化类型(在不创建新的类型的情况下, 通过泛型指定的不同类型来控制形参具体限制的类型). 也就是说在泛型使用过程中, 操作的数据类型被指定为一个参数, 这种参数类型可以用在类, 接口和方法中, 分别被称为泛型类, 泛型接口, 泛型方法.

2.2 为什么要有泛型

代码示例:

public class Main {
    public static void main(String[] args){
        List arrayList = new ArrayList();
        arrayList.add("aaaa");
        arrayList.add(100);
        for(int i = 0; i< arrayList.size();i++){
            String item = (String)arrayList.get(i);
            System.out.println("泛型测试, item = " + item);
        }
    }
}

运行结果:

泛型测试, item = aaaa
Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
    at Main.main(Main.java:11)

ArrayList可以存放任意类型, 例子中添加了一个String类型, 添加了一个Integer类型, 在使用时都以String的方式使用, 因此程序崩溃了. 为了解决类似这样的问题(在编译阶段就可以解决), 泛型应运而生.
我们将第一行声明初始化list的代码更改一下, 编译器会在编译阶段就能够帮我们发现类似这样的问题.
泛型

List<String> arrayList = new ArrayList<String>();
...
//arrayList.add(100); 在编译阶段，编译器就会报错

2.3 特性

泛型只在编译阶段有效. 看下面的代码

public class Main {
    public static void main(String[] args){
        List<String> stringArrayList = new ArrayList<String>();
        List<Integer> integerArrayList = new ArrayList<Integer>();
        Class classStringArrayList = stringArrayList.getClass();
        Class classIntegerArrayList = integerArrayList.getClass();
        System.out.println(classStringArrayList);
        System.out.println(classIntegerArrayList);
    }
}

结果:

class java.util.ArrayList
class java.util.ArrayList

通过上面的例子可以证明, 在编译之后程序会采取去泛型化的措施. 也就是说Java中的泛型, 只在编译阶段有效. 在编译过程中, 正确检验泛型结果后, 会将泛型的相关信息擦除, 并且在对象进入和离开方法的边界处添加类型检查和类型转换的方法. 也就是说, 泛型信息不会进入到运行时阶段.

3. 泛型的使用

泛型有三种使用方式, 分别为: 泛型类, 泛型接口, 泛型方法

3.1 泛型类

泛型类型用于类的定义中, 被称为泛型类. 通过泛型可以完成对一组类的操作对外开放相同的接口. 最典型的就是各种容器类, 如: List, Set, Map.
泛型类的最基本写法(这么看可能会有点晕, 会在下面的例子中详解):

class 类名称 <泛型标识：可以随便写任意标识号，标识指定的泛型的类型>{
  private 泛型标识 /*（成员变量类型）*/ var; 
  .....

  }
}

一个最普通的泛型类:

//此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型
//在实例化泛型类时，必须指定T的具体类型
public class Generic<T>{ 
    //key这个成员变量的类型为T,T的类型由外部指定  
    private T key;
    public Generic(T key) { //泛型构造方法形参key的类型也为T，T的类型由外部指定
        this.key = key;
    }
    public T getKey(){ //泛型方法getKey的返回值类型为T，T的类型由外部指定
        return key;
    }
}
public class Main {
    public static void main(String[] args){
        //泛型的类型参数只能是类类型（包括自定义类），不能是简单类型
        //传入的实参类型需与泛型的类型参数类型相同，即为Integer.
        Generic<Integer> genericInteger = new Generic<Integer>(123456);
        //传入的实参类型需与泛型的类型参数类型相同，即为String.
        Generic<String> genericString = new Generic<String>("key_vlaue");
        System.out.println("泛型测试, key is " + genericInteger.getKey());
        System.out.println("泛型测试, key is " + genericString.getKey());
    }
}

运行结果:

泛型测试, key is 123456
泛型测试, key is key_vlaue

定义的泛型类, 就一定要传入泛型类型实参么? 并不是这样, 在使用泛型的时候如果传入泛型实参, 则会根据传入的泛型实参做相应的限制, 此时泛型才会起到本应起到的限制作用. 如果不传入泛型类型实参的话, 在泛型类中使用泛型的方法或成员变量定义的类型可以为任何的类型.

public class Main {
    public static void main(String[] args){
        Generic generic = new Generic("111111");
        Generic generic1 = new Generic(4444);
        Generic generic2 = new Generic(55.55);
        Generic generic3 = new Generic(false);
        System.out.println("泛型测试, key is " + generic.getKey());
        System.out.println("泛型测试, key is " + generic1.getKey());
        System.out.println("泛型测试, key is " + generic2.getKey());
        System.out.println("泛型测试, key is " + generic3.getKey());
    }
}

运行结果:

泛型测试, key is 111111
泛型测试, key is 4444
泛型测试, key is 55.55
泛型测试, key is false

3.2 泛型接口

泛型接口与泛型类的定义及使用基本相同. 泛型接口常被用在各种类的生产器中, 可以看一个例子:

//定义一个泛型接口
public interface Generator<T> {
    public T next();
}

当实现泛型接口的类, 未传入泛型实参时:

/**
 * 未传入泛型实参时，与泛型类的定义相同，在声明类的时候，需将泛型的声明也一起加到类中
 * 即：class FruitGenerator<T> implements Generator<T>{
 * 如果不声明泛型，如：class FruitGenerator implements Generator<T>，编译器会报错："Unknown class"
 */
class FruitGenerator<T> implements Generator<T>{
    @Override
    public T next() {
        return null;
    }
}

当实现泛型接口的类, 传入泛型实参时:

/**
 * 传入泛型实参时：
 * 定义一个生产器实现这个接口,虽然我们只创建了一个泛型接口Generator<T>
 * 但是我们可以为T传入无数个实参，形成无数种类型的Generator接口。
 * 在实现类实现泛型接口时，如已将泛型类型传入实参类型，则所有使用泛型的地方都要替换成传入的实参类型
 * 即：Generator<T>，public T next();中的的T都要替换成传入的String类型。
 */
public class FruitGenerator implements Generator<String> {

    private String[] fruits = new String[]{"Apple", "Banana", "Pear"};

    @Override
    public String next() {
        Random rand = new Random();
        return fruits[rand.nextInt(3)];
    }
}

3.3 泛型通配符

我们知道Integer是Number的一个子类, 同时在特性章节中我们也验证过Generic与Generic实际上是相同的一种类型. 那么问题来了, 在使用Generic作为形参的方法中, 能否使用Generic的实例传入呢? 在逻辑上类似于Generic和Generic是否可以看成具有父子关系的泛型类型呢?
为了弄清楚这个问题, 我们使用Generic这个泛型类继续看下面的例子:

public class Main {
    public static void main(String[] args){
        Generic<Integer> gInteger = new Generic<Integer>(123);
        Generic<Number> gNumber = new Generic<Number>(456);
        showKeyValue(gNumber);
        // 下面showKeyValue这个方法编译器会为我们报错：Generic<java.lang.Integer>
        // cannot be applied to Generic<java.lang.Number>
        // showKeyValue(gInteger);
    }
    public static void showKeyValue(Generic<Number> obj){
        System.out.println("泛型测试, key value is " + obj.getKey());
    }
}
//此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型
//在实例化泛型类时，必须指定T的具体类型
public class Generic<T>{ 
    //key这个成员变量的类型为T,T的类型由外部指定  
    private T key;
    public Generic(T key) { //泛型构造方法形参key的类型也为T，T的类型由外部指定
        this.key = key;
    }
    public T getKey(){ //泛型方法getKey的返回值类型为T，T的类型由外部指定
        return key;
    }
}

通过提示信息我们可以看到Generic不能被看作为`Generic的子类. 由此可以看出:同一种泛型可以对应多个版本(因为参数类型是不确定的), 不同版本的泛型类实例是不兼容的.
回到上面的例子, 如何解决上面的问题? 总不能为了定义一个新的方法来处理Generic类型的类, 这显然与java中的多台理念相违背. 因此我们需要一个在逻辑上可以表示同时是Generic和Generic父类的引用类型. 由此类型通配符应运而生.
我们可以将上面的方法改一下:

public void showKeyValue(Generic<?> obj){
    System.out.println("泛型测试, key value is " + obj.getKey());
}

类型通配符一般是使用? 代替具体的类型实参, 注意了, 此处’?’是类型实参, 而不是类型形参. 再直白点的意思就是, 此处的?和Number, String, Integer一样都是一种实际的类型, 可以把?看成所有类型的父类. 是一种真实的类型.
可以解决当具体类型不确定的时候, 这个通配符就是?; 当操作类型时, 不需要使用类型的具体功能时, 只使用Object类中的功能. 那么可以用? 通配符来表未知类型.

3.4 泛型方法

泛型类, 是在实例化类的时候指明泛型的具体类型, 泛型方法, 是在调用方法的时候指明泛型的具体类型.

/**
 * 泛型方法的基本介绍
 * @param tClass 传入的泛型实参
 * @return T 返回值为T类型
 * 说明：
 *     1）public 与 返回值中间<T>非常重要，可以理解为声明此方法为泛型方法。
 *     2）只有声明了<T>的方法才是泛型方法，泛型类中的使用了泛型的成员方法并不是泛型方法。
 *     3）<T>表明该方法将使用泛型类型T，此时才可以在方法中使用泛型类型T。
 *     4）与泛型类的定义一样，此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型。
 */
public <T> T genericMethod(Class<T> tClass)throws InstantiationException ,
  IllegalAccessException{
        T instance = tClass.newInstance();
        return instance;
}
Object obj = genericMethod(Class.forName("Test"));

3.4.1 泛型方法的基本用法

光看上面的例子有的同学可能依然会非常迷糊, 我们再通过一个例子, 把我泛型方法再总结一下.

public class GenericTest {
    //这个类是个泛型类，在上面已经介绍过
    public class Generic<T>{
        private T key;
        public Generic(T key) {
            this.key = key;
        }
        //我想说的其实是这个，虽然在方法中使用了泛型，但是这并不是一个泛型方法。
        //这只是类中一个普通的成员方法，只不过他的返回值是在声明泛型类已经声明过的泛型。
        //所以在这个方法中才可以继续使用 T 这个泛型。
        public T getKey(){
            return key;
        }
        /**
         * 这个方法显然是有问题的，在编译器会给我们提示这样的错误信息"cannot reslove symbol E"
         * 因为在类的声明中并未声明泛型E，所以在使用E做形参和返回值类型时，编译器会无法识别。
         public E setKey(E key){
         this.key = key
         }
         */
    }

    /**
     * 这才是一个真正的泛型方法。
     * 首先在public与返回值之间的<T>必不可少，这表明这是一个泛型方法，并且声明了一个泛型T
     * 这个T可以出现在这个泛型方法的任意位置.
     * 泛型的数量也可以为任意多个
     *    如：public <T,K> K showKeyName(Generic<T> container){
     *        ...
     *        }
     */
    public <T> T showKeyName(Generic<T> container){
        System.out.println("container key :" + container.getKey());
        //当然这个例子举的不太合适，只是为了说明泛型方法的特性。
        T test = container.getKey();
        return test;
    }

    //这也不是一个泛型方法，这就是一个普通的方法，只是使用了Generic<Number>这个泛型类做形参而已。
    public void showKeyValue1(Generic<Number> obj){
        System.out.println("泛型测试, key value is " + obj.getKey());
    }

    //这也不是一个泛型方法，这也是一个普通的方法，只不过使用了泛型通配符?
    //同时这也印证了泛型通配符章节所描述的，?是一种类型实参，可以看做为Number等所有类的父类
    public void showKeyValue2(Generic<?> obj){
        System.out.println("泛型测试, key value is " + obj.getKey());
    }

    /**
     * 这个方法是有问题的，编译器会为我们提示错误信息："UnKnown class 'E' "
     * 虽然我们声明了<T>,也表明了这是一个可以处理泛型的类型的泛型方法。
     * 但是只声明了泛型类型T，并未声明泛型类型E，因此编译器并不知道该如何处理E这个类型。
     public <T> T showKeyName(Generic<E> container){
     ...
     }
     */

    /**
     * 这个方法也是有问题的，编译器会为我们提示错误信息："UnKnown class 'T' "
     * 对于编译器来说T这个类型并未项目中声明过，因此编译也不知道该如何编译这个类。
     * 所以这也不是一个正确的泛型方法声明。
     public void showkey(T genericObj){

     }
     */
    public static void main(String[] args) {

    }
}

3.4.2 类中的泛型方法

当然这并不是泛型方法的全部, 泛型方法可以出现杂任何地方和任何场景中使用. 但是有一种情况是非常特殊的, 当泛型方法出现在泛型类中时, 我们再通过一个例子看一下

public class GenericFruit {
    class Fruit{
        @Override
        public String toString() {
            return "fruit";
        }
    }
    class Apple extends Fruit{
        @Override
        public String toString() {
            return "apple";
        }
    }
    class Person{
        @Override
        public String toString() {
            return "Person";
        }
    }
    class GenerateTest<T>{
        public void show_1(T t){
            System.out.println(t.toString());
        }
        //在泛型类中声明了一个泛型方法，使用泛型E，这种泛型E可以为任意类型。可以类型与T相同，也可以不同。
        //由于泛型方法在声明的时候会声明泛型<E>，因此即使在泛型类中并未声明泛型，编译器也能够正确识别泛型方法中识别的泛型。
        public <E> void show_3(E t){
            System.out.println(t.toString());
        }
        //在泛型类中声明了一个泛型方法，使用泛型T，注意这个T是一种全新的类型，可以与泛型类中声明的T不是同一种类型。
        public <T> void show_2(T t){
            System.out.println(t.toString());
        }
    }
    public void main(String[] args) {
        Apple apple = new Apple();
        Person person = new Person();
        GenerateTest<Fruit> generateTest = new GenerateTest<Fruit>();
        //apple是Fruit的子类，所以这里可以
        generateTest.show_1(apple);
        //编译器会报错，因为泛型类型实参指定的是Fruit，而传入的实参类是Person
        //generateTest.show_1(person);
        //使用这两个方法都可以成功
        generateTest.show_2(apple);
        generateTest.show_2(person);
        //使用这两个方法也都可以成功
        generateTest.show_3(apple);
        generateTest.show_3(person);
    }
}

3.4.3 泛型方法与可变参数

再看一个泛型方法和可变参数的例子:

public class Main{
    public static void main(String[] args){
        printMsg("111",222,"aaaa","2323.4",55.55);
    }
    public static <T> void printMsg( T... args){
        for(T t : args){
            System.out.println("泛型测试, t is " + t);
        }
    }
}

3.4.4 静态方法与泛型

静态方法有一种情况需要注意一下, 那就是在类中的静态方法使用泛型: 静态方法无法访问类上定义的泛型; 如果静态方法操作的引用数据类型不确定的时候, 必须要将泛型定义在方法上.
即: 如果静态方法要使用泛型的话, 必须将静态方法也定义成泛型方法.

public class StaticGenerator<T> {
    ....
    ....
    /**
     * 如果在类中定义使用泛型的静态方法，需要添加额外的泛型声明（将这个方法定义成泛型方法）
     * 即使静态方法要使用泛型类中已经声明过的泛型也不可以。
     * 如：public static void show(T t){..},此时编译器会提示错误信息：
          "StaticGenerator cannot be refrenced from static context"
     */
    public static <T> void show(T t){

    }
}

3.4.5 泛型方法总结

泛型方法能使方法独立于类而产生变化, 以下是一个基本的指导原则:

  • 无论何时, 如果你能做到, 你就该尽量使用泛型方法. 也就是说, 如果使用泛型方法将整个类泛型化, 那么就应该使用泛型方法. 另外对于一个static的方法而言, 无法访问泛型类型的参数. 所以如果static方法要使用泛型能力, 就必须使其成为泛型方法.

3.5 泛型上下边界

在使用泛型的时候, 我们还可以为传入的泛型类型实参进行上下边界的限制, 如: 类型实参只准传入某种类型的父类或某种类型的子类.
为泛型添加上边界, 即传入的类型实参必须是指定类型的子类型.

public class Main{
    public static void main(String[] args){
        Generic<String> generic1 = new Generic<String>("11111");
        Generic<Integer> generic2 = new Generic<Integer>(2222);
        Generic<Float> generic3 = new Generic<Float>(2.4f);
        Generic<Double> generic4 = new Generic<Double>(2.56);

        //这一行代码编译器会提示错误，因为String类型并不是Number类型的子类
        //showKeyValue1(generic1);

        showKeyValue1(generic2);
        showKeyValue1(generic3);
        showKeyValue1(generic4);
    }
    public static void showKeyValue1(Generic<? extends Number> obj){
        System.out.println("泛型测试, key value is " + obj.getKey());
    }
}

如果我们把泛型类的定义也改一下:

public class Generic<T extends Number>{
    private T key;
    public Generic(T key) {
        this.key = key;
    }
    public T getKey(){
        return key;
    }
}
//这一行代码也会报错，因为String不是Number的子类
Generic<String> generic1 = new Generic<String>("11111");

再来一个泛型方法的例子:

//在泛型方法中添加上下边界限制的时候，必须在权限声明与返回值之间的<T>上添加上下边界，即在泛型声明的时候添加
//public <T> T showKeyName(Generic<T extends Number> container)，编译器会报错："Unexpected bound"
public <T extends Number> T showKeyName(Generic<T> container){
    System.out.println("container key :" + container.getKey());
    T test = container.getKey();
    return test;
}

通过上面的两个例子可以看出: 泛型的上下边界添加, 必须与泛型的声明在一起.

3.6 泛型数组

在Java中是”不能创建一个确切的泛型类型的数组”的.
也就是说下面的这个例子是不可以的:

List<String>[] ls = new ArrayList<String>[10];

而使用通配符创建泛型数组是可以的, 如下面这个例子:

List<?>[] ls = new ArrayList<?>[10];

这样也是可以的:

List<String>[] ls = new ArrayList[10];

下面使用Sun的一篇文档的一个例子来说明这个问题:

List<String>[] lsa = new List<String>[10]; // Not really allowed.    
Object o = lsa;    
Object[] oa = (Object[]) o;    
List<Integer> li = new ArrayList<Integer>();    
li.add(new Integer(3));    
oa[1] = li; // Unsound, but passes run time store check    
String s = lsa[1].get(0); // Run-time error: ClassCastException.
  • 这种情况下, 由于JVM泛型的擦除机制, 在运行时JVM是不知道泛型信息的, 所以可以给oa[1]赋上一个ArrayList而不会出现异常, 但是在取出数据的时候却要做一次类型转换, 所以就会出现ClassCastException, 如果可以进行泛型数组的声明, 上面说的这种情况在编译期将不会出现任何的警告和错误, 只有在运行时才会出错.

这个部分写不下去了, 记住一点就好, 不要使用泛型数组!!!

4. 参考链接

https://blog.csdn.net/s10461/article/details/53941091

「已注销」
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java基础-泛型学习总结
03-12
思维导图
Java泛型
myt0929的专栏
03-10 487
  偶然看见这种泛型的方式<T extends Comparable<? super T>>，一时间懵逼了，这写的是啥，然后找资料去理解这种泛型定义。   要理解这种类型的泛型，先理解以下这种泛型的含义： <T extends Comparable<T>>   这种泛型的很好理解，就是类型T必须是或者继承某种类型。这种类型就是需要实现Compara...
java: 不兼容的类型: 推论变量T具有不兼容的限制范围 等式约束条件: T 下限: java.lang.Object
心比天高，仗剑走天涯，保持热爱，奔赴向梦想！
01-17 3714
开发中遇到一个比较生僻的关于泛型T的问题。想要利用泛型封装一下统一返回实体时报错记录学习一下。
IDEA在build项目或用maven构建时，出现错误→不兼容的类型: 推断类型不符合上限
最新发布
weixin_45131680的博客
10-11 787
我们点击错误消息时会标记第1行代码，但其实原因是第8行返回的 new HashMap<>()。**我们知道，Map<K,V> / HashMap<K,V>是java.util包里的泛型类，new HashMap<>等价于new HashMap<Object, Object>， 而外层接收的是 Map<String, OrderDTO>。上面的build报错，我的项目JDK版本是1.8.0_40。升级到1.8.0_241后，这个问题就没有了， 高版本的JRE已经可以推断出来这个类型转换了。
typeScript总结之函数和泛型详解
qq_34027761的博客
09-01 605
三、函数 TypeScript中函数的格式： let myAdd: (baseValue: number, increment: number) => number = function(x: number, y: number): number { return x + y; }; 标准格式 //格式1 function(x: number, y: number): number { return x + y; }; //格式2 let myAdd: (x: number, y:
Java 泛型相关整理
windy杨树的博客
03-26 145
1. 概述 Java 泛型（generics）是 JDK 5 中引入的一个新特性，泛型提供了 编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。 泛型，即 参数化类型。将类型由原来的具体的类型（类似于方法的变量参数，该变量定义了具体的类型），也定义成参数形式（可以称之为类型形参），然后在使用/调用时再传入具体的类型（类型实参）。 泛型的本质是为了参数化类型（在不创建新...
java基础-泛型通配符
03-12
java基础-泛型通配符
JAVA-泛型课件-泛型课件
05-11
个人制作且上课使用的课件，希望对大家初步了解泛型相关内容有一定的帮助。个人制作且上课使用的课件，希望对大家初步了解泛型相关内容有一定的帮助。
JAVA-泛型基本讲解
06-06
1、Java泛型是J2 SE1.5中引入的一个新特性，其本质是参数化类型，也就是说所操作的数据类型被指定为一个参数（type parameter）这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。...
大学课程讲义-Java基础-泛型.docx
08-14
大学课程讲义_Java基础_泛型.docx
Maven编译不兼容解决方案
08-26
eclipse 中编译、运行都正常，但是如果用maven的打包命令 mvn clean package 进行打包时会发现有类型错误
Java高级特性-泛型类型推断
VoidHope的博客
10-07 346
Java泛型类型推导是Java 7中引入的一种新特性，指 Java 编译器根据上下文推断出泛型类型参数的类型。类型推导的目的是简化泛型编程，减少代码中的冗余。在 Java 7 之前，需要在定义泛型类型或调用泛型方法时显式指定泛型类型。使用类型推导后，可以让编译器根据上下文推断出泛型类型的实际类型，从而简化代码。
IDEA提示不兼容类型,找不到合适的方法,无法推断类型变量,不适用等编译错误解决方法
热门推荐
Umbrella Corporation
08-09 3万+
这个针对和使用eclipse的小伙伴在代码交互上可能会存在在使用idea编译的时候报错,但是eclipse的小伙伴上并没有编译错误. 这是因为这个虽然是maven项目 但是Eclipse编译代码使用的是Eclipse自带的JDT（Java Development Tools） 而IDEA 这里默认使用的是JAVA_HONE中的javac javac相对JDT的检查机制来说，更加的严格，...
IDEA/MAVEN编译错误：不兼容的类型，推断类型不符合上限
gzyes
02-28 873
IDEA在build项目或用maven构建时，出现错误→不兼容的类型: 推断类型不符合上限 Error:(285, 67) java: 不兼容的类型: 推断类型不符合上限 推断: java.util.Map<? extends java.lang.Object,? extends java.lang.Object> 上限: java.util.Map<java...
python中var是什么_c#教程之c#中var关键字用法浅谈
weixin_39778815的博客
11-24 1101
https://www.xin3721.com/eschool/VAR 是3.5新出的一个定义变量的类型其实也就是弱化类型的定义VAR可代替任何类型编译器会根据上下文来判断你到底是想用什么类型的至于什么情况下用到VAR 我想就是你无法确定自己将用的是什么类型就可以使用VAR 类似 OBJECT但是效率比OBJECT高点使用var定义变量时有以下四个特点：1. 必须在定义时初始化。也就是...
java泛型类型推断_Java 泛型-类型推断
weixin_35183690的博客
02-28 2418
类型推断(Type Inference)是指 Java 编译器能查看每个方法的调用和相应声明，以确定调用合适的类型参数(Type Argument)或参数。推断算法决定参数的类型，如果可用，则指定被赋值的类型或返回的类型。最后，推断算法试图在一起工作的所有参数中找到最具体的类型。为了说明最后一点，在下面的例子中，泛型推断确定将传入 pick 方法的第二个参数作为 Serializable 的类型：...
一文搞懂 java 泛型，也有可能搞不懂，毕竟讲得太全面了
兴趣是最好的老师，勤能补拙
06-29 610
在许多编程语言中，如Java和C#，泛型类是一种特殊类型的类，它可以接受不同类型的参数进行实例化。泛型类提供了代码重用和类型安全性的好处，因为它们可以与各种数据类型一起使用，而无需为每种类型编写单独的类。// 类成员和方法定义 }在上面的示例中，是一个泛型类的名称，表示类型参数，T可以替换为任何合法的标识符，用于表示实际类型。要使用泛型类，可以通过指定实际类型来实例化它。例如，假设我们有一个名为MyClass在上面的示例中，我们使用整数类型实例化了泛型类。这样，myInstance。
Non-static method cannot be referenced from a static context ，java: 不兼容的类型: 推断类型不符合上限 的解决办法
Spring Boot-Common On With You
05-01 1万+
问题概述 如下图： 解决办法
Java-泛型小解
樊金良的博客
07-01 676
泛型小解，新手上路！
java基础(十二 )-----Java泛型详解
05-16
Java泛型是Java 5引入的新特性，可以提高代码的可读性和安全性，降低代码的耦合度。泛型是将类型参数化，实现代码的通用性。 一、泛型的基本语法 在声明类、接口、方法时可以使用泛型，泛型的声明方式为在类名、...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值