java 泛型问号强转 java泛型转换为实体类

泛型概述

在Java中存入容器中的对象再取出时需要转换类型，因为对象加入容器会被转换成Object类型，而取出时要转换成实际类型。但向 下类型转换都 是存在潜在危险的，因此应该尽量避免它们。

Java的泛型：

所谓泛型就是在定义(类、方法、形参、成员变量等等)的时候，指 定它们为通用类型，也就是数据类型可以是任意类型。

泛型为提高大型程序的类型安全和维护带来了很大的潜力。

使用泛型的目的：

· 努力将运行时异常转换成编译时的错误，减少运行时异常的数量。

· 解决模板编程的问题。

1. 泛型的声明：

在定义泛型类的时候，在<>中定义形式类型参数，例如：
Class TestJava、Class TestList、Class TestVector,
其中
K：键，比如映射的键。
V：值，比如Set、List、Map中的值。
E：异常类。
T : 泛型。
在实例化泛型对象的时候，一定要在类名后面指定类型参数的值，如：
Listlist = new ArrayList():
2. 泛型的使用：
1>消除类型的转换：
下面是消除类型转换的例子：
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
public class CollectionsTest {
public static void main(String[] args) {
// 声明ArrayList对象 ,且list中只能存储String类元素
Listlist = new ArrayList();
// 向数组列表中添加元素
list.add("1abc");
list.add("2def");
list.add("3hij");
list.add("4klm");
// 取得list元素并输出,无须类型转换
System.out.print("输出第四个元素：");
String str = list.get(3);
System.out.println(str);
System.out.println("\n输出列表中的所有元素：");
for (String s : list) {
System.out.println(s);
}
System.out.println();
// 声明一个HashMap对象，指定键的类型为Integer、值的类型为String
Mapmap = new HashMap();
// 向对象中添加元素
map.put(1, "zhao");
map.put(2, "qian");
map.put(3, "sun");
map.put(4, "li");
// 取得键集
Setkeys = map.keySet();
// 由键取得对应的值，并输出
System.out.println("输出： key=value");
for (Integer i : keys) {
String value = map.get(i);
System.out.println(i + "=" + value);
}
}
}
输出结果：
输出第四个元素：4klm
输出列表中的所有元素：
1abc
2def
3hij
4klm
输出： key=value
1=zhao
2=qian
3=sun
4=li
注：
·属性中使用集合时不指定泛型，默认为 ,如定义属性： Listlist=null;
· 泛型不同的引用不能相互赋值。
· 加入集合中的对象类型必须与指定的泛型类型一一致。
2>限制泛型中类型参数的使用：
· >: 允许所有泛型的引用调用。
· Extends Number>: 只允许泛型为Number及Number子类的引用调用。
· Super Number>: 只允许泛型为Number及Number父类的引用调用。
· Extends Comparable>: 只允许泛型为实现Comparable接口的实现类的引用调用。
注：
· 方法参数中使用集合时不指定泛型默认为>.
· 方法参数中 Extends Number&Comparable>这种修饰符是不 支持的。
下面的例子演示限制类型的参数的范围：
import java.util.ArrayList;
import java.util.List;
public class CollectionsTest {
public static void main(String[] args) {
Listl1 = new ArrayList();
l1.add("China");
Listl2 = new ArrayList();
l2.add(99);
Listl3 = new ArrayList();
l3.add(3.3);
Listl4 = new ArrayList();
l4.add(83);
Listl5 = new ArrayList();
l5.add(93.67);
printView(l1);//String类型的泛型对象
printView(l2);//Object类型的泛型对象
printView(l3);//Number类型的泛型对象
printView(l4);//Integer类型的泛型对象
printView(l5);//Double类型的泛型对象
}
//方法参数中使用集合时不指定泛型，默认为>
@SuppressWarnings("rawtypes")
private static void printView(List list) {
for (Object o : list) {
System.out.println(o);
}
}
}
输出结果：
China
99
3.3
83
93.67
(1)当上面例子中的方法变为：
//允许所有的泛型的引用调用
@SuppressWarnings("rawtypes")
private static void printView(List> list) {
for (Object o : list) {
System.out.println(o);
}
}
时，输出结果：
China
99
3.3
83
93.67
可见输出结果是不变的。
(2)当上面例子中的方法变为：
//允许Number及Number的自类的引用调用
@SuppressWarnings("rawtypes")
private static void printView(List extends Number> list) {
for (Object o : list) {
System.out.println(o);
}
}
此时需要注释掉两行：
// printView(l1);//String类型的泛型对象
// printView(l2);//Object类型的泛型对象
运行，
输出结果：
3.3
83
93.67
(3)当上面例子的方法变为：
//只允许实现了Comparable接口的类的引用调用
@SuppressWarnings("rawtypes")
private static void printView(List extends Comparable> list)
{
for (Object o : list) {
System.out.println(o);
}
}
此时需要注释掉两行：
// printView(l2);//Object类型的泛型对象
//printView(l3);//Number类型的泛型对
运行，
输出结果：
China
83
93.67
(4)当上面的例子的方法变为：
// 只允许Number和Number的父类的引用调用
@SuppressWarnings("rawtypes")
private static void printView(List super Number> list) {
for (Object o : list) {
System.out.println(o);
}
}
此时需要注释掉三行：
//printView(l1);// String类型的泛型对象
//printView(l4);// Integer类型的泛型对象
//printView(l5);// Double类型的泛型对象
运行，
输出结果：
99
3.3
3>泛型的方法(也被称为Java中的多态)：
在类的定义中添加一个形式类型参数列表，可以将类泛型化。方法也 可以被泛型化，不管它们所在的类是不是泛型化的。
泛型方法的格式为：
修饰符 泛型 返回类型 方法名 参数表 抛出的异常
泛型的样式有如下几种：
· : 允许所以泛型的引用调用。
· : 只允许泛型为Number及Number子类的引用调用。
· : 只允许泛型为实现了Comparable接口的实现类的引用调用。
· : 只允许泛型为即是Number及Number子类又实现了Comparable几接口的
实现类的引用调用。
注：泛型方法中 super Number>这种修饰符是不支持的。
下面是泛型方法使用的例子：
import java.util.ArrayList;
import java.util.List;
public class CollectionsTest {
public static void main(String[] args) {
//声明各类的对象
Listl1 = new ArrayList();
Listl2 = new ArrayList();
Listl3 = new ArrayList();
Listl4 = new ArrayList();
Listl5 = new ArrayList();
//创建各类的数组
String[] a1 = new String[1];
a1[0] = "a1";
Object[] a2 = new Object[1];
a2[0] = "Object";
Number[] a3 = new Number[1];
a3[0] = 3;
Integer[] a4 = new Integer[1];
a4[0] = 4;
Double[] a5 = new Double[1];
a5[0] = 5.5;
//将相同类的数组copy到对象
copyFromArray(l1, a1);
copyFromArray(l2, a2);
copyFromArray(l3, a3);
copyFromArray(l4, a4);
copyFromArray(l5, a5);
//显示对象元素
printView(l1);
printView(l2);
printView(l3);
printView(l4);
printView(l5);
}
//显示方法
private static void printView(List> l) {
for (Object o : l) {
System.out.println(o);
}
}
//copy的方法
private static void copyFromArray(Listl, T[] a) {
for (T o : a)
l.add(o);
}
}
输出结果：
a1
Object
3
4
5.5
4>泛型类：
泛型类的写法：
class Person{
public void show(E e) {
System.out.println(e);
}
public E get() {
return null;
}
}
编写泛型类的时候要注意：
·静态方法中不能使用类的泛型，原因是泛型类中的泛型在创建类的对象时被替换成确定的类型。
静态方法可以通过类名直接访问，而Java是一种强类语言，没有类型的变量或对象是不允许存在的，
所以静态方法中不能使用类的泛型。
·不要创建泛型类的对象，因为泛型类有可能是一个接口或抽象类，如果不是接口或抽象类则可以创建。
·不能在Catch字句中使用泛型，因为编译时，如果try子句抛出的 是一检查的异常，编译器无法确定Catch能否不活这个异常。
下面是演示泛型类创建的技巧的例子：
类TestGenrics中的代码：
public class TestGenrics {
public static void main(String[] args) {
@SuppressWarnings({ "rawtypes" })
MyClass> test = new MyClass();
test.show();
MyClassstr = new MyClass();
str.method("323");
str.show();
MyClassi = new MyClass();
i.method(323);
i.show();
}
}
泛型类MyClass中的代码：
class MyClass{
private T t;
public void method(T t) {
this.t = t;
}
public T method1() {
return null;
}
public void show(){
System.out.println(t);
}
}
输出结果：
null
323
323