⑴ java中的泛型套泛型有没有方法方便地向下转换
类型是对应的，可以强制转换
~~~~~~
⑵ java中泛型的使用
泛型可以避免强制类型转换，设定集合对象中存储的对象类型。
比如List<String> list = new ArrayList<String>();
那在这个list中，只能存储字符串对象。
⑶ 关于java泛型集合转换问题，下图是List<String>类型数据，求问怎么转换为List<T>类型
public class Test {
public static void main(String[] args){
List<A> list = new ArrayList<A>();
A a1 = new A("101","01","122222222","上海");
A a2 = new A("102","02","133333333","南京");
A a3 = new A("103","03","142333223","上海");
A a4 = new A("104","04","125555552","上海");
list.add(a1);
list.add(a2);
list.add(a3);
list.add(a4);
}
}
class A{
private String ID;
private String num;
private String iphone;
private String address;
public String getID() {
return ID;
}
public void setID(String iD) {
ID = iD;
}
public String getNum() {
return num;
}
public void setNum(String num) {
this.num = num;
}
public String getIphone() {
return iphone;
}
public void setIphone(String iphone) {
this.iphone = iphone;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public A(String id,String num,String iphone,String address){
this.ID = id;
this.num = num;
this.iphone = iphone;
this.address=address;
}
}
我写了个例子，应该能明白了吧？也就是吧你集合的数据封装成一个对象，这样泛型的时候就可以泛型成这个对象了。A也就是你说的T 这样就是你要的把数据封装成了A类对象
希望能帮到你!
⑷ Java，泛型问题和Object，类型转换问题
简单点说，不扯那些书上的，弱类型语言无类型，高级语言有类型，每个类型有自己的方法，这里就说java，java基本数据类型有8中，对应的包装类也是有方法的，比如int对应的Integer，按你说的统一就Object类型，那么每个类型都有自己的方法，你都用Object方法要怎么用？你可以如果我要用String，那么我就把Object转换为String，可是往往写代码的时候，你还不知道未来那个数据是什么类型，这种情况也是有的，再说泛型，泛型这个东西简单来说就是在编译期间确定类型，这样IDE可以帮你检查类型，举例一个集合List，这里以前是可以装任何Object的，有了泛型以后，我们可以这样List<String>意思说这里的集合我只能装字符串类型，否则编译时就过不去，这样的好处是你内心知道这里只是字符串，未来在从集合中获取一个对象时，直接就可以用字符串的方法，而不是拿出Object在转换，并且如果只是单纯的List集合，你如何确定代码装入集合中的对象就一定是字符串，倘若很复杂的代码，里面不小心装入的Integer对象，也很难检测，恐怕只有运行报错的时候你才知道，最后要说泛型只存在于编译期间，编译过后泛型擦除！
⑸ java中泛型怎么强制转换
首先你的问题得明确一些
如果把List<B>转成B,则不用转，直接B b = list.get(2)。
如果把List<B>转成A，也不需要强制转换，因为A是B的父类。父类的引用可以直接指向之类的对象，而不需要强制转换。A a = list.get(2);就可以完成。
如果把List<A>转成B,这需要强制转换。也很简单B b = (B)list.get(2);但是，前提是，当你把对象装入List<A> list的时候，你必须实例化B对象，否则会报错！
以下是第三种不会报错情况的代码，比较简陋，但运行正确，分析原理足矣！
package a;
import java.util.ArrayList;
import java.util.List;
public class A {
public int sign = 1;
public List<A> getList(){
List<A> l = new ArrayList<A>();
for(int i=0;i<5;i++){
l.add(new A(i));
}
return l;
}
public A(int s){
this.sign = s;
}
}
package a;
import java.util.ArrayList;
import java.util.List;
public class B extends A {
public B(int s) {
super(s);
// TODO Auto-generated constructor stub
}
/**
* @param args
*/
public static void main(String[] args) {
B b = new B(1);
List<A> list = b.getList();
for(int i=0;i<5;i++){
A a = list.get(i);
B bb = (B)list.get(i);
System.out.println("A:"+a.sign+" B:"+bb.sign);
}
}
public List<A> getList(){
List<A> l = new ArrayList<A>();
for(int i=0;i<5;i++){
l.add(new B(i));
}
return l;
}
}
楼主可以把B中的new B(i)改成new A(i) ，编译不报错，运行就会错了！
⑹ 如何理解Java的泛型
泛
型（Generic type 或者 generics）是对
简单的理解，就是对类型的参数化，比如我们定义一个类属性或者实例属性时，往往要指定具体的类型，如Integer、Person等等，
但是如果使用了泛型，我们把这些具体的类型参数化，用一个广泛的可以表示所有类型的“类型”T来定义，那这个T就是泛型的表示。
可以在集合框架（Collection framework）中看到泛型的动机。例如，Map 类允许您向一个 Map 添加任意类的对象，即使最常见的情况是在给定映射（map）中保存某个特定类型（比如 String）的对象。
因为 Map.get() 被定义为返回 Object，所以一般必须将 Map.get() 的结果强制类型转换为期望的类型，如下面的代码所示：
[java]view plainprint?
Mapm=newHashMap();
m.put("key","value");
Strings=(String)m.get("key");
⑺ java中的泛型 求详细解释
1、Java泛型
其实Java的泛型就是创建一个用类型作为参数的类。就象我们写类的方法一样，方法是这样的method(String str1,String str2 ),方法中参数str1、str2的值是可变的。而泛型也是一样的，这样写class Java_Generics＜K,V＞，这里边的K和V就象方法中的参数str1和str2,也是可变。下面看看例子：
//code list 1
import Java.util.Hashtable;
class TestGen0＜K,V＞{
public Hashtable＜K,V＞ h=new Hashtable＜K,V＞();
public void put(K k, V v) {
h.put(k,v);
}
public V get(K k) {
return h.get(k);
}
public static void main(String args[]){
TestGen0＜String,String＞ t=new TestGen0＜String,String＞();
t.put("key", "value");
String s=t.get("key");
System.out.println(s);
}
}
正确输出:value
这只是个例子（Java中集合框架都泛型化了，这里费了2遍事.），不过看看是不是创建一个用类型作为参数的类，参数是K，V，传入的“值”是String类型。这个类他没有特定的待处理型别，以前我们定义好了一个类，在输入输入参数有所固定，是什么型别的有要求，但是现在编写程序，完全可以不制定参数的类型，具体用的时候来确定，增加了程序的通用性，像是一个模板。
呵呵，类似C++的模板（类似）。
1.1. 泛型通配符
下面我们先看看这些程序：
//Code list 2
void TestGen0Medthod1(List l) {
for (Object o : l)
System.out.println(o);
}
看看这个方法有没有异议，这个方法会通过编译的，假如你传入String，就是这样List＜String＞。
接着我们调用它,问题就出现了，我们将一个List＜String＞当作List传给了方法，JVM会给我们一个警告，说这个破坏了类型安全，因为从List中返回的都是Object类型的，而让我们再看看下面的方法。
//Code list 3
void TestGen0Medthod1(List＜String＞ l) {
for (Object o : l)
System.out.println(o);
}
因为这里的List＜String＞不是List＜Object＞的子类,不是String与Object的关系，就是说List＜String＞不隶属于list＜Object＞,他们不是继承关系，所以是不行的，这里的extends是表示限制的。
类型通配符是很神奇的，List＜?＞这个你能为他做什么呢?怎么都是“？”，它似乎不确定，他总不能返回一个？作为类型的数据吧，是啊他是不会返回一个“？”来问程序员的？JVM会做简单的思考的，看看代码吧，更直观些。
//code list 4
List＜String＞ l1 = new ArrayList＜String＞();
li.add(“String”);
List＜?＞ l2 = l1;
System.out.println(l1.get(0));
这段代码没问题的，l1.get(0)将返回一个Object。
1.2. 编写泛型类要注意：
1) 在定义一个泛型类的时候，在 “＜＞”之间定义形式类型参数，例如：“class TestGen＜K,V＞”，其中“K” , “V”不代表值，而是表示类型。
2) 实例化泛型对象的时候，一定要在类名后面指定类型参数的值（类型），一共要有两次书写。例如：
TestGen＜String,String＞ t=new TestGen＜String,String＞()；
3) 泛型中＜K extends Object＞,extends并不代表继承，它是类型范围限制。
2、泛型与数据类型转换
2.1. 消除类型转换
上面的例子大家看到什么了，数据类型转换的代码不见了。在以前我们经常要书写以下代码，如：
//code list 5
import Java.util.Hashtable;
class Test {
public static void main(String[] args) {
Hashtable h = new Hashtable();
h.put("key", "value");
String s = (String)h.get("key");
System.out.println(s);
}
}
这个我们做了类型转换，是不是感觉很烦的，并且强制类型转换会带来潜在的危险，系统可能会抛一个ClassCastException异常信息。在JDK5.0中我们完全可以这么做，如：
//code list 6
import Java.util.Hashtable;
class Test {
public static void main(String[] args) {
Hashtable＜String,Integer＞ h = new Hashtable＜String,Integer＞ ();
h.put("key", new Integer(123));
int s = h.get("key").intValue();
System.out.println(s);
}
}
这里我们使用泛化版本的HashMap,这样就不用我们来编写类型转换的代码了，类型转换的过程交给编译器来处理，是不是很方便，而且很安全。上面是String映射到String，也可以将Integer映射为String，只要写成HashTable＜Integer,String＞ h=new HashTable＜Integer,String＞();h.get(new Integer(0))返回value。果然很方便。
⑻ java 泛型转换问题
不能直接转，bs = as；如果这个能转的话证明bs和as的类型一致，或者它们两个直接有继承关系，但是ArrayList<A>与ArrayList<B>之间并不存在类型一致或者继承的关系，所以不能直接转换。只能通过其他方法实现
⑼ 请教java List 泛型转换
如：List<String> list = new ArrayList<String>(); list.add("1");
list.add("2");
采用泛型写法后，list想加入一个Integer类型的对象时会出现编译错误，通过List<String>，直接限定了list集合中只能含有String类型的元素，从而在后续如果进行for循环就无须进行强制类型转换，因为此时，集合能够记住元素的类型信息，编译器已经能够确认它是String类型了。