泛型javaextends

‘壹’ java中如何实现泛型类和泛型类之间的继承

A1的泛型参数要有两个，否则无法确定抽象父类的泛型。
public class inher
{
public static void main(String[] args)
{
var a1 = new A1<Child, Parent>();
a1.a = new Parent();
a1.b = new Child();
a1.a.parent = 1;
a1.b.child = 2;
System.out.println(a1.a.parent);
System.out.println(a1.b.child);
}
}

abstract class A<T>
{
public T a;
}

class A1<U extends T, T> extends A<T>
{
public U b;
}

class Parent
{
public int parent;
}

class Child extends Parent
{
public int child;
}

‘贰’ java <A extends Annotation> 中 A 是什么泛型，A不是对象

A应该是注解的Class;
对比参照以下信息:
1. Class有一个方法:isAnnotationPresent(Class<? extends Annotation> anno)
是用来判断anno是不是代表注解的,参数的泛型使用了extends,但anno是定义的注解的Class,并不是Annotation的子类或接口实现类,这也可以通过Class类方法isAssignableFrom(Class<?> cls)来判断.说明注解并不是Annotation的子类或实现类
2. Class还有两个方法:isAnnotation()和isInterface(),如果用注解来判断,这两个返回值都是true,但由1知道注解不是Annotation的子类,从表面看这就有问题了,为什么注解是Annotation却不是其子类呢?从isAnnotation()的解释可以得到答案:Returns true if this Class object represents an annotation type.这里使用了represents而不是extends
3. 从1和2的分析,问题就回到了泛型中extends的含义了,? extends不一定表示继承的子类或接口实现类!!

‘叁’ java 泛型extends为什么不能写

因为范围过小。

_紫龋颐且酪坏悖魏蔚姆盒捅淞浚ū热缯饫锏_）都是派生自Object，所以我们在填充泛型变量时，只能使用派生自Object的类，比如String,Integer,Double，等而不能使用原始的变量类型，比如int,double,float等。

‘肆’ JAVA中的泛型类是什么东西

在Java SE1.5之前，没有泛型的情况的下，通过对类型Object的引用来实现参数的“任意化”，“任意化”带来的缺点是要做显式的强制类型转换，而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况，编译器可能不提示错误，在运行的时候才出现异常，这是一个安全隐患。 1、泛型的类型参数只能是类类型（包括自定义类），不能是简单类型。2、同一种泛型可以对应多个版本（因为参数类型是不确定的），不同版本的泛型类实例是不兼容的。3、泛型的类型参数可以有多个。4、泛型的参数类型可以使用extends语句，例如<Textends superclass>。习惯上成为“有界类型”。5、泛型的参数类型还可以是通配符类型。例如Class<?> classType =Class.forName(java.lang.String);

‘伍’ java 如何继承泛型

下面一个子类继承泛型父类的例子，可以参考一下：

//父类是一个泛型
classParent<T>{
	
	privateTval;

	publicTgetVal(){
		returnval;
	}

	publicvoidsetVal(Tval){
		this.val=val;
	}
}

classChild1extendsParent<Integer>{
	
}

classChild2extendsParent<String>{
	
}

publicclassApp{

	publicstaticvoidmain(String[]argv){
		
		Child1c1=newChild1();
		c1.setVal(123456);
		System.out.println(c1.getVal());
		
		Child2c2=newChild2();
		c2.setVal("abcdef");
		System.out.println(c2.getVal());
		
	}
}

‘陆’ Java 泛型 lt;super T>中 super 怎么 理解与 extends 有何不同

java泛型是1.5引进的一个新概念.本题对于"?superT"和"?extendsT",我从书上摘个经典的例子给你看看,如果不能理解,那么你就参考以下书籍慢慢体会,循序渐进!"?superT"和"?extendsT",都是java泛型通配符,而用法又有区别,还有super和extends不是java类关系中的超类和继承的意思,他是通配符的下限和上限限制.下面看一个通配符得高级用法:在这一部分，我们来考虑一些通配符得高级用法。我们已经看到了上限通配符在从一个数据结构中进行读取的几个例子。现在考虑相反的情况，一个只写的数据结构。接口Sink是这种情况的一个简单例子。interfaceSink{voidflush(Tt);}我们可以想象他被如下面的代码一样使用。方法writeAll()被设计来把集合coll的所有元素flush到sinksnk，并且返回最后一个flush的元素。publicstaticTwriteAll(Collectioncoll,Sinksnk){Tlast=null;for(Tt:coll){last=t;snk.flush(last);}returnlast;}Sinks;Collectioncs;Stringstr=writeAll(cs,s);//非法的调用!!像上面所写，writeAll()的调用是非法的，因为没有有效的类型参数可以被推断出来。String或Object都不是T的合适的类型，因为Collection的元素和Sink的元素必须是同样的类型。我们可以解决这个问题，通过使用通配符来修改writeAll()的方法签名，如下：TwriteAll(Collectioncoll,Sinksnk){…}Stringstr=writeAll(cs,s);//可以调用但是返回值类型错误这个调用现在是合法的，但是赋值产生错误，因为推断出的返回值类型是Object因为T匹配了Sink的类型，Object。解决方案是使用一种我们还没有见过的有限制的通配符：有下限的通配符。语法?superT表示T的一个未知的父类（或者是T自己）。这跟我们用?extendsT表示T的一个未知的子类是对应的。TwriteAll(Collectioncoll,Sinksnk){…}Stringstr=writeAll(cs,s);//YES!!!使用这个语法，这个调用是合法的，推断出来的T是String，正是我们想要的。现在让我们看一个更现实的例子。一个java.util.TreeSet代表一个有序的元素是E类型的树。创建一个TreeSet的一个方法是传递一个Comparator对象给构造函数。这个Comparator将会用来按照需要对TreeSet进行排序。TreeSet(Comparatorc)Comparator接口是核心：interfaceComparator{intcompare(Tfst,Tsnd);}假定我们要创建一个TreeSet并传递一个合适的Comparator，我们需要传一个能比较String的Comparator。这可以是一个Comparator，也可以是一个Comparator。然而我们不能用Comparator来调用上面的构造函数。我们可以使用一个有下限的通配符来得到我们需要的灵活性：TreeSet(Comparatorc)这允许任何可用的Comparator被传递进去。作为使用下限通配符最终的例子，让我们来看看方法Collections.max()，它返回一个集合中的最大的元素。现在，为了让max()能工作，传进来的集合中的所有元素必须实现Comparatable接口。而且，他们必须都能够被彼此比较（allbecomparabletoeachother）。第一个尝试是：publicstatic>Tmax(Collectioncoll)就是说，方法的参数是某一个能和自己进行比较的T的集合。这限制太严格了。为什么？考虑一个能和任何对象进行比较的类型：classFooimplementsComparable{}Collectioncf=;Collections.max(cf);//应该能工作cf中的每个元素都可以和每个cf中的其他元素进行比较，因为每个这样的元素都是一个Foo,它可以和任意的对象进行比较，也可以和另一个Foo进行比较。但是，使用上面的方法签名，我们发现这个调用被拒绝。推断出来的类型必须是Foo，但是Foo没有实现接口Comparable。T精确的(exactly)和自己能比较是不需要的。所需要的是T能够和它的父类中的一个进行比较，这导出：（注：Collections.max()的实际方法签名更复杂，我们在第10部分再讨论。）publicstatic>Tmax(Collectioncoll)这个推论对大多数想让Comparable对任意类型生效的用法中都有效：你总是应该使用Comparable。总之，如果你有一个只使用类型参数T作为参数的API，它的使用应该利用下限通配符(?superT)的好处。相反的，如果API只返回T，你应该使用上限通配符(?extendsT)来给你的客户端更大的灵活性。（原文：rarbitrarytypes:YoualwayswanttouseComparable.Ingeneral,,(?superT).Conversely,iftheAPIonlyreturnsT,you'(?extendsT).）。

‘柒’ java泛型

java泛型是1.5引进的一个新概念.
本题对于"? super T"和"? extends T",我从书上摘个经典的例子给你看看,如果不能理解,那么你就参考以下书籍慢慢体会,循序渐进!

"? super T"和"? extends T",都是java泛型通配符,而用法又有区别,
还有super 和extends 不是java类关系中的超类和继承的意思,他是通配符的下限和上限限制.

下面看一个通配符得高级用法:
在这一部分，我们来考虑一些通配符得高级用法。我们已经看到了上限通配符在从一个数据结构中进行读取的几个例子。现在考虑相反的情况，一个只写的数据结构。

接口Sink是这种情况的一个简单例子。

interface Sink<T> {

void flush(T t);

}

我们可以想象他被如下面的代码一样使用。方法writeAll() 被设计来把集合coll的所有元素flush到sink snk，并且返回最后一个flush的元素。

public static <T> T writeAll(Collection<T> coll, Sink<T> snk) {

T last = null;

for (T t : coll) {

last = t;

snk.flush(last);

}

return last;

}

Sink<Object> s;

Collection<String> cs;

String str = writeAll(cs, s); // 非法的调用!!

像上面所写，writeAll() 的调用是非法的，因为没有有效的类型参数可以被推断出来。String 或 Object都不是T的合适的类型，因为Collection的元素和 Sink的元素必须是同样的类型。

我们可以解决这个问题，通过使用通配符来修改writeAll()的方法签名，如下：

<T> T writeAll(Collection<? extends T> coll, Sink<T> snk) { … }

String str = writeAll(cs, s); //可以调用但是返回值类型错误

这个调用现在是合法的，但是赋值产生错误，因为推断出的返回值类型是 Object因为T 匹配了Sink的类型，Object。

解决方案是使用一种我们还没有见过的有限制的通配符：有下限的通配符。语法 ? super T 表示T的一个未知的父类（或者是T自己）。这跟我们用? extends T 表示T的一个未知的子类是对应的。

<T> T writeAll(Collection<T> coll, Sink<? super T> snk) { … }

String str = writeAll(cs, s); // YES!!!

使用这个语法，这个调用是合法的，推断出来的T是String，正是我们想要的。

现在让我们看一个更现实的例子。一个 java.util.TreeSet<E> 代表一个有序的元素是E类型的树。创建一个TreeSet的一个方法是传递一个 Comparator 对象给构造函数。这个Comparator将会用来按照需要对TreeSet进行排序。

TreeSet(Comparator<E> c)

Comparator 接口是核心：

interface Comparator<T> { int compare(T fst, T snd); }

假定我们要创建一个 TreeSet<String> 并传递一个合适的 Comparator，我们需要传一个能比较String的Comparator。这可以是一个 Comparator<String>，也可以是一个 Comparator<Object>。然而我们不能用Comparator<Object>来调用上面的构造函数。我们可以使用一个有下限的通配符来得到我们需要的灵活性：

TreeSet(Comparator<? super E> c)

这允许任何可用的Comparator被传递进去。

作为使用下限通配符最终的例子，让我们来看看方法 Collections.max()，它返回一个集合中的最大的元素。

现在，为了让max()能工作，传进来的集合中的所有元素必须实现 Comparatable接口。而且，他们必须都能够被彼此比较（all be comparable to each other）。第一个尝试是：

public static <T extends Comparable<T>> T max(Collection<T> coll)

就是说，方法的参数是某一个能和自己进行比较的T的集合。这限制太严格了。

为什么？考虑一个能和任何对象进行比较的类型：

class Foo implements Comparable<Object> {...} ...

Collection<Foo> cf = ...;

Collections.max(cf); // 应该能工作

cf 中的每个元素都可以和每个cf中的其他元素进行比较，因为每个这样的元素都是一个Foo,它可以和任意的对象进行比较，也可以和另一个Foo进行比较。

但是，使用上面的方法签名，我们发现这个调用被拒绝。推断出来的类型必须是Foo，但是Foo没有实现接口 Comparable<Foo>。

T 精确的(exactly)和自己能比较是不需要的。所需要的是 T能够和它的父类中的一个进行比较，这导出：（注：Collections.max()的实际方法签名更复杂，我们在第10部分再讨论。）

public static <T extends Comparable<? super T>> T max(Collection<T> coll)

这个推论对大多数想让 Comparable 对任意类型生效的用法中都有效：你总是应该使用 Comparable<? super T>。

总之，如果你有一个只使用类型参数T作为参数的API，它的使用应该利用下限通配符( ? super T )的好处。相反的，如果API只返回T，你应该使用上限通配符( ? extends T )来给你的客户端更大的灵活性。

（原文：This reasoning applies to almost any usage of Comparable that is intended to work for arbitrary types: You always want to use Comparable<? super T>.

In general, if you have an API that only uses a type parameter T as an argument, its uses should take advantage of lower bounded wildcards (? super T). Conversely, if the API only returns T, you'll give your clients more flexibility by using upper bounded wildcards (? extends T). ）。

如果你想比较深刻的了解java泛型那么
建议你看看<Java1.5泛型指南>
中文链接地址:http://blog.csdn.net/explorers/archive/2005/08/15/454837.aspx#_Toc111865968
英文pdf格式地址:http://java.sun.com/j2se/1.5/pdf/generics-tutorial.pdf

‘捌’ java泛型的高级应用

在上面的例子中，由于没有限制class GenericsFoo<T>类型持有者T的范围，实际上这里的限定类型相当于Object，这和“Object泛型”实质是一样的。限制比如我们要限制T为集合接口类型。只需要这么做：
class GenericsFoo<T extends Collection>，这样类中的泛型T只能是Collection接口的实现类，传入非Collection接口编译会出错。
注意：<T extends Collection>这里的限定使用关键字extends，后面可以是类也可以是接口。但这里的extends已经不是继承的含义了，应该理解为T类型是实现Collection接口的类型，或者T是继承了XX类的类型。
下面继续对上面的例子改进，我只要实现了集合接口的类型： publicclassCollectionGenFoo<TextendsCollection>{privateTx;publicCollectionGenFoo(Tx){this.x=x;}publicTgetX(){returnx;}publicvoidsetX(Tx){this.x=x;}}实例化的时候可以这么写： {publicstaticvoidmain(Stringargs[]){CollectionGenFoo<ArrayList>listFoo=null;listFoo=newCollectionGenFoo<ArrayList>(newArrayList());//出错了,不让这么干。//原来作者写的这个地方有误，需要将listFoo改为listFoo1//需要将CollectionGenFoo<Collection>改为CollectionGenFoo<ArrayList>//CollectionGenFoo<Collection>listFoo1=null;//listFoo1=newCollectionGenFoo<ArrayList>(newArrayList());System.out.println("实例化成功!");}}当前看到的这个写法是可以编译通过，并运行成功。可是注释掉的两行加上就出错了，因为<T extends Collection>这么定义类型的时候，就限定了构造此类实例的时候T是确定的一个类型，这个类型实现了Collection接口，但是实现 Collection接口的类很多很多，如果针对每一种都要写出具体的子类类型，那也太麻烦了，我干脆还不如用Object通用一下。别急，泛型针对这种情况还有更好的解决方案，那就是“通配符泛型”。 虽然Java泛型简单的用 extends 统一的表示了原有的 extends 和 implements 的概念，但仍要遵循应用的体系，Java 只能继承一个类，但可以实现多个接口，所以你的某个类型需要用 extends 限定，且有多种类型的时候，只能存在一个是类，并且类写在第一位，接口列在后面，也就是：
<T extends SomeClass & interface1 & interface2 & interface3>
这里的例子仅演示了泛型方法的类型限定，对于泛型类中类型参数的限制用完全一样的规则，只是加在类声明的头部，如： publicclassDemo<TextendsComparable&Serializable>{//T类型就可以用Comparable声明的方法和Seriablizable所拥有的特性了} 为了解决类型被限制死了不能动态根据实例来确定的缺点，引入了“通配符泛型”，针对上面的例子，使用通配泛型格式为<? extends Collection>，“？”代表未知类型，这个类型是实现Collection接口。那么上面实现的方式可以写为： {publicstaticvoidmain(Stringargs[]){CollectionGenFoo<ArrayList>listFoo=null;listFoo=newCollectionGenFoo<ArrayList>(newArrayList());//出错了,不让这么干。//原来作者写的这个地方有误，需要将listFoo改为listFoo1//CollectionGenFoo<Collection>listFoo1=null;//listFoo1=newCollectionGenFoo<ArrayList>(newArrayList());System.out.println("实例化成功!");}}注意：
1、如果只指定了<?>，而没有extends，则默认是允许Object及其下的任何Java类了。也就是任意类。
2、通配符泛型不单可以向下限制，如<? extends Collection>，还可以向上限制，如<? super Double>，表示类型只能接受Double及其上层父类类型，如Number、Object类型的实例。
3、泛型类定义可以有多个泛型参数，中间用逗号隔开，还可以定义泛型接口，泛型方法。这些都与泛型类中泛型的使用规则类似。