泛型的上下限问题  谁能给举例解释一下   

在写程序的时候，我们希望某一个函数接收的参数，有一个范围的限制，这时候我们就可以考虑使用泛型的上限和下限去解决。
看一段代码，然后再去详细解释。


class Point<T>
{
    private T x;
    private T y;
    public T getX()
    {
        return x;
    }
    public void setX(T x)
    {
        this.x = x;
    }
    public T getY()
    {
        return y;
    }
    public void setY(T y)
    {
        this.y = y;
    }
}
public class Demo2
{
//  static void show(Point<? extends Number> p)//此时这个函数只能接收Number及其子类 此时show(p2)会报错
    static void show(Point<? super String> p)//此时这个函数只能接收String及其父类  此时show(p1)会报错
    {
        System.out.println(p.getX());
        System.out.println(p.getY());
    }
    public static void main(String[] args)
    {
        Point<Integer> p1 = new Point<Integer>();
        p1.setX(2);
        p1.setY(4);
        Point<String> p2 = new Point<String>();
        p2.setX("东经43度");
        p2.setY("北纬34度");
        show(p1);
        show(p2);
    }
}
在这段程序中我们定义了一个函数show，我们在参数的后面使用的<? .....>这里的问号，表示的通配符，代表接收的实际参数的类型。我们可以看出来在程序中我先注释了entends的一行代码。这个表示参数的上限，接收的参数必须是Number或者是其子类，如果使用这个的时候，我们调用show方法的时候，传递p2会报错，因为p2不是Number或者其子类。同样的，我们使用super关键字，这个表示参数的上限，程序中表示接收的参数只能是String或者其父类，这时候show方法的参数是p1会报错，不满足下限的要求。
对于上限和下限基本的使用就是这样，希望对你有帮助

泛型的限制范围与它的方式有关，具体如下：
1、<?>允许所有泛型的引用调用
2、<? extends Number> 只允许泛型为Number及Number子类的引用调用
3、<? super Number> 只允许泛型为Number及Number父类的引用调用
4、<? extends Comparable> 只允许泛型实现Comparable接口的实现类的引用调用

1.Toy类

package fanxing;

public class Toy {

}
2.SubToy类

package fanxing;

public class SubToy extends Toy{
     
}
3.SubToy2类

package fanxing;

public class SubToy2 extends Toy{
     
}
4.main类

package fanxing;

import java.util.ArrayList;
import java.util.List;

public class main {

    /**
     * @param args
     * @throws IllegalAccessException
     * @throws InstantiationException
     */
    public static void main(String[] args) throws Exception{
        Toy toy = new Toy();
        SubToy subToy = new SubToy();
        SubToy subToy2 = new SubToy();
         
        List<? extends Toy> list = new ArrayList<Toy>();//表示所持有对象是Toy子类
        List<? extends Toy> list1 = new ArrayList<SubToy>();//表示所持有对象是Toy的子类
         
//      list.add(toy);      错误的 因为list所持有的对象类型上限为Toy，但是他不知道具体持有的对象类型，
//      list.add(subToy);   错误的，理由同上
//      list.add(subToy2);  错误的，理由同上
         
//      list1.add(toy);         错误的 因为list1所持有的对象类型上限为Toy，但是他不知道具体持有的对象类型，
//      list1.add(subToy);   错误的，理由同上
//      list1.add(subToy2);  错误的，理由同上
         
         
         
        List<? super Toy> list2 = new ArrayList<Toy>();//所持有对象为Toy的超类,下限为Toy，所以可以add() Toy及Toy的子类
        list2.add(toy);
        list2.add(subToy);
        list2.add(subToy2);
         
//      List<? super Toy> list3 = new ArrayList<SubToy>();  错误的，所持有对象为Toy的超类，下限为Toy，
//      所以不可以超过下限Toy，将ArrayList泛型指定为SubToy

         
        List<? super SubToy> list4 = new ArrayList<Toy>();//所持有对象为SubToy的超类，下限为SubToy ，
                                                                //可以将ArrayList泛型指定为Toy
//      list4.add(toy); 错误的，因为虽然持有对象为SubToy的超类，但是容器不知道具体的类型是超类还是子类，所以不能放入超类，但是子类的话就可以的
        list4.add(subToy);
        list4.add(subToy2);
         
        List<? super SubToy> list5 = new ArrayList<SubToy>();//所持有对象为SubToy的超类，下限为SubToy ，
        //可以将ArrayList泛型指定为SubToy      
//      list5.add(toy); 错误的，理由同list4
        list5.add(subToy);
        list5.add(subToy2);
         
//      List<? super SubToy> list6 = new ArrayList<SubToy2>(); 错误的，所持有对象为SubToy的超类，下限为SubToy ，
//      所以持有的对象可能为Toy，也可能为SubToy ，也就不能将具体的实现的泛型指定为SubToy2
         
         
    }

}