java泛型class

❶ java 泛型 Class

给你顺序解释下泛型的意思哈：

<T>：定义一个泛型
T ：定义方法返回的类型是之前定义的泛型类型
Class<? extends T> 这个是定义参数的类型为Class， 但是这个Class必须是和之前定义的泛型有继承关系的。？表示任意类的Class，不过后面跟了extends 表明了条件。

❷ Java 泛型 Class< extends T>

泛型中<? extends T>和<? super T> 差别
<? extends T>和<? super T>含有JAVA5.0的新的概念。由于它们的外表导致了很多人误解了它们的用途：
1.<?
extends T>首先你很容易误解它为继承于T的所有类的集合，这是大错特错的，相信能看下去你一定见过或用过List<?
extends T>吧？为什么我说理解成一个集合是错呢？如果理解成一个集合那为什么不用List<T>来表示？所以<?
extends
T>不是一个集合，而是T的某一种子类的意思，记住是一种，单一的一种，问题来了，由于连哪一种都不确定，带来了不确定性，所以是不可能通过
add（）来加入元素。你或许还觉得为什么add(T)不行?因为<? extends
T>是T的某种子类，能放入子类的容器不一定放入超类，也就是没可能放入T。
2.<? super T>这里比较容易使用，没<? extends T>这么多限制，这里的意思是，以T类为下限的某种类，简单地说就是T类的超类。但为什么add(T)可以呢？因为能放入某一类的容器一定可以放入其子类，多态的概念。
擦除
也
许泛型最具挑战性的方面是擦除（erasure），这是 Java
语言中泛型实现的底层技术。擦除意味着编译器在生成类文件时基本上会抛开参数化类的大量类型信息。编译器用它的强制类型转换生成代码，就像程序员在泛型出
现之前手工所做的一样。区别在于，编译器开始已经验证了大量如果没有泛型就不会验证的类型安全约束。
通过擦除实现泛型的含意是很重要的，并
且初看也是混乱的。尽管不能将List<Integer> 赋给List<Number>，因为它们是不同的类型，但是
List<Integer> 和 List<Number> 类型的变量是相同的类！要明白这一点，请评价下面的代码：
new List<Number>().getClass() == new List<Integer>().getClass()
编译器只为 List 生成一个类。当生成了 List 的字节码时，将很少剩下其类型参数的的跟踪。
当
生成泛型类的字节码时，编译器用类型参数的擦除替换类型参数。对于无限制类型参数（<V>），它的擦除是
Object。对于上限类型参数（<K extends Comparable<K>>），它的擦除是其上限（在本例中是
Comparable）的擦除。对于具有多个限制的类型参数，使用其最左限制的擦除。
如果检查生成的字节码，您无法说出 List<Integer> 和 List<String> 的代码之间的区别。类型限制 T 在字节码中被 T 的上限所取代，该上限一般是 Object。

多重限制
一个类型参数可以具有多个限制。当您想要约束一个类型参数比如说同时为 Comparable 和 Serializable 时，这将很有用。多重限制的语法是用“与”符号分隔限制：
class C<T extends Comparable<? super T>&Serializable>
通配符类型可以具有单个限制 —— 上限或者下限。一个指定的类型参数可以具有一个或多个上限。具有多重限制的类型参数可以用于访问它的每个限制的方法和域。
类型形参和类型实参
在
参数化类的定义中，占位符名称（比如 Collection<V> 中的 V）叫做类型形参（type
parameter），它们类似于方法定义中的形式参数。在参数化类的变量的声明中，声明中指定的类型值叫做类型实参（type
argument），它们类似于方法调用中的实际参数。但是实际中二者一般都通称为“类型参数”。所以给出定义：
interface Collection<V> { ... }
和声明：
Collection<String> cs = new HashSet<String>();
那么，名称 V（它可用于整个 Collection 接口体内）叫做一个类型形参。在 cs 的声明中，String 的两次使用都是类型实参（一次用于 Collection<V>，另一次用于 HashSet<V>）。
关
于何时可以使用类型形参，存在一些限制。大多数时候，可以在能够使用实际类型定义的任何地方使用类型形参。但是有例外情况。不能使用它们创建对象或数组，
并且不能将它们用于静态上下文中或者处理异常的上下文中。还不能将它们用作父类型（class Foo<T> extends
T），不能用于 instanceof 表达式中，不能用作类常量。
类似地，关于可以使用哪些类型作为类型实参，也存在一些限制。类型实参
必须是引用类型（不是基本类型）、通配符、类型参数，或者其他参数化类型的实例化。所以您可以定义
List<String>（引用类型）、List<?>（通配符）或者
List<List<?>>（其他参数化类型的实例化）。在带有类型形参 T 的参数化类型的定义中，您也可以声明
List<T>（类型形参）。

❸ java 如何获取 泛型的 class

package com.leo.common;
public class Genericity<T> {
public static void main(String[] args) {
Genericity<String> test = new Genericity<>("test1");
System.out.println(test.getGenericityName());
Genericity<Double> test1 = new Genericity<>(new Double(123));
System.out.println(test1.getGenericityName());
}
private T data;
public Genericity(T data) {
this.data = data;
}
public T getData() {
return this.data;
}
public String getGenericityName() {
return data.getClass().getName();
}
}

❹ java中的泛型 求详细解释

1、Java泛型
其实Java的泛型就是创建一个用类型作为参数的类。就象我们写类的方法一样，方法是这样的method(String str1,String str2 ),方法中参数str1、str2的值是可变的。而泛型也是一样的，这样写class Java_Generics＜K,V＞，这里边的K和V就象方法中的参数str1和str2,也是可变。下面看看例子：
//code list 1
import Java.util.Hashtable;
class TestGen0＜K,V＞{
public Hashtable＜K,V＞ h=new Hashtable＜K,V＞();
public void put(K k, V v) {
h.put(k,v);
}
public V get(K k) {
return h.get(k);
}
public static void main(String args[]){
TestGen0＜String,String＞ t=new TestGen0＜String,String＞();
t.put("key", "value");
String s=t.get("key");
System.out.println(s);
}
}
正确输出:value
这只是个例子（Java中集合框架都泛型化了，这里费了2遍事.），不过看看是不是创建一个用类型作为参数的类，参数是K，V，传入的“值”是String类型。这个类他没有特定的待处理型别，以前我们定义好了一个类，在输入输入参数有所固定，是什么型别的有要求，但是现在编写程序，完全可以不制定参数的类型，具体用的时候来确定，增加了程序的通用性，像是一个模板。
呵呵，类似C++的模板（类似）。
1.1. 泛型通配符
下面我们先看看这些程序：
//Code list 2
void TestGen0Medthod1(List l) {
for (Object o : l)
System.out.println(o);
}
看看这个方法有没有异议，这个方法会通过编译的，假如你传入String，就是这样List＜String＞。
接着我们调用它,问题就出现了，我们将一个List＜String＞当作List传给了方法，JVM会给我们一个警告，说这个破坏了类型安全，因为从List中返回的都是Object类型的，而让我们再看看下面的方法。
//Code list 3
void TestGen0Medthod1(List＜String＞ l) {
for (Object o : l)
System.out.println(o);
}
因为这里的List＜String＞不是List＜Object＞的子类,不是String与Object的关系，就是说List＜String＞不隶属于list＜Object＞,他们不是继承关系，所以是不行的，这里的extends是表示限制的。
类型通配符是很神奇的，List＜?＞这个你能为他做什么呢?怎么都是“？”，它似乎不确定，他总不能返回一个？作为类型的数据吧，是啊他是不会返回一个“？”来问程序员的？JVM会做简单的思考的，看看代码吧，更直观些。
//code list 4
List＜String＞ l1 = new ArrayList＜String＞();
li.add(“String”);
List＜?＞ l2 = l1;
System.out.println(l1.get(0));
这段代码没问题的，l1.get(0)将返回一个Object。
1.2. 编写泛型类要注意：
1) 在定义一个泛型类的时候，在 “＜＞”之间定义形式类型参数，例如：“class TestGen＜K,V＞”，其中“K” , “V”不代表值，而是表示类型。
2) 实例化泛型对象的时候，一定要在类名后面指定类型参数的值（类型），一共要有两次书写。例如：
TestGen＜String,String＞ t=new TestGen＜String,String＞()；
3) 泛型中＜K extends Object＞,extends并不代表继承，它是类型范围限制。
2、泛型与数据类型转换
2.1. 消除类型转换
上面的例子大家看到什么了，数据类型转换的代码不见了。在以前我们经常要书写以下代码，如：
//code list 5
import Java.util.Hashtable;
class Test {
public static void main(String[] args) {
Hashtable h = new Hashtable();
h.put("key", "value");
String s = (String)h.get("key");
System.out.println(s);
}
}
这个我们做了类型转换，是不是感觉很烦的，并且强制类型转换会带来潜在的危险，系统可能会抛一个ClassCastException异常信息。在JDK5.0中我们完全可以这么做，如：
//code list 6
import Java.util.Hashtable;
class Test {
public static void main(String[] args) {
Hashtable＜String,Integer＞ h = new Hashtable＜String,Integer＞ ();
h.put("key", new Integer(123));
int s = h.get("key").intValue();
System.out.println(s);
}
}
这里我们使用泛化版本的HashMap,这样就不用我们来编写类型转换的代码了，类型转换的过程交给编译器来处理，是不是很方便，而且很安全。上面是String映射到String，也可以将Integer映射为String，只要写成HashTable＜Integer,String＞ h=new HashTable＜Integer,String＞();h.get(new Integer(0))返回value。果然很方便。

❺ java泛型T和class.getName一样吗

不一样，第一个class.getName();是Class对象的一个方法，它会返回一个类名的字符串，而sql = "from"+T，这句话的语法不正确。
还有Class 是一个类，Class 类的实例表示正在运行的 Java 应用程序中的类和接口，而泛型T 也是一个类，但他本身不是Class对象
下面给出一个测试代码：

package ysw;
import java.util.*;
class Food{}
public class Test<T>
{
public void s(T t){
String s = ""+t;//泛型T 将调用对象的toString()方法，返回该字符串由类名（对象是该类的一个实例）、at 标记符“@”和此对象哈希码的无符号十六进制表示 System.out.println(s);
Class<T> cl = (Class<T>) t.getClass();//让泛型赋给Class对象，
System.out.println(cl.getName());//调用Class的getName()方法，返回类名。
}
public static void main(String args[]){
Test<Food> tf = new Test<Food>();
tf.s(new Food());
}
}
////
output:

ysw.Food@1eb2c1b
ysw.Food

❻ java class<t> 泛型怎么写

E - Element (在集合中使用，因为集合中存放的是元素)
T - Type（Java 类）
K - Key（键）
V - Value（值）
N - Number（数值类型）
? - 表示不确定的java类型

举例说明：
Set<T> 表示 集合里 是 T类的实例
List<E> 表示 集合里 是 E类的实例
List<?> 表示 集合里的对象类型不确定，未指定
List 同 List<?> 是一样的。

泛型的作用：
1、用泛型：
Java代码 收藏代码
List<T> list=new ArrayList<T>();
T t=list.get(0);

2、不用泛型：
Java代码 收藏代码
List list=new ArrayList();
T t=(T)list.get(0);

❼ 在java中，使用泛型，比如说T,但是T.class就要报错。我想获取T的class对象怎样获取啊。

T.getClass()或者T.class都是非法的，因为T是泛型变量。
由于一个类的类型是什么是在编译期处理的，故不能在运行时直接在Base里得到T的实际类型。
有一种变通的实现方式：
import java.lang.reflect.Array;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

public class Generic extends Base<String> {
public static void main(String[] args) {
Generic c = new Generic();
System.out.println(c.array);
}

Object array ;
public Generic() {
array = Array.newInstance(getGenericType(0), 100);
}
}

class Base<T> {
public Class getGenericType(int index) {
Type genType = getClass().getGenericSuperclass();
if (!(genType instanceof ParameterizedType)) {
return Object.class;
}
Type[] params = ((ParameterizedType) genType).getActualTypeArguments();
if (index >= params.length || index < 0) {
throw new RuntimeException("Index outof bounds");
}
if (!(params[index] instanceof Class)) {
return Object.class;
}
return (Class) params[index];
}
}
其中Base<T>是泛型类，在父类中声明getGenericType，子类继承具体的Base<String>，那么在子类中就可以通过getGenericType(0)获取到String的class.

❽ java中泛型的class怎么获取

import java.lang.reflect.ParameterizedType;
public class GT1 extends GT2<Integer>{
public static void main(String[] args) {
System.out.println(((ParameterizedType)new GT1().getClass().getGenericSuperclass()));
}
}

则输出结果即为：
GT2<java.lang.Integer>

❾ java class类的泛型有什么意义

拿容器类来说吧。如果没有泛型，容器中对象都是默认Object类型，可能会将错误的类型放入容器中，取出的时候进行转型也是对Object进行强转。如果有错会抛出RuntimeException。加入泛型之后，就可以在编译期发现这种错误。

❿ java中如何得到泛型参数的class

泛型的目的就是为了避免强制类型转换，所以直接取出来就是object的类型了。
public
class
classtest
{
public
static
void
main(string[]
args)
{
list
liststr
=
new
arraylist
();
liststr.add("aaa");
liststr.add("bbb");
system.out.println(liststr.get(0));
}
}
你想要的应该是这个吧，只要取出来就是你定义类型的object了，在这个例子中是string。如果你给它定义的是integer类型的泛型的话，取出来就是integer了。