Java基础:泛型(强烈建议收藏)

Rockchip RK3568实战:手把手教你调试I2S音频驱动(附ALSA设备树配置详解) 本文提供Rockchip RK3568平台I2S音频驱动的实战调试指南。详细解析了从硬件连接到软件配置的全过程,重点涵盖ALSA驱动框架下的设备树配置、时钟计算、DMA参数设置以及常见问题(如无声、爆音)的排查与解决方法,帮助开发者快速定位并解决音频驱动难题。 阅读详情

本文将从以下四个方面来系统的讲解一下泛型,基本上涵盖了泛型的主体内容。

  • 什么是泛型?
  • 为什么要使用泛型?
  • 如何使用泛型?
  • 泛型的特性

1. 什么是泛型?

泛型的英文是Generics,是指在定义方法、接口或类的时候,不预先指定具体的类型,而使用的时候再指定一个类型的一个特性。

写过Java代码的同学应该知道,我们在定义方法、接口或类的时候,都要指定一个具体的类型。比如:

public class test {
    private String name;

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

    public String getName() {
        return name;
    }
}

上面代码就定义了字段name的类型为String,方法getName的返回类型为String,这种写法就是预先指定了具体的类型。而泛型就是不预先指定具体的类型。

Java中有一个类型叫ArrayList,相当于一个可变长度的数组。在ArrayList类型中就没有预先指定具体的类型。因为数组可以存放任何类型的数据,如果要预先指定一个数组类型的话,那要满足大家对各种类型的需求,就要写很多类型的ArrayList,要为每个class写一个单独的ArrayList,比如:

  • IntegerArrayList
  • StringArrayList
  • FloatArrayList
  • LongArrayList
  • …

这显然不太现实,因为class有上千种,还有自己定义的class。那么在ArrayList中预先指定具体的类型就无法满足需求。这个时候就需要使用泛型,即不指定存储数据的具体的类型,这个类型由使用者决定。

为了解决类型的问题,我们必须把ArrayList变成一种模板:ArrayList<T>,代码如下:

public class ArrayList<T> {
    private T[] array;
    private int size;
    public void add(T e) {...}
    public void remove(int index) {...}
    public T get(int index) {...}
}

T可以是任何class,这样一来,我们就实现了:编写一次模版,可以创建任意类型的ArrayList:

// 创建可以存储String的ArrayList:
ArrayList<String> strList = new ArrayList<String>();
// 创建可以存储Float的ArrayList:
ArrayList<Float> floatList = new ArrayList<Float>();
// 创建可以存储Person的ArrayList:
ArrayList<Person> personList = new ArrayList<Person>();

因此,泛型也可以说是定义一种模板,例如ArrayList<T>,然后在代码中为用到的类创建对应的ArrayList<类型>。(泛型是指在定义方法、接口或类的时候,不预先指定具体的类型,而使用的时候再指定一个类型的一个特性。)后面这种定义可能会更好理解其本质。

更为官方的定义是:泛型指“参数化类型”。泛型的本质是为了参数化类型(将类型参数化传递)(在不创建新的类型的情况下,通过泛型指定的不同类型来控制形参具体限制的类型)。也就是说在泛型使用过程中,操作的数据类型被指定为一个参数,这种参数类型,可以在类、接口和方法中,分别被称为泛型类,泛型接口,泛型方法。

2. 为什么要使用泛型?

参考自:Oracle 泛型文档

与非泛型的代码相比,使用泛型的代码具有很多优点:

1.在编译时会有更强的类型检查

Java编译器对泛型代码进行强类型检查,如果代码违反类型安全,则会发出错误。修复编译时的错误比修复运行时的错误会更加简单,运行时的错误会更难找到。

说人话就是,使用泛型时,编译器会对输入的类型的进行检查,类型与声明的类型不一致时就会报错。而不使用泛型,编译器可能就检测不到这个类型错误,就会在运行的时候报错。

2.消除类型转换

下面的代码是没有使用泛型的情况,这时候需要对类型进行转换

List list = new ArrayList();
list.add("hello");
String s = (String) list.get(0);

使用泛型,就不需要对类型进行转换


List<String> list = new ArrayList<String>();
list.add("hello");
String s = list.get(0);   // no cast

3.可以实现更通用的算法

通过使用泛型,程序员可以对不同类型的集合进行自定义操作以实现通用算法,并且代码类型会更加安全、代码更易读

3. 如何使用泛型?

还是以ArrayList为例,如果不定义泛型类型时,泛型类型此时就是Object:


// 编译器警告:
List list = new ArrayList();
list.add("Hello");
list.add("World");
String first = (String) list.get(0);
String second = (String) list.get(1);

此时,只能把<T>当作Object使用,没有发挥泛型的优势。

当我们定义泛型类型<String>后,List<T>的泛型接口变为强类型List<String>:

// 无编译器警告:
List<String> list = new ArrayList<String>();
list.add("Hello");
list.add("World");
// 无强制转型:
String first = list.get(0);
String second = list.get(1);

编译器看到泛型类型List<String>就可以自动推断出后面的ArrayList<T>的泛型类型必须是ArrayList<String>,因此,可以把代码简写为:

// 可以省略后面的Number,编译器可以自动推断泛型类型:
List<String> list = new ArrayList<>();

3.1 泛型类
泛型类的语法形式:


class name<T1, T2, ..., Tn> { /* ... */ }

泛型类的声明和非泛型类的声明类似,除了在类名后面添加了类型参数声明部分。由尖括号(<>)分隔的类型参数部分跟在类名后面。它指定类型参数(也称为类型变量)T1,T2,…和 Tn。

一般将泛型中的类名称为原型,而将 <> 指定的参数称为类型参数。

在泛型出现之前,一个类要想处理所有类型的数据,只能使用Object做数据转换。实例如下:


public class Info {
	private Object value;

	public Object getValue() {
		return value;
	}

	public void setValue(Object value) {
		this.value = value;
	}
}

使用泛型之后,其实就是将Object换成T,并声明<T>:


public class Info<T> {
	private T value;
    
    public T getValue() {
        return value;
    }
    
    public void setValue(T value) {
        this.value = value;
    }
}

在上面的例子中,在初始化一个泛型类时,使用 <> 指定了内部具体类型,在编译时就会根据这个类型做强类型检查。

实际上,不使用 <> 指定内部具体类型,语法上也是支持的(不推荐这么做),这样的调用就失去泛型类型的优势。如下所示:


public static void main(String[] args) {
    Info info = new Info();
    info.setValue(10);
    System.out.println(info.getValue());
    info.setValue("abc");
    System.out.println(info.getValue());
}

上面是单个类型参数的泛型类。

下面我们看一下多个类型参数的泛型类该如何编写。

例如,我们定义Pair不总是存储两个类型一样的对象,就可以使用类型<T, K>:

public class Pair<T, K> {
    private T first;
    private K last;
    
    public Pair(T first, K last) {
        this.first = first;
        this.last = last;
    }
    
    public T getFirst() { 
    	return first;
    }
    
    public K getLast() { 
    	return last;
    }
}

使用的时候,需要指出两种类型:

Pair<String, Integer> p = new Pair<>("test", 123);

Java标准库的Map<K, V>就是使用两种泛型类型的例子。它对Key使用一种类型,对Value使用另一种类型。

小结

编写泛型时,需要定义泛型类型<T>;

泛型可以同时定义多种类型,例如Map<K, V>。

3.2 泛型接口
接口也可以声明泛型。

泛型接口语法形式:


public interface Content<T> {
    T text();
}

泛型接口有两种实现方式:

实现接口的子类明确声明泛型类型

预先声明继承的具体类型的接口类,下面就是继承的Integer类型的接口类。


public class IntContent implements Content<Integer> {
    private int text;

    public IntContent(int text) {
        this.text = text;
    }

    @Override
    public Integer text() { 
        return text; 
    }
}

因为子类并没有泛型类型,所以正常使用就行。


InContent ic = new IntContent(10);

实现接口的子类不明确声明泛型类型


public class GenericsContent<T> implements Content<T> {
    private T text;

    public GenericsContent(T text) {
        this.text = text;
    }

    @Override
    public T text() { 
        return text; 
    }
}

此时子类也使用了泛型类型,就需要指定具体类型

Content<String> gc = new GenericsContent<>("ABC");

3.3 泛型方法
泛型方法是引入其自己的类型参数的方法。泛型方法可以是普通方法、静态方法以及构造方法。

泛型方法语法形式如下:


public <T> T func(T obj) {}

注意:是否拥有泛型方法,与其所在的类是否是泛型没有关系。

泛型方法的语法包括一个类型参数列表,在尖括号内,它出现在方法的返回类型之前。对于静态泛型方法,类型参数部分必须出现在方法的返回类型之前。类型参数能被用来声明返回值类型,并且能作为泛型方法得到的实际类型参数的占位符。

**使用泛型方法的时候,通常不必指明类型参数,因为编译器会为我们找出具体的类型。这称为类型参数推断(type argument inference)。类型推断只对赋值操作有效,其他时候并不起作用。**如果将一个泛型方法调用的结果作为参数,传递给另一个方法,这时编译器并不会执行推断。

编译器会认为:调用泛型方法后,其返回值被赋给一个 Object 类型的变量。


public class GenericsMethodDemo01 {
    public static <T> void printClass(T obj) {
        System.out.println(obj.getClass().toString());
    }

    public static void main(String[] args) {
        printClass("abc");
        printClass(10);
    }
}
// Output:
// class java.lang.String
// class java.lang.Integer

泛型方法中也可以使用可变参数列表


public class GenericVarargsMethodDemo {
    public static <T> List<T> makeList(T... args) {
        List<T> result = new ArrayList<T>();
        Collections.addAll(result, args);
        return result;
    }

    public static void main(String[] args) {
        List<String> ls = makeList("A");
        System.out.println(ls);
        ls = makeList("A", "B", "C");
        System.out.println(ls);
    }
}
// Output:
// [A]
// [A, B, C]

4. 泛型的特性

4.1 类型擦除(Type Erasure)
Java 语言引入泛型是为了在编译时提供更严格的类型检查,并支持泛型编程。不同于 C++ 的模板机制,Java 泛型是使用类型擦除来实现的,使用泛型时,任何具体的类型信息都被擦除了。

那么,类型擦除做了什么呢?它做了以下工作:

把泛型中的所有类型参数替换为 Object,如果指定类型边界,则使用类型边界来替换。因此,生成的字节码仅包含普通的类,接口和方法。
擦除出现的类型声明,即去掉 <> 的内容。比如 T get() 方法声明就变成了 Object get() ;List<String> 就变成了 List。如有必要,插入类型转换以保持类型安全。
生成桥接方法以保留扩展泛型类型中的多态性。类型擦除确保不为参数化类型创建新类;因此,泛型不会产生运行时开销。

Java 泛型的实现方式不太优雅,但这是因为泛型是在 JDK5 时引入的,为了兼容老代码,必须在设计上做一定的折中。

简单来说类型擦除是指,虚拟机对泛型其实一无所知,所有的工作都是编译器做的。

例如,我们编写了一个泛型类Pair,这是编译器看到的代码:


public class Pair<T> {
    private T first;
    private T last;
    public Pair(T first, T last) {
        this.first = first;
        this.last = last;
    }
    public T getFirst() {
        return first;
    }
    public T getLast() {
        return last;
    }
}

而虚拟机根本不知道泛型。这是虚拟机执行的代码:


public class Pair {
    private Object first;
    private Object last;
    public Pair(Object first, Object last) {
        this.first = first;
        this.last = last;
    }
    public Object getFirst() {
        return first;
    }
    public Object getLast() {
        return last;
    }
}

因此,Java使用类型擦拭实现泛型,导致了:

编译器把类型<T>视为Object;
编译器根据<T>实现安全的强制转型。
因此,Java使用擦拭法实现泛型,导致了:

编译器把类型<T>视为Object;
编译器根据<T>实现安全的强制转型。
使用泛型的时候,我们编写的代码也是编译器看到的代码:


Pair<String> p = new Pair<>("Hello", "world");
String first = p.getFirst();
String last = p.getLast();

而虚拟机执行的代码并没有泛型:


Pair p = new Pair("Hello", "world");
String first = (String) p.getFirst();
String last = (String) p.getLast();

所以,Java的泛型是由编译器在编译时实行的,编译器内部永远把所有类型T视为Object处理,但是,在需要转型的时候,编译器会根据T的类型自动为我们实行安全地强制转型。

泛型的局限

了解了Java泛型的实现方式——类型擦除,我们就知道了Java泛型的局限:

局限一:<T>不能是基本类型,例如int,因为实际类型是Object,Object类型无法持有基本类型:

Pair<int> p = new Pair<>(1, 2); // compile error!

局限二:无法取得带泛型的Class。观察以下代码:


public class test {
    public static void main(String[] args) {
        List<Object> list1 = new ArrayList<Object>();
        List<String> list2 = new ArrayList<String>();
        System.out.println(list1.getClass());
        System.out.println(list2.getClass());
    }
}
// Output:
// class java.util.ArrayList
// class java.util.ArrayList

因为T是Object,我们对ArrayList<Object>和ArrayList<String>类型获取Class时,获取到的是同一个Class,也就是ArrayList类的Class。

换句话说,所有泛型实例,无论T的类型是什么,getClass()返回同一个Class实例,因为编译后它们全部都是ArrayList<Object>。

局限三:无法判断带泛型的类型:


List<Integer> p = new ArrayList<>();
// Compile error:
if (p instanceof List<String>) {
}

原因和前面一样,并不存在List<String>.class,而是只有唯一的List.class。

泛型和继承

正是由于泛型时基于类型擦除实现的,所以,泛型类型无法向上转型。

向上转型是指用子类实例去初始化父类,这是面向对象中多态的重要表现。

在这里插入图片描述

Integer 继承了 Object;ArrayList 继承了 List;但是 List<Interger> 却并非继承了 List<Object>。

这是因为,泛型类并没有自己独有的 Class 类对象。比如:并不存在 List<Object>.class 或是 List<Interger>.class,Java 编译器会将二者都视为 List.class。

4.2 上边界
在使用泛型的时候,我们还可以为传入的泛型类型实参进行上下边界的限制,如:类型实参只准传入某种类型的父类或某种类型的子类。

extend通配符

为泛型添加上边界,即传入的类型实参必须是指定类型的子类型


// 可以限制传入方法的参数的类型
<? extends xxx>
// 也可以限制T的类型
<T extends XXX>
// 类型边界可以设置多个,语法形式如下:
<T extends B1 & B2 & B3>

注意:extends 关键字后面的第一个类型参数可以是类或接口,其他类型参数只能是接口。

<? extends xxx>

举个例子:

public class test {  
    public static void main(String[] args) {
        Pair<Integer> p = new Pair<>(123, 456);
        int n = add(p);
        System.out.println(n);
    }

    static int add(Pair<? extends Number> p) {
        Number first = p.getFirst();
        Number last = p.getLast();
        return first.intValue() + last.intValue();
    }
}

class Pair<T> {
    private T first;
    private T last;
    public Pair(T first, T last) {
        this.first = first;
        this.last = last;
    }
    public T getFirst() {
        return first;
    }
    public T getLast() {
        return last;
    }
}

通过使用<? extends Number>,我们可以传入Number类型的子类类型的数组。就可以执行数值类型的加法。

这种使用<? extends Number>的泛型定义称之为上界通配符(Upper Bounds Wildcards),即把泛型类型T的上界限定在Number了。除了可以传入Pair<Integer>类型,我们还可以传入Pair<Double>类型,类型等等,因为Double和BigDecimal都是Number的子类。

如果我们考察对Pair<? extends Number>类型调用getFirst()方法,实际的方法签名变成了:

<? extends Number> getFirst();
接下来,我们再来考察一下Pair<T>的set方法:

public class test {  
    public static void main(String[] args) {
        Pair<Integer> p = new Pair<>(123, 456);
        int n = add(p);
        System.out.println(n);
    }

    static int add(Pair<? extends Number> p) {
        Number first = p.getFirst();
        Number last = p.getLast();
        p.setFirst(new Integer(first.intValue() + 100));
        p.setLast(new Integer(last.intValue() + 100));
        return p.getFirst().intValue() + p.getFirst().intValue();
    }
}

class Pair<T> {
    private T first;
    private T last;
    public Pair(T first, T last) {
        this.first = first;
        this.last = last;
    }
    public T getFirst() {
        return first;
    }
    public T getLast() {
        return last;
    }
    public void setFirst(T first) {
        this.first = first;
    }
    public void setLast(T last) {
        this.last = last;
    }
}

// 会得到一个编译错误
// The method setFirst(capture#3-of ? extends Number) in the type Pair<capture#3-of ? extends Number> is not applicable for the arguments (int)Java(67108979)

编译错误的原因在于,如果一开始我们传入的p是Pair<Double>,显然它满足参数定义Pair<? extends Number>,然而,Pair<Double>的setFirst()显然无法接受Integer类型。

这就是<? extends Number>通配符的一个重要限制:方法参数签名setFirst(? extends Number)无法传递任何Number的子类型给setFirst(? extends Number)。

这里唯一的例外是可以给方法参数传入null:

p.setFirst(null); // ok, 但是后面会抛出NullPointerException
p.getFirst().intValue(); // NullPointerException

使用extends限定T类型

在定义泛型类型Pair<T>的时候,也可以使用extends通配符来限定T的类型:

public class Pair<T extends Number> { ... }

现在,我们只能定义:

Pair<Number> p1 = null;
Pair<Integer> p2 = new Pair<>(1, 2);
Pair<Double> p3 = null;

因为Number、Integer和Double都符合<T extends Number>。

非Number类型将无法通过编译:

Pair<String> p1 = null; // compile error!
Pair<Object> p2 = null; // compile error!

因为String、Object都不符合<T extends Number>,因为它们不是Number类型或K的子类。

小结

使用类似<? extends Number>通配符作为方法参数时表示:

方法内部可以调用获取Number引用的方法,例如:Number n = obj.getFirst();;
方法内部无法调用传入Number引用的方法(null除外),例如:obj.setFirst(Number n);。
即一句话总结:使用extends通配符表示可以读,不能写。

使用类似<T extends Number>定义泛型类时表示:

  • 泛型类型限定为Number以及Number的子类。

4.3 下边界
super 下界通配符将未知类型限制为该类型的特定类型或超类类型。

和extends通配符相反,这次,我们希望接受Pair<Integer>类型,以及Pair<Number>、Pair<Object>,因为Number和Object是Integer的父类,setFirst(Number)和setFirst(Object)实际上允许接受Integer类型。

我们使用super通配符来改写这个方法:

void set(Pair<? super Integer> p, Integer first, Integer last) {
    p.setFirst(first);
    p.setLast(last);
}

注意到Pair<? super Integer>表示,方法参数接受所有泛型类型为Integer或Integer父类的Pair类型。

这里注意到我们无法使用Integer类型来接收getFirst()的返回值,即下面的语句将无法通过编译:

Integer x = p.getFirst();
因为如果传入的实际类型是Pair<Number>,编译器无法将Number类型转型为Integer。

因此,使用<? super Integer>通配符表示:

允许调用set(? super Integer)方法传入Integer的引用;
不允许调用get()方法获得Integer的引用。
唯一例外是可以获取Object的引用:Object o = p.getFirst()。

换句话说,使用<? super Integer>通配符作为方法参数,表示方法内部代码对于参数只能写,不能读。

对比extends和super通配符

我们再回顾一下extends通配符。作为方法参数,<? extends T>类型和<? super T>类型的区别在于:

<? extends T>允许调用读方法T get()获取T的引用,但不允许调用写方法set(T)传入T的引用(传入null除外);
<? super T>允许调用写方法set(T)传入T的引用,但不允许调用读方法T get()获取T的引用(获取Object除外)。
一个是允许读不允许写,另一个是允许写不允许读。

4.4 无限定通配符
我们已经讨论了<? extends T>和<? super T>作为方法参数的作用。实际上,Java的泛型还允许使用无限定通配符(Unbounded Wildcard Type),即只定义一个?:

void sample(Pair<?> p) {
}
因为<?>通配符既没有extends,也没有super,因此:

不允许调用set(T)方法并传入引用(null除外);
不允许调用T get()方法并获取T引用(只能获取Object引用)。

无界通配符有两种应用场景:

  • 可以使用 Object 类中提供的功能来实现的方法。
  • 使用不依赖于类型参数的泛型类中的方法。

语法形式:<?>

public class GenericsUnboundedWildcardDemo {
    public static void printList(List<?> list) {
        for (Object elem : list) {
            System.out.print(elem + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        List<Integer> li = Arrays.asList(1, 2, 3);
        List<String> ls = Arrays.asList("one", "two", "three");
        printList(li);
        printList(ls);
    }
}
// Output:
// 1 2 3
// one two three

小结

使用类似<? super Integer>通配符作为方法参数时表示:

方法内部可以调用传入Integer引用的方法,例如:obj.setFirst(Integer n);;
方法内部无法调用获取Integer引用的方法(Object除外),例如:Integer n = obj.getFirst()。
即使用super通配符表示只能写不能读。

无限定通配符<?>很少使用,可以用<T>替换,同时它是所有<T>类型的超类。

4.5 泛型命名
泛型一些约定俗成的命名(实际并无意义,但是建议对应着来命名泛型):

  • E - Element
  • K - Key
  • N - Number
  • T - Type
  • V - Value
  • S,U,V etc. - 2nd, 3rd, 4th types

5. end

理解泛型之后可以方便我们更好的阅读Java框架的源码,实际编程来说不一定会用到,但是可以用到泛型编程的地方,建议使用,可以简化代码。

6. 参考资料

廖雪峰Java
深入理解Java泛型
Oracle Java文档

使用 ChatGPT/Copilot 提升前端开发效率的 N 种方式 typescript// 输入:根据这个 JavaScript 对象,生成完整的 TypeScript 类型定义id: '123',stock: 50,},// ChatGPT 生成:id: string;discount?: number;// 可选属性// 只读属性// 更进一步,生成 Zod schema 用于运行时验证:});}),});AI 代码助手真正的革命性不在于它能生成多少代码,而在于它改变了我们解决问题的方式。 阅读详情

相关推荐

MacOS Intel芯片实战:Docker Compose一键部署Dify全流程解析

本文详细解析了在搭载Intel芯片的MacOS系统上,使用Docker Compose一键部署开源LLM应用开发平台Dify的全流程。内容涵盖环境准备、Docker配置与镜像加速、代码拉取与配置初始化、服务启动与问题排查,以及访问验证与初步探索,旨在帮助开发者快速在本地搭建私有化AI应用开发环境。

ik678901234的博客 620

Java 泛型

泛型的本质是参数化类型,即给类型指定一个参数,然后在使用时再指定此参数具体的值,那样这个类型就可以在使用时决定了。这种参数类型可以用在类、接口和方法中,分别被称为泛型类、泛型接口、泛型方法。注意:一般在创建对象时,将未知的类型确定具体的类型。当没有指定泛型时,默认类型为Object类型。

weixin_47203903的博客 1562

Sparse4Dv3 代码复现

打包数据集的元信息和标签,并生成所需的.pkl文件。最后还输出了很多跟踪相关的东西...然后通过K-means生成锚点。编译可变形聚合CUDA算子。安装motmetrics。

m0_60857098的博客 4490

java中的泛型

符号进行连接,并且规定在这多个上限中,至多有一个父类上限,但可以有多个接口上限,表明该类型形参必须是其父类的子类(包括其父类本身),并且可以实现多个上限接口,父类在前接口在后。为了解决这个问题,JDK1.5引入了泛型的概念,让我们可以在程序中用某种方式表示完全未知的类型,使得程序顺利编写并通过编译,等到使用时再确定它的具体类型。假如我们有一个新需求,要求学生类的成绩仍然是未确定的类型,但它必须是如下的数字类型之一,不能是String等其他非数字类型。也可以指定上限,这两种的语法格式和要求是一样的。

冲出仁川,走出马德里,故事还会再继续 1663

支付逻辑漏洞的八大姿势(上篇)

学习支付漏洞,看这篇文章!!!文章来源:SecHub网络安全社区(本资料仅供学习参考,严禁使用者进行未授权渗透测试!严禁任何形式的转载!

qq_39493066的博客 1360

手把手教你学Simulink--基于新能源与储能系统的场景实例:压缩空气储能(CAES)系统热力学建模

本文介绍了使用Simulink进行压缩空气储能(CAES)系统热力学建模的详细步骤。系统模型包含压缩机、储气装置、膨胀机、热交换器和控制器等核心模块,通过MATLAB函数计算各部件参数,并设置仿真条件。文章详细说明了从模型创建到性能评估的完整流程,包括压缩/膨胀过程的能量转换、温度压力变化等关键指标分析。该建模方法可验证设计方案的有效性,并为系统优化提供参考,适用于新能源与储能领域的研究与应用。

MHD0815的博客 9201

Java编程笔记14:泛型(续)

Java编程笔记14:泛型(续) 图源:PHP中文网 问题 在前文已经说过,Java因为历史原因,实现的泛型机制是不完整的,因此存在一些问题(限制),下面来详细讨论这些问题以及解决方案。 无法使用基本类型 Java的泛型存在很多限制,无法使用基本类型就是其中之一,幸运的是因为包装类的存在,在大多数情况下“自动解包”和“自动打包”都可以帮我们解决将基础类型应用到泛型的相关问题。 package ch14.base_type; import java.util.ArrayList; import java.

梦幻天空 452

从零开始:手把手教你设计人形机器人锂电池供电系统

人形机器人要像人类一样“活起来”,必须有稳定的“能量血液”——供电系统。本文聚焦锂电池供电系统如何根据机器人功耗选择合适的锂电池参数(容量、电压、放电倍率);如何设计电池管理系统(BMS)保护电池安全;如何解决机器人运动时的“瞬时大电流”供电难题;如何通过硬件电路和代码实现供电系统的监测与控制。用“机器人小助手的能量危机”故事引入锂电池供电系统;拆解锂电池核心参数(容量、电压、放电倍率)和供电系统三大组件(电池组、BMS、电源转换模块);

AI天才研究院 1761

无涯教程-Java泛型 - 命名约定

按照惯例,类型参数名称被命名为单个大写字母,以便可以使用普通的类或接口名称区分类型参数。无涯教程网提供按照惯例,类型参数名称被命名为单个大写字母,以便可以使用普通的类或接口名称区分类...V 值 - 主要用于表示Map的值的参数类型。K 键 - 主要用于表示Map键的参数类型。T 类型 - 主要用于表示第一个通用类型参数。S 类型 - 主要用于表示第二个泛型类型参数。U 类型 - 主要用于表示第三个通用类型参数。V 类型 - 主要用于表示第四个泛型类型参数。

无涯教程 1066

ARFoundation系列讲解 - 24 锚点

一、添加平面检测和平面可视化 请参考 ARFounnation快速入门-08平面检测 案例 二、添加射线检测 1.在AR Session Origin 组件上添加ARRaycastManager 脚本

a451319296的博客 4881

Ros入门 (十)----激光雷达避障 简易实现

本篇文章通过订阅/scan话题获取障碍物的距离信息,达到避障目的,提供部分代码,仅供参考。

weixin_51157015的博客 1万+

Java 基础知识——泛型

泛型概念及应用,包括泛型类、接口、方法,通配符,泛型限定的应用,最后是泛型的局限性。

敲代码的小李同学的博客 2159

【YOLOv11工业级实战】15. YOLOv11海洋监测实战:珊瑚礁健康评估(水下图像增强|机器人搭载)

摘要:本文针对珊瑚礁健康评估的海洋监测需求,基于YOLOv11提出解决方案,聚焦水下色偏、悬浮物干扰、珊瑚形态复杂三大难题。引用全球珊瑚礁监测网络(GCRMN)标准,采用CoralNet数据集,通过Jaffe-McGlamery物理模型引导增强与悬浮物去除算法,在浑浊水域(能见度<5m)实现87.3%的健康珊瑚识别率,藻类误判率低至7.2%。介绍了以BlueROV2水下机器人和Jetson AGX Orin为核心的部署方案,结合水下SLAM定位技术,实现珊瑚健康的实时评估与三维覆盖率计算。

专注于人工智能、软件开发、工控自动化、工厂数字化及智能化等领域,希望和大家共同进步! 1644

Java泛型学习

一、 序言 一直在用的语言是Java,本以为掌握的已经不错了,但最近面试才发现之前自己只是停留在熟料使用的状态,距离编写出优雅,高可复用的代码还有一定的距离。强烈建议大家有机会一定要去看一下JDK源码,写的非常漂亮,可以学到不少东西! 二、 泛型 为什么要使用泛型? 进行日常开发时,当面对有重复的代码时,我们自然而然的将公共部分抽取出来封装成一个函数或方法,然后进行频繁调用。同样的道理,在进行功...

Michael Hsu 393

Probability and Statistics - 4th edition

Probability and Statistics - 4th edition

pscad IEEE标准系统搭建说明

pscad IEEE标准系统搭建说明,包含典型的IEEE 9节点、14节点、30节点、39节点和118节点系统。内含标准测试系统的原始数据和潮流结果。

122. Java 泛型 - 原始类型

Java泛型中的原始类型是指未指定类型参数的泛型类或接口,如Box而非Box<Integer>。原始类型会失去泛型的类型安全特性,退化为Object类型,允许存储任意数据。使用原始类型会导致编译器发出未检查转换警告,可能引发运行时错误。虽然可以通过@SuppressWarnings抑制警告,但建议避免使用原始类型以保持类型安全。编译时使用-Xlint:unchecked可查看详细警告信息。

yaoxin521123的博客 1007

计算机控制技术及应用

《计算机控制技术及应用》通过总结作者的科研成果和吸收国内外的先进理论、方法和技术,以计算机控制系统的网络化、开放化、智能化和集成化发展趋势为主线索,主要介绍计算机控制系统的基本概念和计算机控制系统的典型形式,计算机控制系统的数学描述与基本分析方法,以及数字PID控制器、最少拍控制系统、达林算法、状态变量设计法等设计方法及其各种改进算法。重点突出计算机控制系统输入输出通道接口的设计方法和典型控制系统的设计案例与实现方法等。

hashmap 泛型_泛型的高级使用_容器中使用泛型

1、 泛型的高级使用 (1)泛型的上限:使用关键字extends,表示参数化的类型可能是所指定的类型或者是该类型的子类。(2)泛型的下限:使用关键字super,表示参数化的类型可能是所指定的类型,或者是此类型的父类型,直至Object类。import java.util.ArrayList; public class Test { public static void main(String[]...

weixin_39850331的博客 402

efm32 入门.pdf

本PDF共计22页,介绍的是操作驱动API,下载与否自己斟酌。

1.泛型和链表

1.泛型和链表 1.泛型 1.什么是泛型 1.英文含义: ​ generic paradigm一般类型 2.泛型的含义: ​ 泛型是一种未知的数据类型不像 int string 一样直接去内存中申请空间而是在确定泛型的类型的时候才会去申请内存空间。 3.应用场景: ​

m0_50551074的博客 665

Java 容器泛型_底层源码解读 尚学堂133

先上代码: import java.util.List; import java.util.ArrayList; import java.util.Map; import java.util.HashMap; public class Test { public static void main(String[] args) { List<String> list = new ArrayList<String>(); Map map = new HashMap();.

BOKEhhh的博客 236

泛型简介

This article describes the advantages of generics in Java in relation to type safety and the rationale for introducing it in Java 5.本文介绍了Java与类型安全有关的泛型优势以及在Java 5中引入泛型的原理。 为什么要泛型? (Why Generics?) Con...

weixin_26729165的博客 199

java泛型详解(转)

java泛型详解 (转)博客参考 转载 凌冰_ 最后发布于2016-07-01 16:05:44 阅读数 236 收藏 展开 为什么引入泛型 bug是编程的一部分,我们只能尽自己最大的能力减少出现bug的几率,但是谁也不能保证自己写出的程序不出现任何问题。 错误可分为两种:编译时错误与运行时错误。编译时错误在编译时可以发现并排除,而运行时错误具有很大的不确定性,在程序运行时才能发现,造成的后果可能...

u013078871的博客 496

容器一(泛型、Collection 接口)

可以在类的声明处增加泛型列表,如:。此处,字符可以是任何标识符, 一般采用这 3 个字母。class MyCollection {// E:表示泛型;public E get(int index) {// E:表示泛型;public void set(E e, int index) {// E:表示泛型;泛型 E 像一个占位符一样表示“未知的某个数据类型”,我们在真正调用的时候传入这个 “数据类型”。// 这里的”String”就是实际传入的数据类型;

m0_48205251的博客 1070

Java基础—枚举、注解、泛型、反射

一 、注解(Annotation) 注解就是代码里的特殊标记,可以在编译、类加载、运行时读取,并执行相应的处理。注解可以像修饰符一样使用,用于修饰包、类、构造器、方法、成员变量、参数等。 一定程度上:框架 = 注解 + 反射+设计模式 1.1 jdk内置的三个注解 @Override 重写父类方法 @Deprecated 标注已经过时的方法 @SuppressWarnings 抑制编译器警告 @SuppressWarnings("unuserd") 1.2 自定义注解 ...

光天化日红裤衩 162

java泛型详解

泛型就是,让类、接口、方法能够处理多种数据类型,而不需要为每种类型都写一份代码。泛型就像是Java的"万能模板",一份代码,多种用途,既安全又高效。

2301_77574331的博客 322

JAVA 泛型 入门

什么是泛型本质而言,指的是参数化类型。 参数化类型很重要,因为使用该特性创建的类,接口以及方法,可以作为参数指定所操作数据的类型。 上面的这个是名词解释,看了是不是一头雾水,跟天书一样。 风.fox 可以这么理解 规定了变量数据类型是数值型,你就必须传输数值型的,传输其他类型的就会错误。class Box<T>{ T ob; Box(T o){ ob=o;

风.foxwho(神秘狐) 987

Java学习笔记(10)——枚举和注解和泛型

Java学习笔记(10)——枚举和注解 1 枚举 1.1. 枚举类的说明: 枚举类的理解:类的对象只有有限个,确定的。我们称此类为枚举类 当需要定义一组常量时,强烈建议使用枚举类 如果枚举类中只一个对象,则可以作为单例模式的实现方式。 1.2 如何自定义枚举类?步骤: //自定义枚举类 class Season{ //1.声明Season对象的属性:private final修饰 private final String seasonName; private final Str

Chris683的博客 466

泛型之多种类型参数

package fft.generics; //定义接口,接口中使用泛型 public interface Pair {          public K getKey();          public V getValue(); } package fft.generics; /**  *  * @ClassName: Order

hongweideng的专栏 3735
上一篇: VsCode之Bookmarks插件使用(书签,快速跳转)
下一篇: HTTP状态码,100--505错误代码中文英文(建议收藏)
亦小柒
博客等级 码龄8年 10粉丝 17原创
评论 2
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值