关于泛型的一些问题

一、泛型在任何运行时需要知道确切类型信息的操作都将无法工作

package generics;
//: generics/Erased.java
// {CompileTimeError} (Won't compile)

public class Erased<T> {
  private final int SIZE = 100;
  public static void f(Object arg) {
    if(arg instanceof T) {}          // Error
    T var = new T();                 // Error
    T[] array = new T[SIZE];         // Error
    T[] array = (T)new Object[SIZE]; // Unchecked warning
  }
} ///:~

二、泛型类型参数在声明什么类型就必须实例化什么类型,类型继承和多态不能用于泛型类型参数。

class Fruit {}
class Apple extends Fruit {}
class Orange extends Fruit {}
public class NonCovariantGenerics {
  // Compile Error: incompatible types:
  List<Fruit> flist = new ArrayList<Apple>();
} ///:~

在实例化一个List的时候 指定一个泛型类型,如果这个类型是Fruit,那么就代表后面所有继承Fruit的子类都可以添加到当前的集合中;但是在赋值的时候却是使用的 Apple,那么这个ArrayList 中的泛型定义就是 Apple类型,也就意味着后面对 这个 ArrayList 进行Add等操作都必须是Apple类型或者是Apple的子类;也就和前面的Fruit以及Fruit的子类自相矛盾了;所以不允许这样进行擦除。

三、List<? extends T> 这里的T可以是任何类或者接口,?可以是T代表的这个类本身或子类;List<? super T>这里?可以是T代表的这个类本身或它的父类;

四、泛型对象的泛型参数类型在声明的时候确定

Holder<?> unbounded = new Holder<Long>();

这里unbounded的泛型类型参数是未知的;因为进行了泛型转型 擦除掉了。

五、泛型类对象做参数,使用方法的时候,传递的对象的泛型参数必须一致

package generics;
public class Wildcards {

  static <T> T wildSubtype(Holder<? extends T> holder, T arg) {
    T t = holder.get();
    return t;
  }
  static <T> void wildSupertype(Holder<? super T> holder, T arg) {
    holder.set(arg);
    Object obj = holder.get();
  }
  public static void main(String[] args) {
    Holder<Long> qualified = new Holder<Long>();
    Holder<?> unbounded = new Holder<Long>();
    Holder<? extends Long> bounded = new Holder<Long>();
    Long lng = 1L;

    Long r10 = wildSubtype(qualified, lng);
    // OK, but can only return Object:
    Object r11 = wildSubtype(unbounded, lng);//Error
    Long r12 = wildSubtype(bounded, lng);

    wildSupertype(qualified, lng);
     wildSupertype(unbounded, lng); // Error:
    //   wildSupertype(Holder<? super T>,T) cannot be
    //   applied to (Holder<capture of ?>,Long)
     wildSupertype(bounded, lng); // Error:
    //   wildSupertype(Holder<? super T>,T) cannot be
    //  applied to (Holder<capture of ? extends Long>,Long)
  }
} ///:~

 Object r11 = wildSubtype(unbounded, lng);//Error
wildSupertype(unbounded, lng); // Error:
wildSupertype(bounded, lng); // Error:

这三句话都是因为参数的泛型参数类型不对出错。

Long r12 = wildSubtype(bounded, lng);

这句没出错,说明参数可以为参数类型不确定的泛型。

六、 静态方法中不能使用类的泛型。

七、要用到泛型的方法必须在方法声明的时候声明为泛型方法。

格式为:

public static <T> void fromArrayToCollection(T[] a, Collection<T> c){//方法实现}//其中T不能是类的泛型

八、泛型通配符

泛型通配符的主要作用是为了在方法调用时,泛型参数使用通配符就可以让该参数类型不受限制。

1.使用类型 通配符:?,比如:List<?> ,Map<?,?>
List<?>是List<String>、List<Object>等各种泛型List的父类。
2. 读取List<?>的对象list中的元素时,永远是安全的,因为不管list的真实类型是什么,它包含的都是Object。
3. 写入list中的元素时,不行。因为我们不知道c的元素类型,我们不能向其中添加对象。唯一的例外是null,它是所有类型的成员。

•  将任意元素加入到其中不是类型安全的:
• Collection<?> c = new ArrayList<String>();
• c.add(new Object()); // 编译时错误
•  因为我们不知道c 的元素类型,我们不能向其中添加对象

• add方法有类型参数E作为集合的元素类型。我们传给add的任何参数都必须是一个未知类型的子类。因为我们不知道那是什么类型,所以我们无法传任何东西进去。
•  唯一的例外的是null ,它是所有类型的成员。
•  另一方面,我们可以调用get() 方法并使用其返回值。返回值是一个未知的类型,但是我们知道,它总是一个Object

public static void main(String[] args) {
List<?> list = null;
list = new ArrayList<String>();
list = new ArrayList<Double>();
//list.add(3);
list.add(null);
List<String> l1 = new ArrayList<String>();
List<Integer> l2 = new ArrayList<Integer>();
l1.add(“ 六星教育");
l2.add(15);
read(l1);
read(l2); }
static void read(List<?> list){
for(Object o : list){
System.out.println(o);
} }

• <?>
• 允许所有泛型的引用调用
• 举例:
• <? extends Number> ( 无穷小 , Number]
• 只允许泛型为Number及Number子类的引用调用
• <? super Number> [Number ,  无穷大)
• 只允许泛型为Number及Number父类的引用调用
• <? extends Comparable>
• 只允许泛型为实现Comparable接口的实现类的引用调用

public static void printCollection3(Collection<?
extends Person> coll){
//Iterator只能用Iterator<?>或Iterator<? extends
Person>.why?
Iterator<?> iterator = coll.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
} }
public static void printCollection4(Collection<? super
Person> coll){
Iterator<?> iterator = coll.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
} }
时间: 2017-01-14

关于泛型的一些问题的相关文章

java se-使用泛型打印输出任意类型的数组,为什么调用时有错误?

问题描述 使用泛型打印输出任意类型的数组,为什么调用时有错误? import java.util.Arrays; public class FanXing { public static void printMatrix(T[][] matrix){ for(int i=0;i<matrix.length;i++){ System.out.println(Arrays.toString(matrix[i])); } } public static void main(String[] args)

诊断Java代码: 轻松掌握 Java 泛型,第4部分

至此,在这个讨论 JSR-14 和 Tiger 中泛型类型的微型系列中,我们已经探讨了: 泛型类型及被设计成支持它们的即将发布的功能 基本类型.受约束的泛型以及多态方法上的限制 几个强加给这些 Java 扩展的限制 这些扩展语言的编译器所用的实现策略如何使这些限制成为必需 在泛型类型中添加对"裸"类型参数的 new 操作的支持所带来的影响 本月,我们将探讨在可以处理 mixin(可能被期望是泛型类型中最强大的功能)之前需要先解决的问题,以此来结束对 Java 语言中泛型类型的讨论. m

诊断Java代码: 轻松掌握Java泛型,第3部分

这一系列主要讨论在 Java 编程中添加泛型类型,本文是其中的一篇,将研究还未讨论过的有关使用泛型的两个限制之一,即添加对裸类型参数的 new 操作的支持(如类 C<T> 中的 new T() ). 正如我 上个月所提到的那样,Tiger 和 JSR-14 通过使用"类型消除(type erasure)"对 Java 语言实现泛型类型.使用类型消除(type erasure),泛型类型仅用于类型检查:然后,用它们的上界替换它们.由此定义可知:消除将与如 new T() 之类

泛型-c# 动态创建控件 及触发事件 即插即用。

问题描述 c# 动态创建控件 及触发事件 即插即用. 各大大好,初来驾到,请大家多多关照,问题是这样的.需求 :需要动态添加控件.然后需要项目做出来后要实现"即插即用"的特点.(即插即用:我们要是更新一个功能,用户只要更新这个控件就可以直接使用,而不用更新整个客服端)问题 :知道要用泛型来写,但是看了一天了,不知道如何下手,现已写了如下代码:using System;using System.Collections.Generic;using System.Linq;using Sys

泛型

 什么是Java泛型                1.java泛型是java SE 1.5的新特性,泛型的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数.这种参数类型可以用在类.接口和方法的创建中,分别称为泛型类.泛型接口.泛型方法.                2.java泛型可以让你消除代码中的强制类型转换,同时获得一个附加的类型检查层,该检查层可以防止有人将错误类型的键或值保存在集合中.这就是泛型所做的工作. 为什么要有泛型 先来看看以下代码,        publi

泛型T 如何在扩展方法中使用?

问题描述 泛型T 如何在扩展方法中使用? 本来想了解一下扩展方法,但是看到文库中的实例明显有问题,特来提问 泛型对象T 如何使用Length 属性? 可以像类中一样加继承于某某类的约束吗? http://wenku.baidu.com/link?url=Vz-Cjrq24tvblbk0l1I4IPYYfZ82jkGpzGBoNBDhi6qSCJko9hSTcrKGWrunO91TqTgyqB0AMvueHUP1or-mi8ktWMejceDW6Y-OphMnBh7 public static c

java泛型type体系整理

一直对jdk的ref使用比较模糊,早上花了点时间简单的整理了下,也帮助自己理解一下泛型的一些处理.   java中class,method,field的继承体系     java中所有对象的类型定义类Type   说明:    Type :  Type is the common superinterface for all types in the Java programming language. These include raw types, parameterized types, 

关于泛型实例声明类型的问题,问题在注释里面

问题描述 关于泛型实例声明类型的问题,问题在注释里面 class Employee{ } class Manager extends Employee{ }class CEO extends Manager{ }public class Test{ public static void main(String[] args) { List<? super Manager> list=new ArrayList(); //请问,new ArrayList()中,这里面的Manager有什么用吗?

求个泛型排序写法,如下。

问题描述 求个泛型排序写法,如下. public static List<T> SortAsc<T>(List<T> source, string sortby) { List<T> tlist = source.OrderBy(x => x.GetType().GetProperty(sortby)).ToList<T>(); return tlist; } 这个方法我写的,测试根本没排序,求大神指点迷津 解决方案 List<T&g

Java泛型&lt;? extends T&gt;和&lt;? super T&gt;

<? extends T>是泛型的上界(含),<? super T>是泛型的下界(含), 而且,对泛型不能只约束下限,如果只对子类做约束,父类可以千奇百怪. extends后面跟的类型如<任意字符 extends 类/接口>表示泛型的上限, super表示泛型的下限. 1 2 3 4 5 6 7 8 9 10 import java.util.*; class Demo<T extends AbstractList>{} public class Test