1. private static<T> void swap (T[] a,int i,int j )
   
2.         {
   
3.                 T temp=a[i];
   
4.                 a[i]=a[j];
   
5.                 a[j]=temp;
   
6.         }

复制代码

这段程序想要实现数组元素的交换，但是数组类型未知，因此用了泛型，
问题就来了，(1)void前面那个<T>出现在这个位置我该怎么理解呢？这个函数没有要求有返回值啊，那这个T有什么用呢？如果换成<?>通配符岂不是更好吗，
(2)还有就是里面的那个数组定义的是T[],不是说数组元素不能使用参数化的类型吗，这个作何解释呢？

泛型：jdk1.5版本以后出现的一个安全机制。表现格式：< >
好处：
1：将运行时期的问题ClassCastException问题转换成了编译失败，体现在编译时期，程序员就可以解决问题。
2：避免了强制转换的麻烦。

只要带有<>的类或者接口，都属于带有类型参数的类或者接口，在使用这些类或者接口时，必须给<>中传递一个具体的引用数据类型。

泛型技术：其实应用在编译时期，是给编译器使用的技术，到了运行时期，泛型就不存在了。
为什么? 因为泛型的擦除：也就是说，编辑器检查了泛型的类型正确后，在生成的类文件中是没有泛型的。
在运行时，如何知道获取的元素类型而不用强转呢？
泛型的补偿：因为存储的时候，类型已经确定了是同一个类型的元素，所以在运行时，只要获取到该元素的类型，在内部进行一次转换即可，所以使用者不用再做转换动作了。

什么时候用泛型类呢？
　　　当类中的操作的引用数据类型不确定的时候，以前用的Object来进行扩展的，现在可以用泛型来表示。这样可以避免强转的麻烦，而且将运行问题转移到的编译时期。
----------------------------------------------------------
泛型在程序定义上的体现：
//泛型类：将泛型定义在类上。
class Tool<Q> {
        private Q obj;
        public  void setObject(Q obj) {
                this.obj = obj;
        }
        public Q getObject() {
                return obj;
        }
}
//当方法操作的引用数据类型不确定的时候，可以将泛型定义在方法上。
        public <W> void method(W w) {
                System.out.println("method:"+w);
        }
//静态方法上的泛型：静态方法无法访问类上定义的泛型。如果静态方法操作的引用数据类型不确定的时候，必须要将泛型定义在方法上。
        public static <Q> void function(Q t) {
                System.out.println("function:"+t);
        }
//泛型接口.
interface Inter<T> {
        void show(T t);
}
class InterImpl<R> implements Inter<R> {
        public void show(R r) {
                System.out.println("show:"+r);
        }
}
------------------------------------------------------------
泛型中的通配符：可以解决当具体类型不确定的时候，这个通配符就是 ?  ；当操作类型时，不需要使用类型的具体功能时，只使用Object类中的功能。那么可以用 ? 通配符来表未知类型。

泛型限定：
        上限：？extends E：可以接收E类型或者E的子类型对象。
        下限：？super E：可以接收E类型或者E的父类型对象。

上限什么时候用：往集合中添加元素时，既可以添加E类型对象，又可以添加E的子类型对象。为什么？因为取的时候，E类型既可以接收E类对象，又可以接收E的子类型对象。

下限什么时候用：当从集合中获取元素进行操作的时候，可以用当前元素的类型接收，也可以用当前元素的父类型接收。

泛型的细节：
1）、泛型到底代表什么类型取决于调用者传入的类型，如果没传，默认是Object类型；
2）、使用带泛型的类创建对象时，等式两边指定的泛型必须一致；
        原因：编译器检查对象调用方法时只看变量，然而程序运行期间调用方法时就要考虑对象具体类型了；
3）、等式两边可以在任意一边使用泛型，在另一边不使用(考虑向后兼容)；
ArrayList<String> al = new ArrayList<Object>();  //错
//要保证左右两边的泛型具体类型一致就可以了，这样不容易出错。
ArrayList<? extends Object> al = new ArrayList<String>();
al.add("aa");  //错
//因为集合具体对象中既可存储String，也可以存储Object的其他子类，所以添加具体的类型对象不合适，类型检查会出现安全问题。 ？extends Object 代表Object的子类型不确定，怎么能添加具体类型的对象呢？
public static void method(ArrayList<? extends Object> al) {
　　al.add("abc");  //错
        //只能对al集合中的元素调用Object类中的方法，具体子类型的方法都不能用，因为子类型不确定。

skill20 发表于 2014-4-25 22:29
泛型：jdk1.5版本以后出现的一个安全机制。表现格式：< >
好处：
1：将运行时期的问题ClassCastException问 ...

辛苦你了，这些内容我明白，我只是想知道我想问的那些东西的答案

我也是被泛型给搞晕了！

好晕啊 还得好好学啊~

第一个问题：
        本来void前面那个<T>是放在该方法所在的类名后面的，为了让不同方法可以操作不同类型，而且类型还不确定，那么可以将泛型定义在方法上。
        假设swap方法所属类为A，而swap方法实现的是交换数组i,j位置的元素（对象），可以假设类A中还有其他的方法如swap01( )、swap02( )......如果<T>放在类A的后面，那么当创建一个A的对象a以后，如果定义其类型为<int>,那么在使用其中的swap、swap01、swap02等方法时候的类型必须都是int。为了让对象a能调用这三个方法时使用不同的类型，比如swap方法用int，swap01方法用String，swap02用boolean，所以把<T>定义在方法上而不是类A的后面。至于用<T>还是用<?>,看你调用时候的类型了，<T>是固定的泛型，<?>只要是Object类的子类就行，使用<T>表示类型已经确定了，使用<?>类型不确定的话可以用。


第二个问题：
        具体的也不是太明白，但个人的理解是Java不支持声明泛型数组，数组的类型不可以是类型变量，但采用通配符的方式，如果泛型数组作为参数传递时候，当你调用该方法的时候其实数组的类型是已经确定了的，传到swap方法的时候数组已经不再是泛型的了。


希望能对楼主有用。

Silvester 发表于 2014-4-26 18:05
第一个问题：
        本来void前面那个是放在该方法所在的类名后面的，为了让不同方法可以操作不同类型， ...

恩，我慢慢想想哈，谢谢你

宋美成 发表于 2014-4-26 18:14
恩，我慢慢想想哈，谢谢你

当然，最主要的还有楼主的方法是静态的，静态方法不可以访问类上定义的泛型，而传入的数组的类型也不确定，那么久只能把泛型定义在方法上了！

编译器不允许创建泛型变量的数组。即在创建数组实例时，数组的元素不能使用参数化的类型。
例如，下面语句有错误：
Vector<Integer> vectorList[] = new Vector<Integer>[10];
跟楼主说的不一样