java泛型方法,java泛型方法具体实例

本文目录一览：

• 1、JAVA中的泛型用法一种： 返回值用法。
• 2、java 泛型类和泛型方法的区别
• 3、java中泛型的使用
• 4、简述java常用3种泛型定义及其作用
• 5、请教关于java的泛型方法
• 6、java中什么是泛型，怎么用泛型？

JAVA中的泛型用法一种： 返回值用法。

1、对于泛型方法来说，是可以接收不同类型的参数，比如下图，使用泛型来操作List集合，然后向List中添加一条数据，看是否可以添加成功，创建泛型方法如图所示。

2、然后在写一个main方法来测试一下这个泛型方法，先向集合中添加一条String类型的数据，打印List集合中的元素，如图所示。

3、上面是往List集合中添加了一个String类型的数据，下图往List集合中添加一条Integer类型的数据并打印，当然也可以自己创建对象进行添加。

4、泛型也是可以限制要使用的参数类型的，比如上面，list集合中，只想加入数字类型的数据，当然也是可以的，只要让类中的T继承Number就行了，如图所示。

5、下面在测试一下，向集合中添加一个Long类型的数据并打印，如图所示。

6、最后输出就完成了。

java 泛型类和泛型方法的区别

在java中

泛型类：是在实例化类的时候指明泛型的具体类型。

泛型方法：是在调用方法的时候指明泛型的具体类型。

定义泛型方法时：必须在返回值前边加一个T，来声明这是一个泛型方法，持有一个泛型T，然后才可以用泛型T作为方法的返回值，泛型方法不是仅仅可以有一个参数ClassT，可以根据需要添加其他参数。

定义泛型类时：ClassT的作用就是指明泛型的具体类型，而ClassT类型的变量C，可以用来创建泛型类的对象

java中泛型的使用

一般使用在集合上，比如现在将一个字符串类型放在集合里面，这时候，放入集合的字符会失去其本身的类型，只能是object类型，比如想要对这这个值进行转换， 很容易出现类型转换错误。可以使用泛型解决这个问题。

简述java常用3种泛型定义及其作用

泛型（Generic type 或者 generics）是对 Java 语言的类型系统的一种扩展，以支持创建可以按类型进行参数化的类。可以把类型参数看作是使用参数化类型时指定的类型的一个占位符，就像方法的形式参数是运行时传递的值的占位符一样。

定义泛型方法语法格式如下：

定义泛型方法时，必须在返回值前边加一个T，来声明这是一个泛型方法，持有一个泛型T，然后才可以用泛型T作为方法的返回值。

ClassT的作用就是指明泛型的具体类型，而ClassT类型的变量c，可以用来创建泛型类的对象。

请教关于java的泛型方法

Java泛型详解

概述

在引入范型之前，Java类型分为原始类型、复杂类型，其中复杂类型分为数组和类。引入范型后，一个复杂类型

就可以在细分成更多的类型。

例如原先的类型List，现在在细分成ListObject, ListString等更多的类型。

注意，现在ListObject, ListString是两种不同的类型，

他们之间没有继承关系，即使String继承了Object。下面的代码是非法的

    ListString ls = new ArrayListString();

    ListObject lo = ls;

这样设计的原因在于，根据lo的声明，编译器允许你向lo中添加任意对象（例如Integer），但是此对象是

ListString，破坏了数据类型的完整性。

在引入范型之前，要在类中的方法支持多个数据类型，就需要对方法进行重载，在引入范型后，可以解决此问题

（多态），更进一步可以定义多个参数以及返回值之间的关系。

例如

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 TestClassDefineT, S extends T {

     ….  

 }

 2.2 定义待类型参数方法

 在定义带类型参数的方法时，在紧跟可见范围修饰（例如public）之后的内,指定一个或多个类型参数的名字， 同时也可以对类型参数的取值范围进行限定，多个类型参数之间用,号分隔。

 定义完类型参数后，可以在定义位置之后的方法的任意地方使用类型参数，就像使用普通的类型一样。

 例如：

 public T, S extends T T testGenericMethodDefine(T t, S s){

     …

 }

 注意：定义带类型参数的方法，骑主要目的是为了表达多个参数以及返回值之间的关系。例如本例子中T和S的继 承关系， 返回值的类型和第一个类型参数的值相同。

 如果仅仅是想实现多态，请优先使用通配符解决。通配符的内容见下面章节。

 public T void testGenericMethodDefine2(ListT s){

     …

 }

 应改为

 public void testGenericMethodDefine2(List？ s){

     …

 }

3. 类型参数赋值

 当对类或方法的类型参数进行赋值时，要求对所有的类型参数进行赋值。否则，将得到一个编译错误。

 3.1 对带类型参数的类进行类型参数赋值

 对带类型参数的类进行类型参数赋值有两种方式

 第一声明类变量或者实例化时。例如

 ListString list;

 list = new ArrayListString;

 第二继承类或者实现接口时。例如

 public class MyListE extends ArrayListE implements ListE {…} 

 3.2 对带类型参数方法进行赋值

 当调用范型方法时，编译器自动对类型参数进行赋值，当不能成功赋值时报编译错误。例如

 public T T testGenericMethodDefine3(T t, ListT list){

     …

 }

 public T T testGenericMethodDefine4(ListT list1, ListT list2){

     …

 }

 Number n = null;

 Integer i = null;

 Object o = null;

 testGenericMethodDefine(n, i);//此时T为Number, S为Integer

 testGenericMethodDefine(o, i);//T为Object, S为Integer

 ListNumber list1 = null;

 testGenericMethodDefine3(i, list1)//此时T为Number

 ListInteger list2 = null;

 testGenericMethodDefine4(list1, list2)//编译报错

 3.3 通配符

 在上面两小节中，对是类型参数赋予具体的值，除此，还可以对类型参数赋予不确定值。例如

 List? unknownList;

 List? extends Number unknownNumberList;

 List? super Integer unknownBaseLineIntgerList; 

 注意： 在Java集合框架中，对于参数值是未知类型的容器类，只能读取其中元素，不能像其中添加元素， 因为，其类型是未知，所以编译器无法识别添加元素的类型和容器的类型是否兼容，唯一的例外是NULL

 ListString listString;

 List? unknownList2 = listString;

 unknownList = unknownList2;

 listString = unknownList;//编译错误

4. 数组范型

 可以使用带范型参数值的类声明数组，却不可有创建数组

 ListInteger[] iListArray;

 new ArrayListInteger[10];//编译时错误

5. 实现原理

5.1. Java范型时编译时技术，在运行时不包含范型信息，仅仅Class的实例中包含了类型参数的定义信息。

泛型是通过java编译器的称为擦除(erasure)的前端处理来实现的。你可以（基本上就是）把它认为是一个从源码到源码的转换，它把泛型版本转换成非泛型版本。

基本上，擦除去掉了所有的泛型类型信息。所有在尖括号之间的类型信息都被扔掉了，因此，比如说一个ListString类型被转换为List。所有对类型变量的引用被替换成类型变量的上限(通常是Object)。而且，无论何时结果代码类型不正确，会插入一个到合适类型的转换。

       T T badCast(T t, Object o) {

         return (T) o; // unchecked warning

       }

类型参数在运行时并不存在。这意味着它们不会添加任何的时间或者空间上的负担，这很好。不幸的是，这也意味着你不能依靠他们进行类型转换。

5.2.一个泛型类被其所有调用共享

下面的代码打印的结果是什么？

       ListString l1 = new ArrayListString();

       ListInteger l2 = new ArrayListInteger();

       System.out.println(l1.getClass() == l2.getClass());

或许你会说false，但是你想错了。它打印出true。因为一个泛型类的所有实例在运行时具有相同的运行时类(class)，

而不管他们的实际类型参数。

事实上，泛型之所以叫泛型，就是因为它对所有其可能的类型参数，有同样的行为；同样的类可以被当作许多不同的类型。作为一个结果，类的静态变量和方法也在所有的实例间共享。这就是为什么在静态方法或静态初始化代码中或者在静态变量的声明和初始化时使用类型参数（类型参数是属于具体实例的）是不合法的原因。

5.3. 转型和instanceof

泛型类被所有其实例(instances)共享的另一个暗示是检查一个实例是不是一个特定类型的泛型类是没有意义的。

       Collection cs = new ArrayListString();

       if (cs instanceof CollectionString) { …} // 非法

类似的，如下的类型转换

CollectionString cstr = (CollectionString) cs;

得到一个unchecked warning，因为运行时环境不会为你作这样的检查。

6. Class的范型处理

Java 5之后，Class变成范型化了。

JDK1.5中一个变化是类 java.lang.Class是泛型化的。这是把泛型扩展到容器类之外的一个很有意思的例子。

现在，Class有一个类型参数T, 你很可能会问，T 代表什么？它代表Class对象代表的类型。比如说，

String.class类型代表 ClassString，Serializable.class代表 ClassSerializable。

这可以被用来提高你的反射代码的类型安全。

特别的，因为 Class的 newInstance() 方法现在返回一个T, 你可以在使用反射创建对象时得到更精确的类型。

比如说，假定你要写一个工具方法来进行一个数据库查询，给定一个SQL语句，并返回一个数据库中符合查询条件

的对象集合(collection)。

一个方法是显式的传递一个工厂对象，像下面的代码：

interface FactoryT {

      public T[] make();

}

public T CollectionT select(FactoryT factory, String statement) { 

       CollectionT result = new ArrayListT();

       /* run sql query using jdbc */

       for ( int i=0; i10; 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 FactoryEmpInfo(){ 

    public EmpInfo make() { 

        return new EmpInfo();

        }

       } , ”selection string”);

也可以声明一个类 EmpInfoFactory 来支持接口 Factory：

class EmpInfoFactory implements FactoryEmpInfo { …

    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是泛型的，我们可以写：

CollectionEmpInfo emps=sqlUtility.select(EmpInfo.class, ”select * from emps”); …

public static T CollectionT select(ClassTc, String sqlStatement) { 

    CollectionT result = new ArrayListT();

    /* 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 ArrayListString();

ListString 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();

    } 

}

要小心你类库的客户端。

java中什么是泛型，怎么用泛型？

这是在各种Java泛型面试中，一开场你就会被问到的问题中的一个，主要集中在初级和中级面试中：

1：什么是泛型？

泛型就是广泛的类型，也是一种数据类型，而这种数据类型可以是任意类型，编写过程中当中不能确定类型，创建对象时必须指定具体类型，不指定也可以，但是会出现一些错误。

泛型是编译器行为，只能在编译期有效，如果能够跨过编译器，那么泛型就没有任何意义了。

2、泛型类

怎么定义泛型类？

在类后面加，中可以编写任意长度任意字符，不能是数值。（一般用26个大写英文字母表示）

泛型类 具体类型 变量名 = new 泛型类();

3.怎么使用泛型

有以下几种使用场景以及放在那种位置

泛型只能定义引用数据类型，而不能使用基本数据类型

泛型类、泛型方法、泛型接口、泛型通配符

例如:作用在类上时( public class Animal E { E pet; } ) , 泛型跟在类后边,可以指定用了泛型的类内部的 pet 的类型。

作用在对象上时( AnimalDog str = new AnimalDog(); ) , 泛型跟在类后边 , 使得对象类的的 pet 属性为 Dog类型。