请教关于java的泛型方法

请教Java高手一个“自定义带泛型的方法”的技术问题。~

添加“”申明的是参数，意思是告诉编译器这是一个泛型方法，有这3个泛型的参数，不然编译器胡报错，它会认为你参数类型是错的，不存在T E K类型，你参数就不能用泛型了

如：List list = new ArrayList(); list.add("1");
list.add("2");
采用泛型写法后，list想加入一个Integer类型的对象时会出现编译错误，通过List，直接限定了list集合中只能含有String类型的元素，从而在后续如果进行for循环就无须进行强制类型转换，因为此时，集合能够记住元素的类型信息，编译器已经能够确认它是String类型了。

Java泛型详解

1. 概述
   在引入范型之前，Java类型分为原始类型、复杂类型，其中复杂类型分为数组和类。引入范型后，一个复杂类型
   就可以在细分成更多的类型。
   例如原先的类型List，现在在细分成List<Object>, List<String>等更多的类型。
   注意，现在List<Object>, List<String>是两种不同的类型，
   他们之间没有继承关系，即使String继承了Object。下面的代码是非法的
       List<String> ls = new ArrayList<String>();
       List<Object> lo = ls;
   这样设计的原因在于，根据lo的声明，编译器允许你向lo中添加任意对象（例如Integer），但是此对象是
   List<String>，破坏了数据类型的完整性。
   在引入范型之前，要在类中的方法支持多个数据类型，就需要对方法进行重载，在引入范型后，可以解决此问题
   （多态），更进一步可以定义多个参数以及返回值之间的关系。
   例如
   public void write(Integer i, Integer[] ia);
   public void write(Double  d, Double[] da);
   的范型版本为
   public <T> void write(T t, T[] ta);
   
   2. 定义&使用
    类型参数的命名风格为：
    推荐你用简练的名字作为形式类型参数的名字(如果可能，单个字符)。最好避免小写字母，这使它和其他的普通
    的形式参数很容易被区分开来。
    使用T代表类型，无论何时都没有比这更具体的类型来区分它。这经常见于泛型方法。如果有多个类型参数，我们
    可能使用字母表中T的临近的字母，比如S。
    如果一个泛型函数在一个泛型类里面出现，最好避免在方法的类型参数和类的类型参数中使用同样的名字来避免混
    淆。对内部类也是同样。
    
    2.1 定义带类型参数的类
    在定义带类型参数的类时，在紧跟类命之后的<>内,指定一个或多个类型参数的名字，同时也可以对类型参数的取
    值范围进行限定，多个类型参数之间用,号分隔。
    定义完类型参数后，可以在定义位置之后的类的几乎任意地方（静态块，静态属性，静态方法除外）使用类型参数，
    就像使用普通的类型一样。
    注意，父类定义的类型参数不能被子类继承。
    public class TestClassDefine<T, S extends T> {
        ....  
    }
    
    2.2 定义待类型参数方法
    在定义带类型参数的方法时，在紧跟可见范围修饰（例如public）之后的<>内,指定一个或多个类型参数的名字， 同时也可以对类型参数的取值范围进行限定，多个类型参数之间用,号分隔。
    定义完类型参数后，可以在定义位置之后的方法的任意地方使用类型参数，就像使用普通的类型一样。
    例如：
    public <T, S extends T> T testGenericMethodDefine(T t, S s){
        ...
    }
    注意：定义带类型参数的方法，骑主要目的是为了表达多个参数以及返回值之间的关系。例如本例子中T和S的继 承关系， 返回值的类型和第一个类型参数的值相同。
    如果仅仅是想实现多态，请优先使用通配符解决。通配符的内容见下面章节。
    public <T> void testGenericMethodDefine2(List<T> s){
        ...
    }
    应改为
    public void testGenericMethodDefine2(List<？> s){
        ...
    }
    
   3. 类型参数赋值
    当对类或方法的类型参数进行赋值时，要求对所有的类型参数进行赋值。否则，将得到一个编译错误。
    
    3.1 对带类型参数的类进行类型参数赋值
    对带类型参数的类进行类型参数赋值有两种方式
    第一声明类变量或者实例化时。例如
    List<String> list;
    list = new ArrayList<String>;
    第二继承类或者实现接口时。例如
    public class MyList<E> extends ArrayList<E> implements List<E> {...} 
    
    3.2 对带类型参数方法进行赋值
    当调用范型方法时，编译器自动对类型参数进行赋值，当不能成功赋值时报编译错误。例如
    public <T> T testGenericMethodDefine3(T t, List<T> list){
        ...
    }
    public <T> T testGenericMethodDefine4(List<T> list1, List<T> list2){
        ...
    }
    
    Number n = null;
    Integer i = null;
    Object o = null;
    testGenericMethodDefine(n, i);//此时T为Number, S为Integer
    testGenericMethodDefine(o, i);//T为Object, S为Integer
    
    List<Number> list1 = null;
    testGenericMethodDefine3(i, list1)//此时T为Number
    
    List<Integer> list2 = null;
    testGenericMethodDefine4(list1, list2)//编译报错
    
    3.3 通配符
    在上面两小节中，对是类型参数赋予具体的值，除此，还可以对类型参数赋予不确定值。例如
    List<?> unknownList;
    List<? extends Number> unknownNumberList;
    List<? super Integer> unknownBaseLineIntgerList; 
    注意： 在Java集合框架中，对于参数值是未知类型的容器类，只能读取其中元素，不能像其中添加元素， 因为，其类型是未知，所以编译器无法识别添加元素的类型和容器的类型是否兼容，唯一的例外是NULL
   
    List<String> listString;
    List<?> unknownList2 = listString;
    unknownList = unknownList2;
    listString = unknownList;//编译错误
    
   4. 数组范型
    可以使用带范型参数值的类声明数组，却不可有创建数组
    List<Integer>[] iListArray;
    new ArrayList<Integer>[10];//编译时错误
    
   5. 实现原理
   
   5.1. Java范型时编译时技术，在运行时不包含范型信息，仅仅Class的实例中包含了类型参数的定义信息。
   泛型是通过java编译器的称为擦除(erasure)的前端处理来实现的。你可以（基本上就是）把它认为是一个从源码到源码的转换，它把泛型版本转换成非泛型版本。
   基本上，擦除去掉了所有的泛型类型信息。所有在尖括号之间的类型信息都被扔掉了，因此，比如说一个List<String>类型被转换为List。所有对类型变量的引用被替换成类型变量的上限(通常是Object)。而且，无论何时结果代码类型不正确，会插入一个到合适类型的转换。
          <T> T badCast(T t, Object o) {
            return (T) o; // unchecked warning
          }
   类型参数在运行时并不存在。这意味着它们不会添加任何的时间或者空间上的负担，这很好。不幸的是，这也意味着你不能依靠他们进行类型转换。
   
   5.2.一个泛型类被其所有调用共享
   下面的代码打印的结果是什么？
          List<String> l1 = new ArrayList<String>();
          List<Integer> l2 = new ArrayList<Integer>();
          System.out.println(l1.getClass() == l2.getClass());
   或许你会说false，但是你想错了。它打印出true。因为一个泛型类的所有实例在运行时具有相同的运行时类(class)，
   而不管他们的实际类型参数。
   事实上，泛型之所以叫泛型，就是因为它对所有其可能的类型参数，有同样的行为；同样的类可以被当作许多不同的类型。作为一个结果，类的静态变量和方法也在所有的实例间共享。这就是为什么在静态方法或静态初始化代码中或者在静态变量的声明和初始化时使用类型参数（类型参数是属于具体实例的）是不合法的原因。
   
   5.3. 转型和instanceof
   泛型类被所有其实例(instances)共享的另一个暗示是检查一个实例是不是一个特定类型的泛型类是没有意义的。
          Collection cs = new ArrayList<String>();
          if (cs instanceof Collection<String>) { ...} // 非法
   类似的，如下的类型转换
   Collection<String> cstr = (Collection<String>) cs;
   得到一个unchecked warning，因为运行时环境不会为你作这样的检查。
   
   6. Class的范型处理
   Java 5之后，Class变成范型化了。
   JDK1.5中一个变化是类 java.lang.Class是泛型化的。这是把泛型扩展到容器类之外的一个很有意思的例子。
   现在，Class有一个类型参数T, 你很可能会问，T 代表什么？它代表Class对象代表的类型。比如说，
   String.class类型代表 Class<String>，Serializable.class代表 Class<Serializable>。
   这可以被用来提高你的反射代码的类型安全。
   特别的，因为 Class的 newInstance() 方法现在返回一个T, 你可以在使用反射创建对象时得到更精确的类型。
   比如说，假定你要写一个工具方法来进行一个数据库查询，给定一个SQL语句，并返回一个数据库中符合查询条件
   的对象集合(collection)。
   一个方法是显式的传递一个工厂对象，像下面的代码：
   interface Factory<T> {
         public T[] make();
   }
   public <T> Collection<T> select(Factory<T> factory, String statement) { 
          Collection<T> result = new ArrayList<T>();
          /* run sql query using jdbc */
          for ( int i=0; i<10; i++ ) { /* iterate over jdbc results */
               T item = factory.make();
               /* use reflection and set all of item’s fields from sql results */
               result.add( item );
          }
          return result;
   }
   你可以这样调用：
   select(new Factory<EmpInfo>(){ 
       public EmpInfo make() { 
           return new EmpInfo();
           }
          } , ”selection string”);
   也可以声明一个类 EmpInfoFactory 来支持接口 Factory：
   class EmpInfoFactory implements Factory<EmpInfo> { ...
       public EmpInfo make() { return new EmpInfo();}
   }
   然后调用：
   select(getMyEmpInfoFactory(), "selection string");
   这个解决方案的缺点是它需要下面的二者之一：
   调用处那冗长的匿名工厂类，或为每个要使用的类型声明一个工厂类并传递其对象给调用的地方，这很不自然。
   使用class类型参数值是非常自然的，它可以被反射使用。没有泛型的代码可能是：
   Collection emps = sqlUtility.select(EmpInfo.class, ”select * from emps”); ...
   public static Collection select(Class c, String sqlStatement) { 
       Collection result = new ArrayList();
       /* run sql query using jdbc */
       for ( /* iterate over jdbc results */ ) { 
           Object item = c.newInstance();
           /* use reflection and set all of item’s fields from sql results */
           result.add(item);
       }
           return result;
   }
   但是这不能给我们返回一个我们要的精确类型的集合。现在Class是泛型的，我们可以写：
   Collection<EmpInfo> emps=sqlUtility.select(EmpInfo.class, ”select * from emps”); ...
   public static <T> Collection<T> select(Class<T>c, String sqlStatement) { 
       Collection<T> result = new ArrayList<T>();
       /* run sql query using jdbc */
       for ( /* iterate over jdbc results */ ) { 
           T item = c.newInstance();
           /* use reflection and set all of item’s fields from sql results */
           result.add(item);
       } 
       return result;
   }
   来通过一种类型安全的方式得到我们要的集合。
   这项技术是一个非常有用的技巧，它已成为一个在处理注释(annotations)的新API中被广泛使用的习惯用法。
   
   7. 新老代码兼容
   
   7.1. 为了保证代码的兼容性，下面的代码编译器（javac）允许，类型安全有你自己保证
   List l = new ArrayList<String>();
   List<String> l = new ArrayList();
   
   7.2. 在将你的类库升级为范型版本时，慎用协变式返回值。
   例如，将代码
   public class Foo { 
       public Foo create(){
           return new Foo();
       }
   }
   
   public class Bar extends Foo { 
       public Foo create(){
           return new Bar();
       } 
   }
   采用协变式返回值风格，将Bar修改为
   public class Bar extends Foo { 
       public Bar create(){
           return new Bar();
       } 
   }
   要小心你类库的客户端。

编译器判断泛型方法的实际类型参数的过程叫做类型推断,类型推断的实现方法是一种非常复杂的过程.
根据调用泛型方法时实际传递的参数类型或返回值类型来推断,具体规则如下:
如果某类型变量只在方法参数列表或返回值的一处被调用了,那根据调用该方法时该处的实际类型来确定,即直接根据调用方法时传递的实际类型或方法返 回值的类型来确定泛型方法的参数类型.例如: swap(new String[3],3,4) --->static <E> void swap(E[] a,int i,int t)
当某个类型变量在方法的参数列表和返回值中被多次利用了,而且在调用方法时这多处的实际类型又是一样的,那么这也可以很明显的知道此泛型方法的参数类型.例如: add(3,5) --> static <T> T add(T a,T b)
当 某个类型变量在方法的参数列表和返回值中被多次利用了,而且在调用方法时这多处的实际类型又对应不同的类型,且返回值是void,那么这时取多处实际变量 类型的最大交集.例如: fill(new Integer[3],3.5f) --> static <T> void fill(T[] a,T i) ,此时T为Number,编译不会报错,但运行有问题.
当某个类型变量在方法的参数列表和返回值中被 多次利用了,且返回值不为空,在调用方法时这多处的实际类型又对应不同的类型,那么优先考虑返回值的类型.int x = add(3,3.5f) --> static <T> T add(T a,T b)
参数类型的类型推断具有传递性,
copy(new Integer[5],new String[5]) --> static <T> void copy(T[] a, T[] b) T为Object类型,没有问题
copy(new Vector<String>(),new Integer[5]) --> static <T> void copy(Collection<T> a, T[] b) 在new Vector<String>()时决定了T为String类型,而new Integer[5]不是String类型,这样会报错

泛型一般的用于继承或者反映，但是你想能过返回值来确实类型，这个好像不太可能，除非强转吧。

---

滨海县13151864044： 什么是JAVA 泛型,初学者应该怎么学习泛型. - ？
佴卿复方： 泛型是Java SE 1.5的新特性,泛型的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数.这种参数类型可以用在类、接口和方法的创建中,分别称为泛型类、泛型接口、泛型方法.Java语言引入泛型的好处是安全简单.是否拥...

滨海县13151864044： java中的泛型 求详细解释 - ？
佴卿复方： 1、Java泛型 其实Java的泛型就是创建一个用类型作为参数的类.就象我们写类的方法一样,方法是这样的method(String str1,String str2 ),方法中参数str1、str2的值是可变的.而泛型也是一样的,这样写class Java_Generics,这里边的K和V就...

滨海县13151864044： 请教关于java的泛型方法？
佴卿复方： 编译器判断泛型方法的实际类型参数的过程叫做类型推断,类型推断的实现方法是一种非常复杂的过程. 根据调用泛型方法时实际传递的参数类型或返回值类型来推断,具体规则如下: 如果某类型变量只在方法参数列表或返回值的一处被调用了...

滨海县13151864044： java中泛型指的是什么 - ？
佴卿复方： 我来简述一下泛型的知识吧:如果一个类的后面跟上一个尖括号,表示这个类是泛型类.可以这样声明:class 名称<泛型列表> 如:class A<E> 其中A是泛型类的名称,E是泛型.(可以是任何对象或接口)其中给出的泛型可以作为类的成员变...

滨海县13151864044： Java的泛型是如何工作的 - ？
佴卿复方： Java中的泛型,只在编译阶段有效.在编译过程中,正确检验泛型结果后,会将泛型的相关信息擦出,并且在对象进入和离开方法的边界处添加类型检查和类型转换的方法.也就是说,泛型信息不会进入到运行时阶段.

滨海县13151864044： java中什么是泛型,举例+讲解 (copy的就不要来了) - ？
佴卿复方： 泛型是java5才加入的,简单的讲就是对于集合中的对象进行约束,也增强了对象的安全.例如java5之前无泛型时:public ArrayList getList(); 调用者无法知道ArrayList中具体是什么类型的对象,只能进行强制转换.而java5后:public ArrayList<YourObject> getList() 调用者清楚的知道List中是什么,不会发生类型转换的错误.而实际上泛型的实现是在java编译器中实现的,通过反编译可以看到字节码中依然是坐了转换,只不过不用你来做了,所以一般业界对java泛型的实现是有一些不同意见的,认为其不是真正的泛型.

滨海县13151864044： Java面向对象之泛型怎么理解? - ？
佴卿复方： 给你说的通俗一点吧,首先Java是面向对象的,这个你必须深刻理解,不是表面上那么简单的理解就可以了 其次可以把泛型理解成一种对象,也就是一种固定的type之类的,比如定义一个学生类,然后在其他类里面指定某个参数为学生类的泛型,那么这个参数就只能是学生类这种类型的数据,就像int,sting之类的一样,它就像自己定义的一种类型一样 然后再把这个参数作为一种对象,也可以理解为学生类的一个实体一样,把他作为一个对象,然后对这个对象做操作,比如指定他的一些属性之类的 希望可以帮到你

滨海县13151864044： java中如何定义一个泛型函数? - ？
佴卿复方： 泛型(Generic type 或者 generics)是对 Java 语言的类型系统的一种扩展,以支持创建可以按类型进行参数化的类.可以把类型参数看作是使用参数化类型时指定的类型的一个占位符,就像方法的形式参数是运行时传递的值的占位符一样.定义泛型方法语法格式如下:定义泛型方法时,必须在返回值前边加一个<T>,来声明这是一个泛型方法,持有一个泛型T,然后才可以用泛型T作为方法的返回值.Class<T>的作用就是指明泛型的具体类型,而Class<T>类型的变量c,可以用来创建泛型类的对象.

滨海县13151864044： java 方法中如何在返回类型使用泛型 - ？
佴卿复方： 主要是一个编译期的检查,也避免了我们代码中的强制转换,比较经典的用法有泛型DAO,泛型Page的DTO.现在我要说的是一个挺有趣但是貌似还不是太多的人在代码中使用的方法,前段时间用guava和op4j的时候发现这样的用法,看看了...

滨海县13151864044： java中什么叫泛型? - ？
佴卿复方： 泛型.规定了此集合中元素的类型.例如:ArrayList<Integer> arr = new ArrayList<Integer> (); 这样就创建了一个包含整数的 ArrayList 对象.如果要自己定义泛型类,就用如下形式:class MyCollection<E> {...} 尖括号中的类型可以有限制,...