java动态泛型

㈠ 你真的了解java中的泛型E、T、K、V吗

Java 泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许开发者在编译时检测到非法的类型。泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。

但是如果换成其他的字母代替 T ，在可读性上可能会弱一些。通常情况下，T，E，K，V，？是这样约定的：？表示不确定的 java 类型。T (type) 表示具体的一个java类型。K V (key value) 分别代表java键值中的Key Value。E (element) 代表Element。

㈡ java泛型

java泛型是1.5引进的一个新概念.
本题对于"? super T"和"? extends T",我从书上摘个经典的例子给你看看,如果不能理解,那么你就参考以下书籍慢慢体会,循序渐进!

"? super T"和"? extends T",都是java泛型通配符,而用法又有区别,
还有super 和extends 不是java类关系中的超类和继承的意思,他是通配符的下限和上限限制.

下面看一个通配符得高级用法:
在这一部分，我们来考虑一些通配符得高级用法。我们已经看到了上限通配符在从一个数据结构中进行读取的几个例子。现在考虑相反的情况，一个只写的数据结构。

接口Sink是这种情况的一个简单例子。

interface Sink<T> {

void flush(T t);

}

我们可以想象他被如下面的代码一样使用。方法writeAll() 被设计来把集合coll的所有元素flush到sink snk，并且返回最后一个flush的元素。

public static <T> T writeAll(Collection<T> coll, Sink<T> snk) {

T last = null;

for (T t : coll) {

last = t;

snk.flush(last);

}

return last;

}

Sink<Object> s;

Collection<String> cs;

String str = writeAll(cs, s); // 非法的调用!!

像上面所写，writeAll() 的调用是非法的，因为没有有效的类型参数可以被推断出来。String 或 Object都不是T的合适的类型，因为Collection的元素和 Sink的元素必须是同样的类型。

我们可以解决这个问题，通过使用通配符来修改writeAll()的方法签名，如下：

<T> T writeAll(Collection<? extends T> coll, Sink<T> snk) { … }

String str = writeAll(cs, s); //可以调用但是返回值类型错误

这个调用现在是合法的，但是赋值产生错误，因为推断出的返回值类型是 Object因为T 匹配了Sink的类型，Object。

解决方案是使用一种我们还没有见过的有限制的通配符：有下限的通配符。语法 ? super T 表示T的一个未知的父类（或者是T自己）。这跟我们用? extends T 表示T的一个未知的子类是对应的。

<T> T writeAll(Collection<T> coll, Sink<? super T> snk) { … }

String str = writeAll(cs, s); // YES!!!

使用这个语法，这个调用是合法的，推断出来的T是String，正是我们想要的。

现在让我们看一个更现实的例子。一个 java.util.TreeSet<E> 代表一个有序的元素是E类型的树。创建一个TreeSet的一个方法是传递一个 Comparator 对象给构造函数。这个Comparator将会用来按照需要对TreeSet进行排序。

TreeSet(Comparator<E> c)

Comparator 接口是核心：

interface Comparator<T> { int compare(T fst, T snd); }

假定我们要创建一个 TreeSet<String> 并传递一个合适的 Comparator，我们需要传一个能比较String的Comparator。这可以是一个 Comparator<String>，也可以是一个 Comparator<Object>。然而我们不能用Comparator<Object>来调用上面的构造函数。我们可以使用一个有下限的通配符来得到我们需要的灵活性：

TreeSet(Comparator<? super E> c)

这允许任何可用的Comparator被传递进去。

作为使用下限通配符最终的例子，让我们来看看方法 Collections.max()，它返回一个集合中的最大的元素。

现在，为了让max()能工作，传进来的集合中的所有元素必须实现 Comparatable接口。而且，他们必须都能够被彼此比较（all be comparable to each other）。第一个尝试是：

public static <T extends Comparable<T>> T max(Collection<T> coll)

就是说，方法的参数是某一个能和自己进行比较的T的集合。这限制太严格了。

为什么？考虑一个能和任何对象进行比较的类型：

class Foo implements Comparable<Object> {...} ...

Collection<Foo> cf = ...;

Collections.max(cf); // 应该能工作

cf 中的每个元素都可以和每个cf中的其他元素进行比较，因为每个这样的元素都是一个Foo,它可以和任意的对象进行比较，也可以和另一个Foo进行比较。

但是，使用上面的方法签名，我们发现这个调用被拒绝。推断出来的类型必须是Foo，但是Foo没有实现接口 Comparable<Foo>。

T 精确的(exactly)和自己能比较是不需要的。所需要的是 T能够和它的父类中的一个进行比较，这导出：（注：Collections.max()的实际方法签名更复杂，我们在第10部分再讨论。）

public static <T extends Comparable<? super T>> T max(Collection<T> coll)

这个推论对大多数想让 Comparable 对任意类型生效的用法中都有效：你总是应该使用 Comparable<? super T>。

总之，如果你有一个只使用类型参数T作为参数的API，它的使用应该利用下限通配符( ? super T )的好处。相反的，如果API只返回T，你应该使用上限通配符( ? extends T )来给你的客户端更大的灵活性。

（原文：This reasoning applies to almost any usage of Comparable that is intended to work for arbitrary types: You always want to use Comparable<? super T>.

In general, if you have an API that only uses a type parameter T as an argument, its uses should take advantage of lower bounded wildcards (? super T). Conversely, if the API only returns T, you'll give your clients more flexibility by using upper bounded wildcards (? extends T). ）。

如果你想比较深刻的了解java泛型那么
建议你看看<Java1.5泛型指南>
中文链接地址:http://blog.csdn.net/explorers/archive/2005/08/15/454837.aspx#_Toc111865968
英文pdf格式地址:http://java.sun.com/j2se/1.5/pdf/generics-tutorial.pdf

㈢ java中什么是泛型，怎么用泛型

最简单的运用：List<String> list = new ArrayList<String>();
这个是什么意思？
意思就是list只装String类型的数据，别的，装不进去
然后你就会觉得这个好像有点封装的意思，比如LIst<Student>，封装学生类
所以，所谓泛型就是广泛的数据类型，你可以把它理解成封装

㈣ 学习java遇到的泛型问题，望大牛解答，感激不尽！

泛型（Generic type 或者generics）是对 Java 语言的类型系统的一种扩展，以支持创建可以按类型进行参数化的类。可以把类型参数看作是使用参数化类型时指定的类型的一个占位符，就像方法的形式参数是运行时传递的值的占位符一样。
可以在集合框架（Collection framework）中看到泛型的动机。例如，Map类允许您向一个Map添加任意类的对象，即使最常见的情况是在给定映射（map）中保存某个特定类型（比如String）的对象。
因为Map.get()被定义为返回Object，所以一般必须将Map.get()的结果强制类型转换为期望的类型，如下面的代码所示：

Map m = new HashMap();

m.put("key", "blarg");

String s = (String) m.get("key");

要让程序通过编译，必须将get()的结果强制类型转换为String，并且希望结果真的是一个String。但是有可能某人已经在该映射中保存了不是String的东西，这样的话，上面的代码将会抛出ClassCastException。
理想情况下，您可能会得出这样一个观点，即m是一个Map，它将String键映射到String值。这可以让您消除代码中的强制类型转换，同时获得一个附加的类型检查层，该检查层可以防止有人将错误类型的键或值保存在集合中。这就是泛型所做的工作。
泛型的好处
Java 语言中引入泛型是一个较大的功能增强。不仅语言、类型系统和编译器有了较大的变化，以支持泛型，而且类库也进行了大翻修，所以许多重要的类，比如集合框架，都已经成为泛型化的了。这带来了很多好处：
· 类型安全。泛型的主要目标是提高 Java 程序的类型安全。通过知道使用泛型定义的变量的类型限制，编译器可以在一个高得多的程度上验证类型假设。没有泛型，这些假设就只存在于程序员的头脑中（或者如果幸运的话，还存在于代码注释中）。
Java 程序中的一种流行技术是定义这样的集合，即它的元素或键是公共类型的，比如“String列表”或者“String到String的映射”。通过在变量声明中捕获这一附加的类型信息，泛型允许编译器实施这些附加的类型约束。类型错误现在就可以在编译时被捕获了，而不是在运行时当作ClassCastException展示出来。将类型检查从运行时挪到编译时有助于您更容易找到错误，并可提高程序的可靠性。
· 消除强制类型转换。泛型的一个附带好处是，消除源代码中的许多强制类型转换。这使得代码更加可读，并且减少了出错机会。
尽管减少强制类型转换可以降低使用泛型类的代码的罗嗦程度，但是声明泛型变量会带来相应的罗嗦。比较下面两个代码例子。
该代码不使用泛型：

List li = new ArrayList();

li.put(new Integer(3));

Integer i = (Integer) li.get(0);

该代码使用泛型：

List<Integer> li = new ArrayList<Integer>();

li.put(new Integer(3));

Integer i = li.get(0);

在简单的程序中使用一次泛型变量不会降低罗嗦程度。但是对于多次使用泛型变量的大型程序来说，则可以累积起来降低罗嗦程度。
· 潜在的性能收益。泛型为较大的优化带来可能。在泛型的初始实现中，编译器将强制类型转换（没有泛型的话，程序员会指定这些强制类型转换）插入生成的字节码中。但是更多类型信息可用于编译器这一事实，为未来版本的JVM 的优化带来可能。
由于泛型的实现方式，支持泛型（几乎）不需要JVM 或类文件更改。所有工作都在编译器中完成，编译器生成类似于没有泛型（和强制类型转换）时所写的代码，只是更能确保类型安全而已。
泛型用法的例子
泛型的许多最佳例子都来自集合框架，因为泛型让您在保存在集合中的元素上指定类型约束。考虑这个使用Map类的例子，其中涉及一定程度的优化，即Map.get()返回的结果将确实是一个String：

Map m = new HashMap();

m.put("key", "blarg");

String s = (String) m.get("key");

如果有人已经在映射中放置了不是String的其他东西，上面的代码将会抛出ClassCastException。泛型允许您表达这样的类型约束，即m是一个将String键映射到String值的Map。这可以消除代码中的强制类型转换，同时获得一个附加的类型检查层，这个检查层可以防止有人将错误类型的键或值保存在集合中。
下面的代码示例展示了 JDK 5.0 中集合框架中的Map接口的定义的一部分：

public interface Map<K, V> {

public void put(K key, V value);

public V get(K key);

}

注意该接口的两个附加物：

* 类型参数 K 和 V 在类级别的规格说明，表示在声明一个 Map 类型的变量时指定的类型的占位符。
* 在 get()、put() 和其他方法的方法签名中使用的 K 和 V。

为了赢得使用泛型的好处，必须在定义或实例化Map类型的变量时为K和V提供具体的值。以一种相对直观的方式做这件事：

Map<String, String> m = new HashMap<String, String>();

m.put("key", "blarg");

String s = m.get("key");

当使用Map的泛型化版本时，您不再需要将Map.get()的结果强制类型转换为String，因为编译器知道get()将返回一个String。
在使用泛型的版本中并没有减少键盘录入；实际上，比使用强制类型转换的版本需要做更多键入。使用泛型只是带来了附加的类型安全。因为编译器知道关于您将放进Map中的键和值的类型的更多信息，所以类型检查从执行时挪到了编译时，这会提高可靠性并加快开发速度。
向后兼容
在 Java 语言中引入泛型的一个重要目标就是维护向后兼容。尽管 JDK 5.0 的标准类库中的许多类，比如集合框架，都已经泛型化了，但是使用集合类（比如HashMap和ArrayList）的现有代码将继续不加修改地在 JDK 5.0 中工作。当然，没有利用泛型的现有代码将不会赢得泛型的类型安全好处。
类型参数
在定义泛型类或声明泛型类的变量时，使用尖括号来指定形式类型参数。形式类型参数与实际类型参数之间的关系类似于形式方法参数与实际方法参数之间的关系，只是类型参数表示类型，而不是表示值。
泛型类中的类型参数几乎可以用于任何可以使用类名的地方。例如，下面是java.util.Map接口的定义的摘录：

public interface Map<K, V> {

public void put(K key, V value);

public V get(K key);

}

Map接口是由两个类型参数化的，这两个类型是键类型K和值类型V。（不使用泛型）将会接受或返回Object的方法现在在它们的方法签名中使用K或V，指示附加的类型约束位于Map的规格说明之下。
当声明或者实例化一个泛型的对象时，必须指定类型参数的值：

Map<String, String> map = new HashMap<String, String>();

注意，在本例中，必须指定两次类型参数。一次是在声明变量map的类型时，另一次是在选择HashMap类的参数化以便可以实例化正确类型的一个实例时。
编译器在遇到一个Map<String, String>类型的变量时，知道K和V现在被绑定为String，因此它知道在这样的变量上调用Map.get()将会得到String类型。
除了异常类型、枚举或匿名内部类以外，任何类都可以具有类型参数。
命名类型参数
推荐的命名约定是使用大写的单个字母名称作为类型参数。这与C++ 约定有所不同（参阅附录 A：与 C++ 模板的比较），并反映了大多数泛型类将具有少量类型参数的假定。对于常见的泛型模式，推荐的名称是：

* K —— 键，比如映射的键。
* V —— 值，比如 List 和 Set 的内容，或者 Map 中的值。
* E —— 异常类。
* T —— 泛型。

泛型不是协变的
关于泛型的混淆，一个常见的来源就是假设它们像数组一样是协变的。其实它们不是协变的。List<Object>不是List<String>的父类型。
如果 A 扩展 B，那么 A 的数组也是 B 的数组，并且完全可以在需要B[]的地方使用A[]：

Integer[] intArray = new Integer[10];

Number[] numberArray = intArray;

上面的代码是有效的，因为一个Integer是一个Number，因而一个Integer数组是一个Number数组。但是对于泛型来说则不然。下面的代码是无效的：

List<Integer> intList = new ArrayList<Integer>();

List<Number> numberList = intList; // invalid

最初，大多数 Java 程序员觉得这缺少协变很烦人，或者甚至是“坏的（broken）”，但是之所以这样有一个很好的原因。如果可以将List<Integer>赋给List<Number>，下面的代码就会违背泛型应该提供的类型安全：

List<Integer> intList = new ArrayList<Integer>();

List<Number> numberList = intList; // invalid

numberList.add(new Float(3.1415));

因为intList和numberList都是有别名的，如果允许的话，上面的代码就会让您将不是Integers的东西放进intList中。但是，正如下一屏将会看到的，您有一个更加灵活的方式来定义泛型。
package com.ibm.course.generics;
import java.util.ArrayList;
import java.util.List;
public class GenericsExample {
public static void main(String[] args) {
Integer[] integer = new Integer[5];
Number[] number = integer;
System.out.println(number[0]);// null
number[0] = new Float(7.65);
System.out.println(number[0]);
System.out.println(integer[0]);
List<Integer> list = new ArrayList<Integer>();
// Type mismatch: cannot convert from List<Integer> to List<Number>
// List<Number> listObj = list;
}
}
List<Number> listObj = list;导致编译错误：Type mismatch: cannot convert from List<Integer> to List<Number>
而System.out.println(number[0]);和System.out.println(integer[0]);导致运行时异常：
Exception in thread "main" java.lang.ArrayStoreException: java.lang.Float
at com.ibm.course.generics.GenericsExample.main(GenericsExample.java:15)

类型通配符
假设您具有该方法：

void printList(List l) {

for (Object o : l)

System.out.println(o);

}

上面的代码在 JDK 5.0 上编译通过，但是如果试图用List<Integer>调用它，则会得到警告。出现警告是因为，您将泛型（List<Integer>）传递给一个只承诺将它当作List（所谓的原始类型）的方法，这将破坏使用泛型的类型安全。
如果试图编写像下面这样的方法，那么将会怎么样？

void printList(List<Object> l) {

for (Object o : l)

System.out.println(o);

}

它仍然不会通过编译，因为一个List<Integer>不是一个List<Object>（正如前一屏泛型不是协变的 中所学的）。这才真正烦人——现在您的泛型版本还没有普通的非泛型版本有用！
解决方案是使用类型通配符：

void printList(List<?> l) {

for (Object o : l)

System.out.println(o);

}

上面代码中的问号是一个类型通配符。它读作“问号”。List<?>是任何泛型List的父类型，所以您完全可以将List<Object>、List<Integer>或List<List<List<Flutzpah>>>传递给printList()。
package com.ibm.course.generics;
import java.util.ArrayList;
import java.util.List;
public class GenericExample {
public static void main(String[] args) {
List<Integer> integer = new ArrayList<Integer>();
integer.add(new Integer(0));
integer.add(new Integer(1));
List<String> str = new ArrayList<String>();
str.add(new String("Hello"));
str.add(new String("World"));
List<?> li=integer;
li=str;
printList(integer);
printList(str);
}
public static void printList(List<?> l) {
for (Object o : l) {
System.out.println(o);
}
}
}
上面的例子程序没有警告也没有编译错误。
类型通配符的作用
前一屏类型通配符 中引入了类型通配符，这让您可以声明List<?>类型的变量。您可以对这样的List做什么呢？非常方便，可以从中检索元素，但是不能添加元素（可以添加null）。原因不是编译器知道哪些方法修改列表哪些方法不修改列表，而是（大多数）变化的方法比不变化的方法需要更多的类型信息。下面的代码则工作得很好：

List<Integer> li = new ArrayList<Integer>();

li.add(new Integer(42));

List<?> lu = li;

System.out.println(lu.get(0));

为什么该代码能工作呢？对于lu，编译器一点都不知道List的类型参数的值。但是编译器比较聪明，它可以做一些类型推理。在本例中，它推断未知的类型参数必须扩展Object。（这个特定的推理没有太大的跳跃，但是编译器可以作出一些非常令人佩服的类型推理，后面就会看到（在底层细节 一节中）。所以它让您调用List.get()并推断返回类型为Object。
另一方面，下面的代码不能工作：

List<Integer> li = new ArrayList<Integer>();

li.add(new Integer(42));

List<?> lu = li;

lu.add(new Integer(43)); // error

在本例中，对于lu，编译器不能对List的类型参数作出足够严密的推理，以确定将Integer传递给List.add()是类型安全的。所以编译器将不允许您这么做。
以免您仍然认为编译器知道哪些方法更改列表的内容哪些不更改列表内容，请注意下面的代码将能工作，因为它不依赖于编译器必须知道关于lu的类型参数的任何信息：

List<Integer> li = new ArrayList<Integer>();

li.add(new Integer(42));

List<?> lu = li;

lu.clear();

泛型方法
（在类型参数 一节中）您已经看到，通过在类的定义中添加一个形式类型参数列表，可以将类泛型化。方法也可以被泛型化，不管它们定义在其中的类是不是泛型化的。
泛型类在多个方法签名间实施类型约束。在List<V>中，类型参数V出现在get()、add()、contains()等方法的签名中。当创建一个Map<K, V>类型的变量时，您就在方法之间宣称一个类型约束。您传递给add()的值将与get()返回的值的类型相同。
类似地，之所以声明泛型方法，一般是因为您想要在该方法的多个参数之间宣称一个类型约束。例如，下面代码中的ifThenElse()方法，根据它的第一个参数的布尔值，它将返回第二个或第三个参数：

public <T> T ifThenElse(boolean b, T first, T second) {

return b ? first : second;

}

注意，您可以调用ifThenElse()，而不用显式地告诉编译器，您想要T的什么值。编译器不必显式地被告知 T 将具有什么值；它只知道这些值都必须相同。编译器允许您调用下面的代码，因为编译器可以使用类型推理来推断出，替代T的String满足所有的类型约束：

String s = ifThenElse(b, "a", "b");

类似地，您可以调用：

Integer i = ifThenElse(b, new Integer(1), new Integer(2));

但是，编译器不允许下面的代码，因为没有类型会满足所需的类型约束：

String s = ifThenElse(b, "pi", new Float(3.14));

为什么您选择使用泛型方法，而不是将类型T添加到类定义呢？（至少）有两种情况应该这样做：

* 当泛型方法是静态的时，这种情况下不能使用类类型参数。
* 当 T 上的类型约束对于方法真正是局部的时，这意味着没有在相同类的另一个 方法签名中使用相同 类型 T 的约束。通过使得泛型方法的类型参数对于方法是局部的，可以简化封闭类型的签名。

有限制类型
在前一屏泛型方法 的例子中，类型参数V是无约束的或无限制的类型。有时在还没有完全指定类型参数时，需要对类型参数指定附加的约束。
考虑例子Matrix类，它使用类型参数V，该参数由Number类来限制：

public class Matrix<V extends Number> { ... }

编译器允许您创建Matrix<Integer>或Matrix<Float>类型的变量，但是如果您试图定义Matrix<String>类型的变量，则会出现错误。类型参数V被判断为由Number限制。在没有类型限制时，假设类型参数由Object限制。这就是为什么前一屏泛型方法 中的例子，允许List.get()在List<?>上调用时返回Object，即使编译器不知道类型参数V的类型。

㈤ 请教关于java的泛型方法

Java泛型详解

1. 概述
   在引入范型之前，Java类型分为原始类型、复杂类型，其中复杂类型分为数组和类。引入范型后，一个复杂类型
   就可以在细分成更多的类型。
   例如原先的类型List，现在在细分成List<Object>, List<String>等更多的类型。
   注意，现在List<Object>, List<String>是两种不同的类型，
   他们之间没有继承关系，即使String继承了Object。下面的代码是非法的
   List<String> ls = new ArrayList<String>();
   List<Object> lo = ls;
   这样设计的原因在于，根据lo的声明，编译器允许你向lo中添加任意对象（例如Integer），但是此对象是
   List<String>，破坏了数据类型的完整性。
   在引入范型之前，要在类中的方法支持多个数据类型，就需要对方法进行重载，在引入范型后，可以解决此问题
   （多态），更进一步可以定义多个参数以及返回值之间的关系。
   例如
   public void write(Integer i, Integer[] ia);
   public void write(Double d, Double[] da);
   的范型版本为
   public <T> void write(T t, T[] ta);
   
   2. 定义&使用
   类型参数的命名风格为：
   推荐你用简练的名字作为形式类型参数的名字(如果可能，单个字符)。最好避免小写字母，这使它和其他的普通
   的形式参数很容易被区分开来。
   使用T代表类型，无论何时都没有比这更具体的类型来区分它。这经常见于泛型方法。如果有多个类型参数，我们
   可能使用字母表中T的临近的字母，比如S。
   如果一个泛型函数在一个泛型类里面出现，最好避免在方法的类型参数和类的类型参数中使用同样的名字来避免混
   淆。对内部类也是同样。
   
   2.1 定义带类型参数的类
   在定义带类型参数的类时，在紧跟类命之后的<>内,指定一个或多个类型参数的名字，同时也可以对类型参数的取
   值范围进行限定，多个类型参数之间用,号分隔。
   定义完类型参数后，可以在定义位置之后的类的几乎任意地方（静态块，静态属性，静态方法除外）使用类型参数，
   就像使用普通的类型一样。
   注意，父类定义的类型参数不能被子类继承。
   public class TestClassDefine<T, S extends T> {
   ....
   }
   
   2.2 定义待类型参数方法
   在定义带类型参数的方法时，在紧跟可见范围修饰（例如public）之后的<>内,指定一个或多个类型参数的名字，同时也可以对类型参数的取值范围进行限定，多个类型参数之间用,号分隔。
   定义完类型参数后，可以在定义位置之后的方法的任意地方使用类型参数，就像使用普通的类型一样。
   例如：
   public <T, S extends T> T testGenericMethodDefine(T t, S s){
   ...
   }
   注意：定义带类型参数的方法，骑主要目的是为了表达多个参数以及返回值之间的关系。例如本例子中T和S的继承关系， 返回值的类型和第一个类型参数的值相同。
   如果仅仅是想实现多态，请优先使用通配符解决。通配符的内容见下面章节。
   public <T> void testGenericMethodDefine2(List<T> s){
   ...
   }
   应改为
   public void testGenericMethodDefine2(List<？> s){
   ...
   }
   
   3. 类型参数赋值
   当对类或方法的类型参数进行赋值时，要求对所有的类型参数进行赋值。否则，将得到一个编译错误。
   
   3.1 对带类型参数的类进行类型参数赋值
   对带类型参数的类进行类型参数赋值有两种方式
   第一声明类变量或者实例化时。例如
   List<String> list;
   list = new ArrayList<String>;
   第二继承类或者实现接口时。例如
   public class MyList<E> extends ArrayList<E> implements List<E> {...}
   
   3.2 对带类型参数方法进行赋值
   当调用范型方法时，编译器自动对类型参数进行赋值，当不能成功赋值时报编译错误。例如
   public <T> T testGenericMethodDefine3(T t, List<T> list){
   ...
   }
   public <T> T testGenericMethodDefine4(List<T> list1, List<T> list2){
   ...
   }
   
   Number n = null;
   Integer i = null;
   Object o = null;
   testGenericMethodDefine(n, i);//此时T为Number, S为Integer
   testGenericMethodDefine(o, i);//T为Object, S为Integer
   
   List<Number> list1 = null;
   testGenericMethodDefine3(i, list1)//此时T为Number
   
   List<Integer> list2 = null;
   testGenericMethodDefine4(list1, list2)//编译报错
   
   3.3 通配符
   在上面两小节中，对是类型参数赋予具体的值，除此，还可以对类型参数赋予不确定值。例如
   List<?> unknownList;
   List<? extends Number> unknownNumberList;
   List<? super Integer> unknownBaseLineIntgerList;
   注意： 在Java集合框架中，对于参数值是未知类型的容器类，只能读取其中元素，不能像其中添加元素，因为，其类型是未知，所以编译器无法识别添加元素的类型和容器的类型是否兼容，唯一的例外是NULL
   
   List<String> listString;
   List<?> unknownList2 = listString;
   unknownList = unknownList2;
   listString = unknownList;//编译错误
   
   4. 数组范型
   可以使用带范型参数值的类声明数组，却不可有创建数组
   List<Integer>[] iListArray;
   new ArrayList<Integer>[10];//编译时错误
   
   5. 实现原理
   
   5.1. Java范型时编译时技术，在运行时不包含范型信息，仅仅Class的实例中包含了类型参数的定义信息。
   泛型是通过java编译器的称为擦除(erasure)的前端处理来实现的。你可以（基本上就是）把它认为是一个从源码到源码的转换，它把泛型版本转换成非泛型版本。
   基本上，擦除去掉了所有的泛型类型信息。所有在尖括号之间的类型信息都被扔掉了，因此，比如说一个List<String>类型被转换为List。所有对类型变量的引用被替换成类型变量的上限(通常是Object)。而且，无论何时结果代码类型不正确，会插入一个到合适类型的转换。
   <T> T badCast(T t, Object o) {
   return (T) o; // unchecked warning
   }
   类型参数在运行时并不存在。这意味着它们不会添加任何的时间或者空间上的负担，这很好。不幸的是，这也意味着你不能依靠他们进行类型转换。
   
   5.2.一个泛型类被其所有调用共享
   下面的代码打印的结果是什么？
   List<String> l1 = new ArrayList<String>();
   List<Integer> l2 = new ArrayList<Integer>();
   System.out.println(l1.getClass() == l2.getClass());
   或许你会说false，但是你想错了。它打印出true。因为一个泛型类的所有实例在运行时具有相同的运行时类(class)，
   而不管他们的实际类型参数。
   事实上，泛型之所以叫泛型，就是因为它对所有其可能的类型参数，有同样的行为；同样的类可以被当作许多不同的类型。作为一个结果，类的静态变量和方法也在所有的实例间共享。这就是为什么在静态方法或静态初始化代码中或者在静态变量的声明和初始化时使用类型参数（类型参数是属于具体实例的）是不合法的原因。
   
   5.3. 转型和instanceof
   泛型类被所有其实例(instances)共享的另一个暗示是检查一个实例是不是一个特定类型的泛型类是没有意义的。
   Collection cs = new ArrayList<String>();
   if (cs instanceof Collection<String>) { ...} // 非法
   类似的，如下的类型转换
   Collection<String> cstr = (Collection<String>) cs;
   得到一个unchecked warning，因为运行时环境不会为你作这样的检查。
   
   6. Class的范型处理
   Java 5之后，Class变成范型化了。
   JDK1.5中一个变化是类 java.lang.Class是泛型化的。这是把泛型扩展到容器类之外的一个很有意思的例子。
   现在，Class有一个类型参数T, 你很可能会问，T 代表什么？它代表Class对象代表的类型。比如说，
   String.class类型代表 Class<String>，Serializable.class代表 Class<Serializable>。
   这可以被用来提高你的反射代码的类型安全。
   特别的，因为 Class的 newInstance() 方法现在返回一个T, 你可以在使用反射创建对象时得到更精确的类型。
   比如说，假定你要写一个工具方法来进行一个数据库查询，给定一个SQL语句，并返回一个数据库中符合查询条件
   的对象集合(collection)。
   一个方法是显式的传递一个工厂对象，像下面的代码：
   interface Factory<T> {
   public T[] make();
   }
   public <T> Collection<T> select(Factory<T> factory, String statement) {
   Collection<T> result = new ArrayList<T>();
   /* run sql query using jdbc */
   for ( int i=0; i<10; i++ ) { /* iterate over jdbc results */
   T item = factory.make();
   /* use reflection and set all of item’s fields from sql results */
   result.add( item );
   }
   return result;
   }
   你可以这样调用：
   select(new Factory<EmpInfo>(){
   public EmpInfo make() {
   return new EmpInfo();
   }
   } , ”selection string”);
   也可以声明一个类 EmpInfoFactory 来支持接口 Factory：
   class EmpInfoFactory implements Factory<EmpInfo> { ...
   public EmpInfo make() { return new EmpInfo();}
   }
   然后调用：
   select(getMyEmpInfoFactory(), "selection string");
   这个解决方案的缺点是它需要下面的二者之一：
   调用处那冗长的匿名工厂类，或为每个要使用的类型声明一个工厂类并传递其对象给调用的地方，这很不自然。
   使用class类型参数值是非常自然的，它可以被反射使用。没有泛型的代码可能是：
   Collection emps = sqlUtility.select(EmpInfo.class, ”select * from emps”); ...
   public static Collection select(Class c, String sqlStatement) {
   Collection result = new ArrayList();
   /* run sql query using jdbc */
   for ( /* iterate over jdbc results */ ) {
   Object item = c.newInstance();
   /* use reflection and set all of item’s fields from sql results */
   result.add(item);
   }
   return result;
   }
   但是这不能给我们返回一个我们要的精确类型的集合。现在Class是泛型的，我们可以写：
   Collection<EmpInfo> emps=sqlUtility.select(EmpInfo.class, ”select * from emps”); ...
   public static <T> Collection<T> select(Class<T>c, String sqlStatement) {
   Collection<T> result = new ArrayList<T>();
   /* run sql query using jdbc */
   for ( /* iterate over jdbc results */ ) {
   T item = c.newInstance();
   /* use reflection and set all of item’s fields from sql results */
   result.add(item);
   }
   return result;
   }
   来通过一种类型安全的方式得到我们要的集合。
   这项技术是一个非常有用的技巧，它已成为一个在处理注释(annotations)的新API中被广泛使用的习惯用法。
   
   7. 新老代码兼容
   
   7.1. 为了保证代码的兼容性，下面的代码编译器（javac）允许，类型安全有你自己保证
   List l = new ArrayList<String>();
   List<String> l = new ArrayList();
   
   7.2. 在将你的类库升级为范型版本时，慎用协变式返回值。
   例如，将代码
   public class Foo {
   public Foo create(){
   return new Foo();
   }
   }
   
   public class Bar extends Foo {
   public Foo create(){
   return new Bar();
   }
   }
   采用协变式返回值风格，将Bar修改为
   public class Bar extends Foo {
   public Bar create(){
   return new Bar();
   }
   }
   要小心你类库的客户端。

㈥ 急求一个java泛型写法

泛型可以用"<T>"代表，任意类型的。
解释： “<T>”是泛型的默认值，可以被任意类型所代替，如：
List<String> list = new ArayList<String>()；这个就定义了一个String类型的”泛型“数组，那么T的类型就是字符串。
List<T> list = new ArayList<T>()；
可以赋值给list：list.add("StringBatch");
可以获取到list的值：list.get(0),结果就是”StringBatch“；
这个时候T的类型也是String。也就是说T是动态的，可以被任意指定类型。

㈦ java泛型问题

泛型只针对没有实例出来的对象。
如：Set<String> set=new TreeSet<String>();
new TreeSet<String>()是实例化之前加的泛型。

ps.keySet()是对象，对象可以加转型，但不能加泛型。

㈧ 麻烦给我详细介绍下JAVA中用了泛型的好处，是不是用了泛型就可以不用NEW去创建对象了

1. 泛型的却很有用, 如果跟反射可以配合用好, 普通企业应用得代码量可以减少非常多.
2. python之类type inference语言比java更适合做这种template抽象

举个例子: 企业程序大部分程序是实体信息管理得, 真正涉及交易清算得只有极小一部分
对于所有得实体管理, 基本上都是增,删, 改, 查看, 查找等等几个功能
我现在用了几个框架, 经典结合方式:webwork+spring+hibernate, 分析如下:

hibernate O/R Mapping没什么花头, 为每个实体管理都要写一个映射类, 一般跟实体得数目差不多, 有时候为了避免关联, 建几个视图映射会多点. But, 这个能用hibernate自己写得工具生成, 维护一个java类文件, 以及里面得meta description.
或者自己写个程序生成( 给定数据源,, 输出java类文件, 以及hbm .xml文件 ), 这个只需要维护sql语句就兴了, 我通常这么做.

1. 不用泛型, 不用反射
spring层要写5个service(假设一个实体对应一个service), 分别实现读实体, 加实体, 删实体, 根据条件查找实体List这些功能.

要写5个不同得实体类得Action, 然后Action里面实现校验, 增加, 修改, 删除, 列表得功能, 每一个类要实现得功能同样也类似.

这些都没多少重构实质性得体现, 好处不明显, 可以提取得公共代码非常少.

2. 不用泛型, 用反射
在 1 得基础之上, 可以重构提取出一个公共service, 将分散在5个service得公共代码kill掉. 多出一个根据实体类参数操作得公共类, 但是类得数量增加一个.

同样Action也可以提出一个baseaction来

重构消去了一部分代码, 每个service得代码还是存在重复代码, 但是这个还可以通过反射合成一个service, 不过掉用者要用反射调用

对于action因为需要配置, 除非webwork支持类型得注入, 否则, 不好消去.
如果webwork spring 支持实体类型得注入, 那么到此可以结束, 只写一套逻辑, 代码也没有重复, 由于精力有限, 没有去深入研究spring AOP跟webwork 得inteceptor机制, 不知道支持不支持.

3.用泛型, 用反射
在1得基础上引入泛型, 写一个泛型service, 写一个泛型webwork action , 也没有研究过xwork中泛型对象是怎么配置产生得, 如果支持配置, 只需要写一个action即可, 如果不支持, 需要为每个实体类写一个webwork action

同样页面也是这个样子

但是, java得泛型用了一把, 不说对很多东西支持得很差, 光写法上来看, 跟C++ template一致, 仍然是一大堆得<>, 让初学者吐血, 变成高手炫耀得奇技淫巧. 比起python之类动态类型安全语言type inference机制相差太远, java泛型还有很长得路要走, 不过静态语言走到type inference上来得话, 编译类型检查得好处就没了, 所以java这方面永远不可能~~~
通过上面考虑, 我觉得python更适合web管理程序, 对于很多entity management得程序完全可以写出一个服务所有, 仅仅是O?Rmapping就没办法省. 不知道python有没有类似java得反射, 如果有得话会更好, 可以写出更通用, 量更少得代码. 相信ruby on rails成功也有这方面得原因(我没用过ruby, 错了也别骂我), 毕竟代码越少越好, 尤其是重复代码

我得主张是kill掉all重复代码, 只要能抽象统一得代码重复就是罪过, 哈哈, 相信用python可以把这个做得更好, 越来越喜欢python语言得特性了, 可惜还没拿他来做过web程序

㈨ java泛型的高级应用

在上面的例子中，由于没有限制class GenericsFoo<T>类型持有者T的范围，实际上这里的限定类型相当于Object，这和“Object泛型”实质是一样的。限制比如我们要限制T为集合接口类型。只需要这么做：
class GenericsFoo<T extends Collection>，这样类中的泛型T只能是Collection接口的实现类，传入非Collection接口编译会出错。
注意：<T extends Collection>这里的限定使用关键字extends，后面可以是类也可以是接口。但这里的extends已经不是继承的含义了，应该理解为T类型是实现Collection接口的类型，或者T是继承了XX类的类型。
下面继续对上面的例子改进，我只要实现了集合接口的类型： publicclassCollectionGenFoo<TextendsCollection>{privateTx;publicCollectionGenFoo(Tx){this.x=x;}publicTgetX(){returnx;}publicvoidsetX(Tx){this.x=x;}}实例化的时候可以这么写： {publicstaticvoidmain(Stringargs[]){CollectionGenFoo<ArrayList>listFoo=null;listFoo=newCollectionGenFoo<ArrayList>(newArrayList());//出错了,不让这么干。//原来作者写的这个地方有误，需要将listFoo改为listFoo1//需要将CollectionGenFoo<Collection>改为CollectionGenFoo<ArrayList>//CollectionGenFoo<Collection>listFoo1=null;//listFoo1=newCollectionGenFoo<ArrayList>(newArrayList());System.out.println("实例化成功!");}}当前看到的这个写法是可以编译通过，并运行成功。可是注释掉的两行加上就出错了，因为<T extends Collection>这么定义类型的时候，就限定了构造此类实例的时候T是确定的一个类型，这个类型实现了Collection接口，但是实现 Collection接口的类很多很多，如果针对每一种都要写出具体的子类类型，那也太麻烦了，我干脆还不如用Object通用一下。别急，泛型针对这种情况还有更好的解决方案，那就是“通配符泛型”。 虽然Java泛型简单的用 extends 统一的表示了原有的 extends 和 implements 的概念，但仍要遵循应用的体系，Java 只能继承一个类，但可以实现多个接口，所以你的某个类型需要用 extends 限定，且有多种类型的时候，只能存在一个是类，并且类写在第一位，接口列在后面，也就是：
<T extends SomeClass & interface1 & interface2 & interface3>
这里的例子仅演示了泛型方法的类型限定，对于泛型类中类型参数的限制用完全一样的规则，只是加在类声明的头部，如： publicclassDemo<TextendsComparable&Serializable>{//T类型就可以用Comparable声明的方法和Seriablizable所拥有的特性了} 为了解决类型被限制死了不能动态根据实例来确定的缺点，引入了“通配符泛型”，针对上面的例子，使用通配泛型格式为<? extends Collection>，“？”代表未知类型，这个类型是实现Collection接口。那么上面实现的方式可以写为： {publicstaticvoidmain(Stringargs[]){CollectionGenFoo<ArrayList>listFoo=null;listFoo=newCollectionGenFoo<ArrayList>(newArrayList());//出错了,不让这么干。//原来作者写的这个地方有误，需要将listFoo改为listFoo1//CollectionGenFoo<Collection>listFoo1=null;//listFoo1=newCollectionGenFoo<ArrayList>(newArrayList());System.out.println("实例化成功!");}}注意：
1、如果只指定了<?>，而没有extends，则默认是允许Object及其下的任何Java类了。也就是任意类。
2、通配符泛型不单可以向下限制，如<? extends Collection>，还可以向上限制，如<? super Double>，表示类型只能接受Double及其上层父类类型，如Number、Object类型的实例。
3、泛型类定义可以有多个泛型参数，中间用逗号隔开，还可以定义泛型接口，泛型方法。这些都与泛型类中泛型的使用规则类似。