Java泛型的实现以及通配符

泛型：

（1）      泛型技术的产生背景：

泛型的引出：

定义一个表示坐标的操作类（Point）,要求：

保存整数x=10，y=8；

保存小数x=2.5，y=3.2；

保存字符串x=”东经120度”，y=”北纬30度”

          分析关键点在于x、y的操作类型上。

   解决：向下转型

    classPoint{

         privateObject x;

         privateObject y;

         Point(){

         }

         publicvoid setX(Object x) {

                   this.x=x;

         }

         publicObject getX()

         {

                   returnx;

         }

         publicvoid setY(Object y) {

                   this.y=y;

         }

         publicObject getY()

         {

                   returny;

         }

}

public classExample24 {

 

         publicstatic void main(String[] args) {

                   //TODO Auto-generated method stub

             Point p = new Point();

                   p.setX(10);

                   p.setY(8);

                   intx = (Integer) p.getX();

                   inty = (Integer) p.getY();

                   System.out.println("x："+x+"y:"+y);

                  

                   Pointp1 = new Point();

                   p1.setX(2.5);

                   p1.setY(3.2);

                   doublec = (Double) p1.getX();

                   doubled = (Double) p1.getY();

                   System.out.println("c："+c+"d:"+d);

                  

                   Pointp2 = new Point();

                   p2.setX("东经120度");

                   p2.setY("北纬30度");

                   Stringm = (String) p2.getX();

                   Stringn = (String) p2.getY();

                   System.out.println("m："+m+"n:"+n);

         }

 

}

  

可以看出能够实现程序的要求，但是有一种情况：

    

存入的是Double型数据，取出的是Integer型数据，两个没有任何关系的类对象发生强制转换，产生ClassCastException。向上转型目的在于统一操作的参数，而向下转型是为了操作子类定义的特殊功能。JDK1.5之后增加泛型技术。

（2）      泛型操作的实现：

类在定义的时候使用后一个标记，此标记表示类中方法或属性的类型，在使用的时候动态设置类型。

class Point<T>{

    private T x;

    private T y;

    Point(){

       

    }

    public void setX(T x) {

        this.x=x;

    }

    public T getX()

    {

        return x;

    }

    public void setY(T y) {

        this.y=y;

    }

    public T getY()

    {

        return y;

    }

}

public class Example24 {

 

    public static voidmain(String[] args) {

        // TODO Auto-generated methodstub

       Point<Integer> p = new Point<Integer>();

        p.setX(10);

        p.setY(8);

        int x = p.getX();

        int y = p.getY();

        System.out.println("x："+x+" y:"+y);

       

        Point<String> p1 = newPoint<String>();

        p1.setX("东经120度");

        p1.setY("北纬30度");

        String m = p1.getX();

        String n = p1.getY();

        System.out.println("m："+m+" n:"+n);

       

        Point<Double> p2 = newPoint<Double>();

        p2.setX(2.5);

        p2.setY(3.2);

        double c = p2.getX();

        double d = p2.getY();

        System.out.println("c："+c+" d:"+d);

    }

}

从而避免了向下转型的问题，解决了类转换的安全隐患问题。但使用泛型时，它能够采用的类型只能是类。

  

（3）      通配符的使用：

classMS<T>{

   private T msg;

   MS(){}

   public void setMsg(T msg) {

            this.msg = msg;

   }

   public T getMsg() {

            return msg;

   }

}

publicclass Example25 {

 

   public static void main(String[] args) {

            // TODO Auto-generated method stub

            MS<String> message = newMS<String>();

            message.setMsg("javabooks");

            fun(message);

   }

   public static void fun(MS<?> temp) {

            System.out.println(temp.getMsg());

   }

}

在“?”通配符基础上还有两个子通配符：

1）?extends 类：设置泛型上限，可以在声明上和方法上使用。

例如：? extends Number:意味着可以设置Number或者Number的子类

2）? super 类：设置泛型下限，方法参数上使用。

例如：? super String：意味着可以设置String或者String的父类

泛型：

（1）      泛型技术的产生背景：

泛型的引出：

定义一个表示坐标的操作类（Point）,要求：

保存整数x=10，y=8；

保存小数x=2.5，y=3.2；

保存字符串x=”东经120度”，y=”北纬30度”

          分析关键点在于x、y的操作类型上。

   解决：向下转型

    classPoint{

         privateObject x;

         privateObject y;

         Point(){

         }

         publicvoid setX(Object x) {

                   this.x=x;

         }

         publicObject getX()

         {

                   returnx;

         }

         publicvoid setY(Object y) {

                   this.y=y;

         }

         publicObject getY()

         {

                   returny;

         }

}

public classExample24 {

 

         publicstatic void main(String[] args) {

                   //TODO Auto-generated method stub

             Point p = new Point();

                   p.setX(10);

                   p.setY(8);

                   intx = (Integer) p.getX();

                   inty = (Integer) p.getY();

                   System.out.println("x："+x+"y:"+y);

                  

                   Pointp1 = new Point();

                   p1.setX(2.5);

                   p1.setY(3.2);

                   doublec = (Double) p1.getX();

                   doubled = (Double) p1.getY();

                   System.out.println("c："+c+"d:"+d);

                  

                   Pointp2 = new Point();

                   p2.setX("东经120度");

                   p2.setY("北纬30度");

                   Stringm = (String) p2.getX();

                   Stringn = (String) p2.getY();

                   System.out.println("m："+m+"n:"+n);

         }

 

}

  

可以看出能够实现程序的要求，但是有一种情况：

     

存入的是Double型数据，取出的是Integer型数据，两个没有任何关系的类对象发生强制转换，产生ClassCastException。向上转型目的在于统一操作的参数，而向下转型是为了操作子类定义的特殊功能。JDK1.5之后增加泛型技术。

（2）      泛型操作的实现：

类在定义的时候使用后一个标记，此标记表示类中方法或属性的类型，在使用的时候动态设置类型。

class Point<T>{

    private T x;

    private T y;

    Point(){

       

    }

    public void setX(T x) {

        this.x=x;

    }

    public T getX()

    {

        return x;

    }

    public void setY(T y) {

        this.y=y;

    }

    public T getY()

    {

        return y;

    }

}

public class Example24 {

 

    public static voidmain(String[] args) {

        // TODO Auto-generated methodstub

       Point<Integer> p = new Point<Integer>();

        p.setX(10);

        p.setY(8);

        int x = p.getX();

        int y = p.getY();

        System.out.println("x："+x+" y:"+y);

       

        Point<String> p1 = newPoint<String>();

        p1.setX("东经120度");

        p1.setY("北纬30度");

        String m = p1.getX();

        String n = p1.getY();

        System.out.println("m："+m+" n:"+n);

       

        Point<Double> p2 = newPoint<Double>();

        p2.setX(2.5);

        p2.setY(3.2);

        double c = p2.getX();

        double d = p2.getY();

        System.out.println("c："+c+" d:"+d);

    }

}

从而避免了向下转型的问题，解决了类转换的安全隐患问题。但使用泛型时，它能够采用的类型只能是类。

  

（3）      通配符的使用：

classMS<T>{

   private T msg;

   MS(){}

   public void setMsg(T msg) {

            this.msg = msg;

   }

   public T getMsg() {

            return msg;

   }

}

public class Example25 { 

   public static void main(String[] args) {

            // TODO Auto-generated method stub

            MS<String> message = newMS<String>();

            message.setMsg("javabooks");

            fun(message);

   }

   public static void fun(MS<?> temp) {

            System.out.println(temp.getMsg());

   }

}

在“?”通配符基础上还有两个子通配符：

1）?extends 类：设置泛型上限，可以在声明上和方法上使用。

例如：? extends Number:意味着可以设置Number或者Number的子类

2）? super 类：设置泛型下限，方法参数上使用。

例如：? super String：意味着可以设置String或者String的父类