java接口泛型方法

A. java获取泛型class

很多朋友都想知道java怎么获取泛型class？下面侍袭就一起来了解一下吧~
获取泛型Class的方法
Class类的方法：
public Type getGenericSuperclass()
方法作用：

如果超类是参数化类型，则返回的 Type 对象必须准确反映源代码中所使用的实际类型参数。如果以前未曾创建表示超类的参数化类型，则创建这个类型。有关参数化老做兄类型创建过程的语义，请参阅 ParameterizedType 声明胡好。如果此 Class 表示 Object 类、接口、基本类型或 void，则返回 null。如果此对象表示一个数组类，则返回表示 Object 类的 Class 对象。

ParameterizedType类的方法：

Type[] getActualTypeArguments()

方法作用：返回表示此类型实际类型参数的 Type 对象的数组。

注意，在某些情况下，返回的数组为空。如果此类型表示嵌套在参数化类型中的非参数化类型，则会发生这种情况。

二、获取泛型Class对象

（解析Excel的类代码较多，这里定义几个简单的类记录）

定义获取泛型Class对象的工具类

GenericSuperclassUtil
import java.lang.reflect.ParameterizedType; import java.lang.reflect.Type; public class GenericSuperclassUtil { /* * 获取泛型类Class对象，不是泛型类则返回null */ public static Class  getActualTypeArgument(Class  clazz) { Class  entitiClass = null; Type genericSuperclass = clazz.getGenericSuperclass(); if (genericSuperclass instanceof ParameterizedType) { Type[] actualTypeArguments = ((ParameterizedType) genericSuperclass) .getActualTypeArguments(); if (actualTypeArguments != null && actualTypeArguments.length > 0) { entitiClass = (Class ) actualTypeArguments[0]; } } return entitiClass; } }
定义BaseService ，用来测试不使用父类时泛型Class的获取

BaseService
public class BaseService  { public Class  getEntityClass() { return GenericSuperclassUtil.getActualTypeArgument(this.getClass()); } }
测试BaseService.getEntityClass() @Testpublic void testBaseService() { System.out.println(new BaseService ().getEntityClass());// 控制台输出：null }

B. Java中怎样使用泛型T类的方法

调用泛型方法语法格式如下publicclassExampleA{
public<T>voidf(Tx){
System.out.println(x.getClass().getName());
}

publicstaticvoidmain(String[]args){
ExampleAea=newExampleA();
ea.f("");
ea.f(10);
ea.f('a');
ea.f(ea);
}
}

输出结果：

1. java.lang.String

2. java.lang.Integer

3. java.lang.Character

4. ExampleA

使用泛型方法时，不必指明参数类型，编译器会自己找出具体的类型。泛型方法除了定义不同，调用就像普通方法一样。

需要注意，一个static方法，无法访问泛型类的类型参数，所以，若要static方法需要使用泛型能力，必须使其成为泛型方法。

C. java中泛型指的是什么

我来简述一下泛型的知识吧:

如果一个类的后面跟上一个尖括号,表示这个类是泛型类.

可以这样声明:class 名称<泛型列表>
如:class A<E>
其中A是泛型类的名称,E是泛型.(可以是任何对象或接口)

其中给出的泛型可以作为类的成员变量的类型,方法的类型以及局部变量的类型.类体和变通类完全一样,由成员变量和方法构成.

举个例子:
class Chorus<E,F>
{
void makeChorus(E person,F yueqi)
{
yueqi.toString();
person.toString() ;
}
}
--------------
上面的类中将类E和类F作为类Chorus的一部分来使用.这就是泛型类的目的,将多个类包含进一个类来使用!!!

如果你想深入理解就可以找一些书来看,一些基本的教材里面也都有提到泛型的.

希望我说的对你有所帮助!!!

D. 请教关于java的泛型方法

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();
   }
   }
   要小心你类库的客户端。

E. Java接口内定义泛型方法如何实现

接口 IHuman.java

public interface IHuman<K, V> {
V execute(K request) throws Exception;
}

实现 MaleHuman.java
public class MaleHuman implements IHuman<String, String> {
@Override
public String execute(String request) throws Exception {
return ...;
}
}

按照以上接口内的泛型方法，能进行子类实现也不会报错。
但是接口内的泛型方法换种写法，就不知道如何写实现了。
接口 IHuman.java (改)
public interface IHuman {
<K, V> V execute(K request) throws Exception;
}

F. java编程题：请按照下列提示编写一个泛型接口以及其实现类

Generic.java：
package com.example.demo;

public interface Generic<T> {

void get(T t);
}

GenericImpl.java：

package com.example.demo;

public class GenericImpl<T> implements Generic<T> {

@Override
public void get(T t) {

}
}

G. java中泛型是什么意思，作用是什么

java 泛型是java SE 1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。
泛型（Generic type 或者 generics）是对 Java 语言的类型系统的一种扩展，以支持创建可以按类型进行参数化的类。可以把类型参数看作是使用参数化类型时指定的类型的一个占位符，就像方法的形式参数是运行时传递的值的占位符一样。
可以在集合框架（Collection framework）中看到泛型的动机。例如，Map 类允许您向一个 Map 添加任意类的对象，即使最常见的情况是在给定映射（map）中保存某个特定类型（比如 String）的对象。
因为 Map.get() 被定义为返回 Object，所以一般必须将 Map.get() 的结果强制类型转换为期望的类型，如下面的代码所示：

Map m = new HashMap();
m.put("key", "blarg");
String s = (String) m.get("key");

要让程序通过编译，必须将 get() 的结果强制类型转换为 String，并且希望结果真的是一个 String。但是有可能某人已经在该映射中保存了不是 String 的东西，这样的话，上面的代码将会抛出 ClassCastException。
理想情况下，您可能会得出这样一个观点，即 m 是一个 Map，它将 String 键映射到 String 值。这可以让您消除代码中的强制类型转换，同时获得一个附加的类型检查层，该检查层可以防止有人将错误类型的键或值保存在集合中。这就是泛型所做的工作。

泛型的好处
Java 语言中引入泛型是一个较大的功能增强。不仅语言、类型系统和编译器有了较大的变化，以支持泛型，而且类库也进行了大翻修，所以许多重要的类，比如集合框架，都已经成为泛型化的了。
这带来了很多好处：
1，类型安全。 泛型的主要目标是提高 Java 程序的类型安全。通过知道使用泛型定义的变量的类型限制，编译器可以在一个高得多的程度上验证类型假设。没有泛型，这些假设就只存在于程序员的头脑中（或者如果幸运的话，还存在于代码注释中）。
2，消除强制类型转换。 泛型的一个附带好处是，消除源代码中的许多强制类型转换。这使得代码更加可读，并且减少了出错机会。
3，潜在的性能收益。 泛型为较大的优化带来可能。在泛型的初始实现中，编译器将强制类型转换（没有泛型的话，程序员会指定这些强制类型转换）插入生成的字节码中。但是更多类型信息可用于编译器这一事实，为未来版本的 JVM 的优化带来可能。由于泛型的实现方式，支持泛型（几乎）不需要 JVM 或类文件更改。所有工作都在编译器中完成，编译器生成类似于没有泛型（和强制类型转换）时所写的代码，只是更能确保类型安全而已。

Java语言引入泛型的好处是安全简单。泛型的好处是在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的，提高代码的重用率。
泛型在使用中还有一些规则和限制：
1、泛型的类型参数只能是类类型（包括自定义类），不能是简单类型。
2、同一种泛型可以对应多个版本（因为参数类型是不确定的），不同版本的泛型类实例是不兼容的。
3、泛型的类型参数可以有多个。
4、泛型的参数类型可以使用extends语句，例如<T extends superclass>。习惯上成为“有界类型”。
5、泛型的参数类型还可以是通配符类型。例如Class<?> classType = Class.forName(Java.lang.String);
泛 型还有接口、方法等等，内容很多，需要花费一番功夫才能理解掌握并熟练应用。在此给出我曾经了解泛型时候写出的两个例子（根据看的印象写的），实现同样的 功能，一个使用了泛型，一个没有使用，通过对比，可以很快学会泛型的应用，学会这个基本上学会了泛型70%的内容。

H. java泛型深入解释：public <T> Test<T> tttttt(String s,Bean bean) {}

public<T>腔升配Test<T>tttttt(Strings,Bean笑胡bean){}

• 第一个<T>是固定语法 可以理解为在这个方法中使用的泛型用符号T表示，当然你也可以伍指用别的名字。

• Test<T> 说明类型Test的定义中也使用了泛型public class Test<T> {}
  

I. java中泛型的使用

泛型可以避免强制类型转换，设定集合对象中存储的对象类型。
比如List<String> list = new ArrayList<String>();
那在这个list中，只能存储字符串对象。