Java的泛型约束和限制

不能用基本类型实例化类型参数



不能用类型参数代替基本类型:例如,没有Pair<double>,只有Pair<Double>,其原因是类型擦除。擦除之后,Pair类含有Object类型的域,而Object不能存储double值。这体现了Java语言中基本类型的独立状态。

运行时类型查询只适用于原始类型(raw type)



运行时:通常指在Classloader装载之后,JVM执行之时

类型查询:instanceof、getClass、强制类型转换

原始类型:即(raw type),泛型类型经编译器类型擦除后是Object或泛型参数的限定类型(例如Pair<T
extends
Comparable>,Comparable就是T的限定类型,转化后泛型的原始类型就是Comparable,所以Pair类不带泛型是Pair<Comparable>),即Pair类含有Comparable类型的域

JVM中没有泛型

eg:

if(a instanceof Pair<String>) //ERROR,仅测试了a是否是任意类型的一个Pair,会看到编译器ERROR警告

if(a instanceof Pair<T>) //ERROR

Pair<String> p = (Pair<String>) a;//WARNING,仅测试a是否是一个Pair

Pair<String> stringPair = ...;
Pair<Employee> employeePair = ...;
if(stringPair.getClass() == employeePair.getClass())  //会得到true,因为两次调用getClass都将返回Pair.class

不能创建参数化类型的数组(泛型数组)



参数化类型的数组:指类型带有泛型参数的数组,也即泛型数组,如Pair<T>[] 、 T[]

  不能实例化参数化类型的数组,例如:

Pair<String> table = new Pair<String>[10]; //ERROR

  在这里我们假设可以实例化,那么经编译器类型擦除后,table的类型是Pair[],我们再让它协变为Object[]:

Object[] objArray = table;

  而一般来说,数组会记住他的元素类型Pair,我们如果试图存储其他类型的元素,就会抛出异常(数组存储检查),例如:

objArray[0] = "Hello"; //ERROR--component type is Pair

  但是,对于泛型类型Pair<String>,类型擦除会使这种不同类检查机制无效,这就是不能实例化泛型数组的原因

objArray[0] = new Pair<Employee>();  //如果泛型机制允许我们实例化数组,那么这一步就没理由出错了!而这违背了我们的初衷(限定类型)
  • 数组存储只会检查擦除后的类型,又因为Java语言设计数组可以协变,所以可以通过编译
  • 能够通过数组存储检查,不过仍会导致一个类型错误,故不允许创建参数化类型的数组
  • 注意,声明类型为Pair<String>[]的变量是合法的,只是不能创建这些实例(我们应该直接用new Pair<String>[10]{......}来初始化这个变量)

泛型数组的间接实现

通过泛型数组包装器,如ArrayList类,维护一个Object数组,然后通过进出口方法set、get来限定类型和强制转换数组类型,从而间接实现泛型数组,

例如:ArrayList: ArrayList<Pair<T>>、ArrayList<T>

不能实例化类型变量T


  • 即不能使用new T(..) , new T[..] 或 T.class 这样的表达式中的类型变量

    • 例如: public Pair() { first = new T(); } //ERROR! 类型擦除将T改变成Object,调用非本意的new Object()
  • 不能使用new T(..) 
    • 但是,可通过反射调用Class.newInstance方法来构造泛型对象(要注意表达式T.class是非法的)
    • public static <T> Pair<T> makePair(Class<T> cl){
          try{ return new Pair<>(cl.newInstance() , cl.newInstance()); }
          catch(Exception ex) { return null; }
      }
      
      //这个方法可以按照下列方式调用:
      Pair<String> p = Pair.makePair(String.class);  

    • 注意:Class类本身是泛型。String.class是一个Class<String>的实例,因此makePair方法能够推断出pair的类型
  • 不能使用new T[..]
    • 即不能(直接)创建泛型数组,参考我另一篇博文(http://www.cnblogs.com/ixenos/p/5648519.html),这里不再赘述
    • 解决方案:使用泛型数组包装器,例如ArrayList
      • 然而,当在设计一个泛型数组包装器时,例如方法minmax返回一个T[]数组,则泛型数组包装器无法施展,因为类型擦除,return (T [])new Object是没有意义的强转不了。此时只好利用反射,调用Array.newInstance:
      • import java.lang.reflect.*;
        ...
        public static <T extends Comparable> T[] minmax(T... a){
            T[] mm = (T[]) Array.newInstance(a.getClass().getComponentType() , 2);
        ...
        }

        • 【API文档描述】public Class<?> getComponentType() 返回表示数组组件类型的 Class。如果此类不表示数组类,则此方法返回 null。
    • 而ArrayList类中的toArray方法的实现就麻烦了

      • public Object[] toArray() 无参,返回Object[]数组即可 

        public Object[] toArray() {
                return Arrays.copyOf(elementData, size);
            }
        • 【API文档描述】public static <T> T[] copyOf(T[] original,int newLength)
            复制指定的数组,截取或用 null 填充(如有必要),以使副本具有指定的长度。对于在原数组和副本中都有效的所有索引,这两个数组将包含相同的值。对于在副本中有效而在原数组无效的所有索引,副本将包含 null。当且仅当指定长度大于原数组的长度时,这些索引存在。所得数组和原数组属于完全相同的类。 
      • public <T> T[] toArray(T[] a) a - 要存储列表元素的T[]数组(如果它足够大)否则分配一个具有相同运行时类型的新数组,返回该T[]数组
      • @SuppressWarnings("unchecked")
            public <T> T[] toArray(T[] a) {
                if (a.length < size)
                    // Make a new array of a‘s runtime type, but my contents:
                    return (T[]) Arrays.copyOf(elementData, size, a.getClass()); //a.getClass()得运行时目的数组的运行时类型
                System.arraycopy(elementData, 0, a, 0, size);
                if (a.length > size)
                    a[size] = null;
                return a;
            }

        •  【API文档描述】

          public static <T,U> T[] copyOf(U[] original,int newLength, Class<? extends T[]> newType)
          复制指定的数组,截取或用 null 填充(如有必要),以使副本具有指定的长度。对于在原数组和副本中都有效的所有索引,这两个数组将包含相同的值。对于在副本中有效而在原数组无效的所有索引,副本将包含 null。当且仅当指定长度大于原数组的长度时,这些索引存在。所得数组属于 newType 类。

 泛型类的静态上下文中类型变量无效


  • 泛型类不能在静态域或静态方法中引用类型变量
  • public class Singleton<T>{
        private static T singleInstance; //ERROR
        public static T getSingleInstance(){...} //ERROR
    }
    • 类型擦除后只剩下Singleton类,因为静态所以他只包含一个singleInstance域,如果能运行则以Singleton类为模板生成不同类型的域,因此产生了冲突

不能throws或catch泛型类的实例(有关异常)


  • 泛型类继承Throwable类不合法,如public class Problem<T> extends Exception {...} //ERROR 不能通过编译
  • catch子句不能使用类型变量
  • public static <T extends Throwable> void doWork(Class<T> t){
        try{
                do work
            }catch (T e){ // ERROR
                Logger.global.info(...)
            }
    }

  • 不过,在异常规范中使用类型变量是允许的:  
  • public static <T extends Throwable> void doWork(T t) throws T { //此时可以throws T
        try{
                do work
            }catch (Throwable realCause){ //捕获到具体实例
                t.initCause(realCause);
                throw t; //这时候抛具体实例,所以throw t 和 throws T 是可以的!
            }
    }

    • 此特性作用:可以利用泛型类、类型擦除、SuppressWarnings标注,来消除对已检查(checked)异常的检查,

      • unchecked和checked异常: Java语言规范将派生于Error类或RuntimeException的所有异常称为未检查(unchecked)异常,其他的是已检查(checked)异常
      • Java异常处理原则:必须为所有已检查(checked)异常提供一个处理器,即一对一个,多对多个

        @SuppressWarnings("unchecked")  //SuppressWarning标注很关键,使得编译器认为T是unchecked异常从而不强迫为每一个异常提供处理器
        public static <T extends Throwable> void throwAs(Throwable e) throws T{  //因为泛型类型擦除,可以传递任意checked异常,例如RuntimeException类异常
            throw (T) e;
        }

        • 假设该方法放在类Block中,如果调用 Block.<RuntimeException>throwAs(t); 编译器就会认为t是一个未检查的异常
        • public abstract class Block{
              public abstract void body() throws Exception;
              public Thread toThread(){
                  return new Thread(){
                                  public void run(){
                                      try{
                                           body();
                                      }catch(Throwable t){
                                           Block.<RuntimeException>throwAs(t);
                                      }
                                  }
                              };
              }
          
              @SuppressWarnings("unchecked")
              public static <T extends Throwable> void throwAs(Throwable e) throws T{
              throw (T) e ;
              }
          }

        • 再写个测试类
        • public class Test{
              public static void main(String[] args){
                  new Block(){
                      public void body() throws Exception{
                          //不存在ixenos文件将产生IOException,checked异常!
                          Scanner in = new Scanner(new File("ixenos"));
                          while(in.hasNext())
                              System.out.println(in.next());
                      }
                  }.toThread().start();
              }
          }    

          • 启动线程后,throwAs方法将捕获线程run方法所有checked异常,“处理”成unchecked Exception(其实只是骗了编译器)后抛出;
          • 有什么意义?正常情况下,因为run()方法声明为不抛出任何checked异常,所以必须捕获所有checked异常并“包装”到未检查的异常中;意义:而我们这样处理后,就不必去捕获所有并包装到unchecked异常中,我们只是抛出异常并“哄骗”了编译器而已

注意擦除后的冲突


  • Java泛型规范有个原则:“要想支持擦除的转换,就需要强行限制一个泛型类或类型变量T不能同时成为两个接口类型的子类而这两个接口是统一接口的不同参数化

    • 注意:非泛型类可以同时实现同一接口,毕竟没有泛型,很好处理
    • class Calender implements Comparable<Calender>{...}
      
      class GGCalender extends Calender implements Comparable<GGCalender>{...} //ERROR
      • 在这里GGCalender类会同时实现Comparable<Calender> 和 Comparable<GGCalender>,这是同一接口的不同参数化
时间: 2024-10-24 08:58:59

Java的泛型约束和限制的相关文章

Java中泛型 类型擦除

转自:Java中泛型是类型擦除的 Java 泛型(Generic)的引入加强了参数类型的安全性,减少了类型的转换,但有一点需要注意:Java 的泛型在编译器有效,在运行期被删除,也就是说所有泛型参数类型在编译后都会被清除掉,看下面一个列子,代码如下: public class Foo { public void listMethod(List<String> stringList){ } public void listMethod(List<Integer> intList) {

C++ Java C#泛型

泛型概述C#中的泛型C#泛型和java泛型的比较C#泛型和C++模板的比较C#泛型中的约束 泛型概述 Bruce Eckel :您能对泛型做一个快速的介绍么? Anders Hejlsberg : 泛型其实就是能够向你的类型中加入类型参数的一种能力,也称作参数化的类型或参数多态性.最著名的例子就是List集合类.一个List是一个易于增长的 数组.它有一个排序方法,你可以为 它做索引,等等.现在,如果没有参数化的类型,那么不论使用数组还是使用List都不是很好.如果你使用数组,你能获得强类型,因

【JAVA之泛型】

一.引例. 1.引例. 假设现在有一个ArrayList的容器,如果不使用泛型约束,则可以向容器中加入各种类型的对象,但是如果取出来的时候只是用一种类型的转换则肯定会抛出ClassCastException异常. 1 package p04.GenerateTypeDemo.Demo01; 2 3 import java.util.ArrayList; 4 import java.util.ListIterator; 5 6 public class Demo01 { 7 public stat

java使用泛型实现Bean类和Map的相互转换

java使用泛型实现Bean类和Map的相互转换,使用泛型可以这带来了很多好处: 首要就是类型安全, Java 程序的类型安全.通过知道使用泛型,这些假设就只存在于程序员的头脑中(或者如果幸运的话,还存在于代码注释中).       泛型允许编译器实施这些附加的类型约束.类型错误现在就可以在编译时被捕获了,而不是在运行时当作 ClassCastException 展示出来.   将类型检查从运行时挪到编译时有助于您更容易找到错误,并可提高程序的可靠性. 消除强制类型转换. 泛型的一个附带好处是,

C#泛型约束

本文将对各类泛型约束做一个简单的总结. 文章一开始,给出演示代码底稿(在此基础上修改,演示,说明.) class MyList<T> { List<T> list = new List<T>(); public T this[int i] { get { return list[i]; } set { this.list[i] = value; } } } class Person { public string Name { get; set; } } 接下来,依次修

Java中泛型的协变

在工作中遇到一个问题,用代码描述如下: package test; import java.util.LinkedList; import java.util.List; public class ListTest {     public void func(List<Base> list) {     }     public static void main(String args[]) {         ListTest lt = new ListTest();         Li

Java 容器 & 泛型:一、认识容器

Writer:BYSocket(泥沙砖瓦浆木匠) 微博:BYSocket 豆瓣:BYSocket 容器是Java语言学习中重要的一部分.泥瓦匠我的感觉是刚开始挺难学的,但等你熟悉它,接触多了,也就"顺理成章"地知道了.Java的容器类主要由两个接口派生而出:Collection和Map. 一.Collection vs Collections 首先,Collection 和 Collections 是两个不同的概念.之所以放在一起,是为了更好的比较.Collection是容器层次结构中

泛型约束

-----------------------------------IDocument.cs(定义一个接口) using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace ConsoleApplication3 {     public interface IDocument     {         s

Java 泛型 Java使用泛型的意义

Java 泛型 Java使用泛型的意义 @author ixenos 直接意义 在编译时保证类型安全 根本意义 a) 类型安全问题源自可复用性代码的设计,泛型保证了类型安全的复用模板 b) 使用复用性模板时不用手动强制类型转换 三种泛型实现方式的优缺点 C++:模板方式实现,在编译时完全展开并且支持偏特化,类型精度高,代码共享差: Java 5:擦除方式实现,仅用于编译时类型检查,在运行时擦除,向后兼容性好,代码共享好,类型精度非常差: C# 2.0:混合方式实现,在运行时展开特化,类型精度高,