JDK1.5之后追加到Java中，主要目的是为了解决ClassCaseException问题。在进行对象的向下转型时永远可能存在安全隐患，java希望通过泛型慢慢解决掉此类问题。

  1. class PointP{
  2.     private Object x;
  3.     private Object y;
  4.     public void setX(Object x){
  5.         this.x = x;
  6.     }
  7.     public void setY(Object y){
  8.         this.y = y;
  9.     }
  10.     public Object getX(){
  11.         return x;
  12.     }
  13.     public Object getY(){
  14.         return y;
  15.     }
  16. }
  17. class Untitled {
  18.     public static void main(String[] args) {
  19.         PointP p = new PointP();
  20.         p.setX(10);
  21.         p.setY(20);
  22.         int x = (int)p.getX();
  23.         int y = (int)p.getY();
  24.         System.out.println( x + "" + y );
  25.     }
  26. }

如上述代码，未使用泛型的时候，必须强制转换成int。一旦转换失败，编译的时候不会报错，运行的时候会报错。

泛型的基本定义：

想要避免“ClassCastException”，最好的方法是回避对象的下转型。泛型技术的本质是，类中的属性或方法的参数与返回值的类型可以由对象实例化的时候动态决定。
不设置泛型类型时，会自动设置为Object类型。

  1. class PointP <T>{ 
  2.     private T x;
  3.     private T y;
  4.     public void setX(T x){
  5.         this.x = x;
  6.     }
  7.     public void setY(T y){
  8.         this.y = y;
  9.     }
  10.     public T getX(){
  11.         return x;
  12.     }
  13.     public T getY(){
  14.         return y;
  15.     }
  16. }
  17. class Untitled {
  18.     public static void main(String[] args) {
  19.         PointP <Integer>  p = new PointP <Integer>();
  20.         p.setX(10);
  21.         p.setY(20);
  22.         Integer x = p.getX();
  23.         Integer y = p.getY();
  24.         System.out.println( x + "" + y );
  25.     }
  26. }

由于泛型类型设置为Integer，编译的时候如果发现设置的内容有错误会自动的进行错误提示，同时避免了对象的向下转型处理。
使用注意：
1.泛型之中只能设置引用类型，如果操作基本类型必须使用包装类。
2.JDK1.7之后操作可以简略成 ： PointP p = new PointP <>();
JDK1.5之前：PointP p = new PointP ();
使用泛型可以解决大部分的类对象向下转型问题，比使用Object更加合理。

泛型通配符

泛型虽然解决了向下转型带来的安全隐患，但是同时带来了引用传递处理问题。

  1. class PointP <T>{ 
  2.     private T x;
  3.     private T y;
  4.     public void setX(T x){
  5.         this.x = x;
  6.     }
  7.     public void setY(T y){
  8.         this.y = y;
  9.     }
  10.     public T getX(){
  11.         return x;
  12.     }
  13.     public T getY(){
  14.         return y;
  15.     }
  16. }
  17. class Untitled {
  18.     public static void main(String[] args) {
  19.         PointP <Integer>  p = new PointP <Integer>();
  20.         p.setX(10);
  21.         p.setY(20);
  22.         func(p);//正确输出30
  23.         PointP <String>  p2 = new PointP <String>();
  24.         p2.setX("11");p2.setY("222");
  25.         func(p2);//报错。因为函数参数被固定成Integer
  26.     }
  27.     public static void func(PointP<Integer> tmp){
  28.         System.out.println( tmp.getX() + tmp.getY());
  29.     }
  30. }

如果不能引用传递，泛型就丧失了意义。如上代码，正常应该可以接受任意类型的PointP对象，但是代码中设置为只能接受PointP类型。
修改方法：通配符

  1. public static void func(PointP<?> tmp){
  2.         System.out.println( tmp.getX() + tmp.getY());
  3.     }

注意：

  1. ? extends 类：设置泛型的上限。

例如：定义 ？extends Number 表示泛型只允许设置为Number及其子类、

  1. ？super 类：设置泛型的下限。

例如：定义 ？super String 表示泛型只允许使用String或其父类。

上限：

  1. class PointP <T extends Number>{ 
  2.     private T x;
  3.     private T y;
  4.     public void setX(T x){
  5.         this.x = x;
  6.     }
  7.     public void setY(T y){
  8.         this.y = y;
  9.     }
  10.     public T getX(){
  11.         return x;
  12.     }
  13.     public T getY(){
  14.         return y;
  15.     }
  16. }
  17. class Untitled {
  18.     public static void main(String[] args) {
  19.         PointP <Integer>  p = new PointP <Integer>();
  20.         p.setX(10);
  21.         p.setY(20);
  22.         func(p);
  23.         PointP <String>  p2 = new PointP <String>();//报错。String无法转换成Integer。
  24. //        p2.setX("11");p2.setY("222");
  25. //        func(p2);
  26.     }
  27.     public static void func(PointP<? extends Number> tmp){
  28.         System.out.println(tmp.getX() + " " + tmp.getY());
  29.     }
  30. }

下限：

  1. class PointP <T>{ 
  2.     private T x;
  3.     private T y;
  4.     public void setX(T x){
  5.         this.x = x;
  6.     }
  7.     public void setY(T y){
  8.         this.y = y;
  9.     }
  10.     public T getX(){
  11.         return x;
  12.     }
  13.     public T getY(){
  14.         return y;
  15.     }
  16. }
  17. class Untitled {
  18.     public static void main(String[] args) {
  19.         PointP <Integer>  p = new PointP <Integer>();
  20.         p.setX(10);
  21.         p.setY(20);
  22.         func(p);//报错，Integer无法转换成String
  23.         PointP <String>  p2 = new PointP <String>();
  24. //        p2.setX("11");p2.setY("222");
  25. //        func(p2);
  26.     }
  27.     public static void func(PointP<? super String > tmp){
  28.         System.out.println(tmp.getX() + " " + tmp.getY());
  29.     }
  30. }

泛型接口

实现泛型接口的两种方式：
1.子类继续用泛型。
2.子类确定泛型的类型。

  1. interface IMessage<T>{
  2.     public String echo(T t);
  3. }
  4. class MessageImpl1<s> implements IMessage<s>{//方式一
  5.     public String echo(s t){
  6.         return "Echo" + t;
  7.     }
  8. }
  9. class MessageImpl2 implements IMessage<String>{//方式二
  10.     public String echo(String t){
  11.         return "Echo" + t;
  12.     }
  13. }
  14. class Untitled {
  15.     public static void main(String[] args) {
  16.         IMessage <String> msg = new  MessageImpl1 <String> ();
  17.                 System.out.println(msg.echo("111"));
  18.         msg = new MessageImpl2();
  19.         System.out.println(msg.echo("222"));
  20.     }
  21. }

泛型方法

如果一个类上没有定义泛型，依然可以使用泛型方法。

  1. class Untitled {
  2.     public static void main(String[] args) {
  3.         Integer num [] = fun(1,2,3);
  4.         for (int temp:num) {
  5.             System.out.println(temp+" ");
  6.         }
  7.     }
  8.     public static <T> T[] fun(T ... args){
  9.         return args;
  10.     }
  11. }