Riguz：Riguz移动页面Blog:关于 Java泛型至Java generics，不留重定向

2023-12-19T06:02:05Z

Riguz移动页面Blog:关于 Java泛型至Java generics，不留重定向

←上一版本	2023年12月19日 (二) 06:02的版本
（没有差异）

imported>Riguz：泛型是Java1.5之后一个比较有用的特性，有点类似于C++的模板。最简单的一个例子： ```java class Wrapper { final T data; Wrapper(T data) { this.data = data; } } ``` 有一些可能不是特别常用的Generics，我们来简单看一下。

2017-12-21T00:00:00Z

泛型是Java1.5之后一个比较有用的特性，有点类似于C++的模板。最简单的一个例子： ```java class Wrapper<T> { final T data; Wrapper(T data) { this.data = data; } } ``` 有一些可能不是特别常用的Generics，我们来简单看一下。

新页面

泛型是Java1.5之后一个比较有用的特性，有点类似于C++的模板。最简单的一个例子：

<syntaxhighlight lang="java">
class Wrapper<T> {
final T data;

Wrapper(T data) {
this.data = data;
}
}
</syntaxhighlight>
有一些可能不是特别常用的Generics，我们来简单看一下。

= Bounded Generics=
== Multiple bound==
如果一个类继承了多个接口，是这样的写法：
<syntaxhighlight lang="java">
interface I {}
interface M {}
abstract class C {}

class Foo extends C implements I,M {}
</syntaxhighlight>
假如一个方法的泛型参数包含多个Bound，则要这样写了：
<syntaxhighlight lang="java">
<T extends I & M> void bar(T arg){}
<T extends C> void ooo(T arg){}
<T extends C & I & M> void xxx(T arg){}
</syntaxhighlight>
== Unbounded wildcards==

使用 ? 修饰符可以用作类型转换，List<?> 意味着是一个未知类型的List，可能是`List<A>` 也可能是`List<B>`
<syntaxhighlight lang="java">
private final List<String> strList = Arrays.asList("Hello", "World!");
private final List<Integer> intList = Arrays.asList(1, 2, 3);
private final List<Float> floatList = Arrays.asList(1.1f, 2.1f, 3.1f);
private final List<Number> numberList = Arrays.asList(1, 1.0f, 3000L);

public void cast() {
List<?> unknownList = null;
unknownList = strList;
unknownList = intList;
unknownList = floatList;
unknownList = numberList;

for (int i = 0; i < unknownList.size(); i++) {
// Number item = unknownList.get(i); wrong!
Object item = unknownList.get(i);
System.out.println(item + "(" + item.getClass() + ")");
}
}
/* output
1(class java.lang.Integer)
1.0(class java.lang.Float)
3000(class java.lang.Long)
*/
</syntaxhighlight>
== Upper bounded wildcards==

<syntaxhighlight lang="java">
public static double sumOfList(List<? extends Number> list) {
double s = 0.0;
for (Number n : list)
s += n.doubleValue();
return s;
}
//...
sumOfList(Arrays.asList(1, 2, 3));
sumOfList(Arrays.asList(1.0f, 2.0f, 3.0f));
</syntaxhighlight>

== Lower bounded wildcards==

<syntaxhighlight lang="java">
public static void addNumbers(List<? super Number> list) {
for (int i = 1; i <= 10; i++) {
list.add(i);
list.add(1.0f);
}
}
addNumbers(new ArrayList<Number>());
</syntaxhighlight>

= Type erase=
== Type erase process==

Java的泛型是编译时有效的，在运行时，所有泛型参数会被编译器擦除。擦除的规则如下：

* 如果参数是有Bound的，则会替换成这个Bound
* 如果是Unbounded，则会替换成Object

如下所示：

<syntaxhighlight lang="java">
public class Node<T> { // public class Node {
private T data; // private Object data;
private Node<T> next; // private Node next;
public Node(T data, Node<T> next) { // public Node(Object data, Node next) {
this data = data; // this data = data;
this next = next; // this next = next;
} // }
//
public T getData() { return data; } // public Object getData() { return data; }
} // }

public class Node<T extends Comparable<T>> { // public class Node {
private T data; // private Comparable data;
private Node<T> next; // private Node next;
public Node(T data, Node<T> next) { // public Node(Comparable data, Node next) {
this.data = data; // this.data = data;
this.next = next; // this.next = next;
} // }
//
public T getData() { return data; } // public Comparable getData() { return data; }
} // }
</syntaxhighlight>
== Bridge method==
按照上面的擦除也会带来问题。考虑下面的例子，如果有一个子类：
<syntaxhighlight lang="java">
public class MyNode extends Node<Integer> { // public class MyNode extends Node {
public MyNode(Integer data) { super(data); } // public MyNode(Integer data) { super(data); }
//
public void setData(Integer data) { // public void setData(Integer data) {
System.out.println("MyNode.setData"); // System.out.println("MyNode.setData");
super.setData(data); // super.setData(data);
} // }
} // }
</syntaxhighlight>
然后，我们考虑如下的代码：
<syntaxhighlight lang="java">
MyNode mn = new MyNode(5); // MyNode mn = new MyNode(5);
Node n = mn; // Node n = (MyNode)mn;
n.setData("Hello"); // n.setData("Hello");
Integer x = mn.data; // Integer x = (String)mn.data;
</syntaxhighlight>
这里调用setData则会参数类型不能匹配。为了解决这个问题，Java编译器会生成一个Bridge method:
<syntaxhighlight lang="java">
public void setData(Object data) {
setData((Integer) data);
}
</syntaxhighlight>

= Q&A=

== List\<?\> vs List\<Object\>==

>It's important to note that List<Object> and List<?> are not the same. You can insert an Object, or any subtype of >Object, into a List<Object>. But you can only insert null into a List<?>.

== extends vs super==

实际上泛型仅仅是为了做一个编译时的检查，从逻辑上确保程序是类型安全的。假设我们有这样的类定义：
Object->Parent->T->Child
我们有这样几种写法：

* ```List<?>``` 代表一种未知类型的List，可能是```List<Object>```，也可能是```List<Child>```，都可以
* ```List<? extends T>``` 代表T或者T的子类的List，可以是```List<T>```，也可以是```List<Child> ```
* ```List<? super T>``` 代表T或者T的父类的List，可以是```List<T>，List<Parent>，List<Object>```

我们有一个事实就是，Child是一定可以转化T或者Parent的，但是一个T不一定能转化成Child，因为可能会是别的子类。
比如我们现在做两个列表的拷贝，
<syntaxhighlight lang="java">
public static <T> void copy(List dest, List src)
</syntaxhighlight>
想实现从一个列表拷贝到另一个列表，比如
<syntaxhighlight lang="java">
List<Parent> parents;
List<T> ts;
List<Child> childs;
</syntaxhighlight>
基于上面说的类的继承的事实，ts/childs显然是可以转化成parents的，但是ts无法确保能转化成childs。因此我们的拷贝方法要这样定义：
<syntaxhighlight lang="java">
public class Collections {
public static <T> void copy
( List<? super T> dest, List<? extends T> src) { // uses bounded wildcards
for (int i=0; i<src.size(); i++)
dest.set(i,src.get(i));
}
}
</syntaxhighlight>
因为在desc.set()方法中，需要的是一个能够转化为T的对象的，src中<? extends T> 保证了src中的元素一定是一个T。

See also:

* [https://docs.oracle.com/javase/tutorial/java/generics/index.html Lesson: Generics (Updated)]

Java generics - 版本历史

Riguz：​Riguz移动页面Blog:关于 Java泛型至Java generics，不留重定向

imported>Riguz：​泛型是Java1.5之后一个比较有用的特性，有点类似于C++的模板。最简单的一个例子： ```java class Wrapper { final T data; Wrapper(T data) { this.data = data; } } ``` 有一些可能不是特别常用的Generics，我们来简单看一下。

Riguz：Riguz移动页面Blog:关于 Java泛型至Java generics，不留重定向

imported>Riguz：泛型是Java1.5之后一个比较有用的特性，有点类似于C++的模板。最简单的一个例子： ```java class Wrapper { final T data; Wrapper(T data) { this.data = data; } } ``` 有一些可能不是特别常用的Generics，我们来简单看一下。