Java泛型

一、泛型的定义主要有以下两种：

1. 在程序编码中一些包含类型参数的类型，也就是说泛型的参数只可以代表类，不能代表个别对象。（这是当今较常见的定义）
2. 在程序编码中一些包含参数的类。其参数可以代表类或对象等等。（现在人们大多把这称作模板）

        不论使用那个定义，泛型的参数在真正使用泛型时都必须作出指明。

二、使用泛型的目的：

1. 一些强类型程序语言支持泛型，其主要目的是加强类型安全及减少类转换的次数，但一些支持泛型的程序语言只能达到部份目的。
2. 泛型程序设计（Generic programming）意味着编写的代码可以被很多不同类型的对象所重用。
3. 是对java语言的类型系统的一种扩展，以支持创建可以按类型进行参数化的类。可以把类型参数看作是使用参数化类型时指定的类型的一个占位符，就像方法的形式参数是运行时传递的值得占位符一样。

【Java泛型的几种类型代码】

一、不使用泛型的代码

     我们定义一个Person类，包含三个属性x，y，z。在我们开始定义地时候，我们也不知道这三个属性是用来干什么的，所以我们定义为Object类型。但是在使用的时候，我们分别对x，y，z赋予了int，double，String类型，所以在取出的时候，我们需要把这三个类型值进行强制转换。如下代码：

    1. Person.java

 1 public class Person {
 2     private Object x;
 3     private Object y;
 4     private Object z;
 5     //使用Object类型。可以转化为任何类型
 6     public Object getX() {
 7         return x;
 8     }
 9     public void setX(Object x) {
10         this.x = x;
11     }
12     public Object getY() {
13         return y;
14     }
15     public void setY(Object y) {
16         this.y = y;
17     }
18     public Object getZ() {
19         return z;
20     }
21     public void setZ(Object z) {
22         this.z = z;
23     }
24 }

    2. NoGenericTest.java

 1 public class NoGenericTest {
 2     public static void main(String[]args){
 3         Person boy=new Person();
 4         boy.setX(20);
 5         boy.setY(22.2);
 6         boy.setZ("帅哥TT");
 7         //这里根据设置的不同类型的值，我们需要进行强制类型转化。
 8         int x=(Integer)boy.getX();
 9         double y=(double)boy.getY();
10         String z=(String)boy.getZ();
11         
12         System.out.println(x);
13         System.out.println(y);
14         System.out.println(z);
15     }
16 }

    3. 运行结果

1 20
2 22.2
3 帅哥TT

二、使用一个类型变量泛型的代码

      我们定义一个泛型类Person，定义三个属性x，y，z，在测试类中，我们设置属性的值，并打印。

    1. Person.java

 1 public class Person<T> {
 2     private T x;
 3     private T y;
 4     private T z;
 5     public T getX() {
 6         return x;
 7     }
 8     public void setX(T x) {
 9         this.x = x;
10     }
11     public T getY() {
12         return y;
13     }
14     public void setY(T y) {
15         this.y = y;
16     }
17     public T getZ() {
18         return z;
19     }
20     public void setZ(T z) {
21         this.z = z;
22     }
23 }

    2. GenericTest.java

 1 public class GenericTest {
 2     public static void main(String[]args){
 3         Person boy=new Person();
 4         boy.setX(20);
 5         boy.setY(22.2);
 6         boy.setZ("帅哥TT");
 7         //不用进行类型转化
 8         System.out.println(boy.getX());
 9         System.out.println(boy.getY());
10         System.out.println(boy.getZ());
11     }
12 }

    3. 运行结果

1 20
2 22.2
3 帅哥TT

三、使用两个类型变量泛型的代码

     我们定义一个泛型类Person，定义两个属性x，y，使用了两种不同的类型变量，在测试类中，我们设置属性的值，并打印。

    1. Person.java

 1 public class Person<T1,T2> {
 2     private T1 x;
 3     private T2 y;
 4     public T1 getX() {
 5         return x;
 6     }
 7     public void setX(T1 x) {
 8         this.x = x;
 9     }
10     public T2 getY() {
11         return y;
12     }
13     public void setY(T2 y) {
14         this.y = y;
15     }
16 }

    2. GenericTest.java

 1 public class GenerricTest {
 2     public static void main(String[] args){
 3         Person<String,Integer> boy=new Person<String,Integer>();
 4         boy.setX("帅哥TT");
 5         boy.setY(20);
 6         System.out.println(boy.getX());
 7         System.out.println(boy.getY());
 8     }
 9 
10 }

    3. 运行结果

1 帅哥TT
2 20