泛型：JDK1.5版本以后出现新特性。用于解决安全问题，是一个类型安全机制。
到底泛型是如何解决安全问题的？？？除了解决安全问题还可以有什么好处呢？？？可以举个例子说明吗？
public class Test<T> {
private T name;

public T getName() {
  return name;
}

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

public static void main(String[] args) {
  Test<String> stringTest = new Test<String>();
  stringTest.setName("aaa");
  System.out.println(stringTest.getName());
  Test<Integer> integerTest = new Test<Integer>();
  integerTest.setName(1111);
  System.out.println(integerTest.getName());
}
}
从上面的例子中我看不出安全在哪里？只是用起来比较方便点？？？可以给我讲解一下吗？或者举例说明下？

1. import java.util.*;
   
2. class Demo
   
3. {
   
4.         public static void main(String[] args)
   
5.         {
   
6.                 ArrayList al =new ArrayList();
   
7.                 al.add("abcd");//         这个是String类型
   
8.                 al.add(4);//        这个是Integer类型
   
9.                 Iterator it =al.iterator();
   
10.                 while(it.hasNext())
    
11.                 {
    
12.                         String s =(String)it.next();
    
13.                         System.out.println(s+":"+s.length());
    
14.                 }
    
15.         }
    
16. }

复制代码

这个程序 编译的时候是没问题，但是运行的时候会出现问题，因此出现安全问题。所以版本更新后加了泛型，这样会在编译的时候就出现问题，提示你类型转换错误，这样你就能在编译的阶段解决问题了。

泛型的安全性 是 在 类型转换上面来说的

在1.5之前没有泛型的情况下，通过对类型Object的引用，可以实现参数的“任意化”，而“任意化”带来的则是参数类型的显示强制转换。

而一般这种转换在编译的时候不会提示出错，只有在运行的时候才会报错。

这样就会造成安全问题。

有了泛型后，程序在编译的时候就会进行检查类型安全，并且所有的强制转换都是隐形的和自动的，提高了代码的重用性。

我举个下面的例子 楼主参考一下，

现在假如我们没有泛型，我们需要构造两个类，一个处理 String 而 另一个处理 Double 类型

首先是 处理String 的类

1. public class StrTest {
   
2. private String x;
   
3. 
   
4. public String StrTest(String x){
   
5. this.x = x;
   
6. }
   
7. public String getX( ) {
   
8.   return x;
   
9. }
   
10. 
    
11. public void setX(String x) {
    
12.   this.x = x;
    
13. }

复制代码

然后是处理Double的类

1. public class DouTest {
   
2. private double x;
   
3. public double DouTest(double x)

复制代码

由于两个类的功能与结构是一样的，因此我们要重构两个类，把他们写成一个类，这样就省事儿多了。因为万物皆object，所以我们先用Object作为类型

1. public class ObjTest {
   
2. private Object x;
   
3. public Object ObjTest(Object x){
   
4. this.x = x;
   
5. }
   
6. 
   
7. public Object getX() {
   
8.   return x;
   
9. }
   

复制代码

*这样就完成了，如果我们想要使用它，那么下面来调用它。

1. public class TestDemo {
   
2. 　　public static void main(String args[]) {
   
3. 
   
4. 　　StrTest  str = new ObjTest(new StrTest("hehe!"));
   
5. 　　DouTest dou = new ObjectFoo(new DouTest(Double("33")));
   
6. 　　ObjTest obj = new ObjTest(new Object());
   
7. 
   
8.       
   
9. System.out.println("str.getX="+(StrTest)str.getX());
   
10. 　　//System.out.println("str.getX="+(DouTest)str.getX()); //<font color="#ff0000">这里将String类型强制转换成了Double，编译不会报错</font>
    
11. 　　System.out.println("dou.getX="+(DouTest)dou.getX());
    
12. 　　System.out.println("obj.getX="+obj.getX());

复制代码

这样就完成了，上面错误的一行就可以看出来，在强制转换的过程中，我们必须要知道这些被转换的数据类型，不然就 会出现错误，而这些错误在编译的时候不会报错，因此这就造成了安全问题。 所以用泛型来解决

就写这么多了，希望楼主能明白。

我郁闷了，double那的代码在编辑的时候还是完整的，一提交就少了一大半。楼主凑合看吧。2楼说的也很好。