最重要的是限定泛型的类型，以便为泛型的调用者提供更精确的编译能力。

比如说，你写了一个泛型类型的排序。
void sort(Collection col)
显然作为排序，你的程序需要比较两个元素的大小，来确定它们的相对关系。
比如

 void sort<T>(Collection<T> col)
{
for (int i = 0; i < col.size() - 1; i++)
for (int j = i; i < col.size() - 1; j++)
{
if (比较 col.get(j) 和 col.get(j + 1))
{
//交换
}
}
}

现在的问题是if (比较 col.get(j) 和 col.get(j + 1))这个怎么写？
也许你想，我们可以写
if (col.get(j).compareTo(col.get(j + 1)))
但是怎么保证传入的元素有compareTo这个方法呢？
你可以将T限定在Compareable接口上。
这样做，编译器可以直接检查传入的T是否实现了这个接口。如果不符合，就不通过编译，而你的程序，直接放心调用就可以了。

@caozhy 给出了限定类型泛型的作用，即，限制类型参数的范围，同时可以使用限定的界限包含的方法。比如caozhy提出的例子调整成可用的形式：

    public static <T extends Number> void sort(List<T> col) {
        for (int i = 0; i < col.size() - 1; i++)
            for (int j = i; i < col.size() - 1; j++) {
                if (col.get(j).longValue() > col.get(j + 1).longValue()) {//可以直接使用Number的方法
                    // 交换
                }
            }
    }

什么样的是自限定类型呢？即，限定范围就是自身。比如一个实现了Comparable接口的的User类，希望只能和User类的实例进行比较，那么我们需要这样写：

    static class User2 implements Comparable<User2>{
        public int compareTo(User2 o) {
            //
        }   
    }

这样就利用了限定类型的两个用处：1.限定范围；2.可以使用限定类的方法。另外一个点，就是限定了只能是同类型的进行比较。

我们再来看一个更复杂的，jdk里的Enum类定义：

 public abstract class Enum<E extends Enum<E>>
        implements Comparable<E>, Serializable{
}

这是一个更复杂的限定类型，为什么要这么复杂呢？如果我们写成简单的样子行不行？像这样：

 public abstract class Enum
        implements Comparable<Enum>, Serializable{
}

（关于Enum类和子类之间的关系，可以参考这里：https://www.cnblogs.com/ly-radiata/articles/6049822.html）
不是同样可以起到限定范围在Enum类么？为什么又要多次一举，弄得这么复杂？
这和Enum类的作用有关系，Enum这个抽象类是用来被继承的，所以我们总是在定义和使用Enum的子类，而且我们希望enum Day和enum Month只能自己的枚举值之间进行比较，而不能互相比较。比如Monday和January就不能比较，因为比较是没有意义的。

看明白了这里，我们再来看一下，简化了的Enum能不能达到上述的限制目的？

 class Day extends Enum{
 }

 class Month extends Enum{
 }

 public satic void main(String[] args){
     Day monday = new Day("monday");
         Month january = new Month("january");
     monday.compareTo(january);// 1
 }

上述1位置的compareTo方法，在简化的Enum情况下是可以的，但是在jdk中复杂的Enum下是不可以的。这也就是为什么jdk里的Enum要定义的这么复杂，目的就是为了限制Enum的子类只能和自己同类的实例进行比较。

说的浅显一点,就是更加明确使用的对象.更方便调用.
不然如果定一下成Object的话.还需要进行一步强转在继续使用

你可以反过来想一想如果没有限定类型同样的代码该怎么写，是不是会多写很多方法才能实现，或者写一些很别扭的代码才能实现

如楼上所说，明确对象，方便使用
不然没有泛型用object对象，还要进行装包、拆包或强转操作，没有效率

自己去看官方文档泛型的定义

泛型靠谱的用途就是将运行时期的错误放到了编译时期，避免了类型强转。具体使用你可以看我的一片博文
http://blog.csdn.net/whb3299065/article/details/79105750

自限定所做的就是要求在继承关系中，强制要求将正在定义的类当做参数传递给基类。可以保证类型参数必须与正在被定义的类相同:
1.提高了可读性，一看便知道里面放的是什么。
2.提高了安全性，防止对象的转换出错。

class SelfBounded>{

T element;

SelfBounded set(T arg){

element=arg;

return this;

}

T get(){return element;}

}

class A extends SelfBounded{}

class B extends SelfBounded{}

class C extends SelfBounded{

C setAndGet(C arg){

set(arg);

return get();

}

}

class D{}

//因为类D没有继承SelfBounded，所以该类编译失败。

//class E extends SelfBounded{}

class SelfBounding {

public static void main(String[] args) {

A a=new A();

a.set(new A());

a=a.set(new A()).get();

a=a.get();

C c=new C();

c=c.setAndGet(new C());

}

}