`
hoover
  • 浏览: 2265 次
  • 性别: Icon_minigender_1
  • 来自: 北京
最近访客 更多访客>>
文章分类
社区版块
存档分类
最新评论

Java泛型

阅读更多
泛型

使用泛型所定义的类在声明及配置对象时,可以使用尖括号一并指定泛型类类型持有者T真正的类型.
而类型或接口转换试不不再需要了.
例子:
   public class GenericFoo<T>{
     private T foo;
     public void setFoo(T foo){
       this.foo = foo;
     }
     public T getFoo(){
       return foo;
     }
   }

   GenericFoo<Boolean> fool = new GenericFoo<Boolean>();
  
注:   自定义泛型类时,类型持有者名称可以使用T(Type),如果是容器的元素可以使用E(Element),
   若键值匹配可以使用K(key)与V(value),Annotation时可以用A,可以参考J2SE5.0 API
   文件说明上的命名方式.


  
可以在定义泛型类时,声明多个类型持有者.
例:
   public class GenericFoo2<T1,T2>{
     private T1 foo1;
     private T2 foo2;
     public void setFoo1(T1 foo1){
       this.foo1 = foo1;
     }
     public T1 getFoo1(){
       return foo1;
     }
     public void setFoo2(T2 foo2){
       this.foo2 = foo2;
     }
     public T2 getFoo2(){
       return foo2;
     }
   }
  
   GenericFoo<Boolean,Integer> foo = new GenericFoo<Boolean,Integer>();
  


泛型可以用于声明数组类型.
例子:
   public class GenericFoo3<T>{
     private T[] fooArray;
     public void setFooArray(T[] fooArray){
       this.fooArray = fooArray;
     }
     public T[] getFooArray(){
       return fooArray;
     }
   }
  
   String [] strs = {"aaa","bbb","ccc"};
   GenericFoo3<String> foo = new GenericFoo3<String>();
   foo.setFooArray(strs);
   strs = foo.getFooArray();
  
注意: 可以用泛型机制来声明一个数组.
   public class GenericFoo<T>{
     private T[] fooArray;
     ....
   }
   但是不可以用泛型来建立数组的实例.
   public class GenericFoo<T>{
     private T[] fooArray = new T[10]; //错误的.
     ....
   }
  
  
如果已经定义了一个泛型类,若要用这个类在另一个泛型类中声明成员该如何做?
例:
   public class WrapperFoo<T>{
     private GenericFoo<T> foo;
     public void setFoo(GenericFoo<T> foo){
       this.foo = foo;
     }
     public GenericFoo<T> getFoo(){
       return foo;
     }
   }
   这样,就可以保留类型持有者T的功能.
  
   WrapperFoo<String> w = new WrapperFoo<String>();
  
  
  
泛型高级语法
泛型的语法元素其实是很基本的,只不过将这种语法来回扩展之后,可以编写出相当复杂
的泛型定义,然而无论再怎么复杂的写法,基本语法元素大致不变:
限制泛型可用类型,使用类型通配符,以及泛型的扩充与继承这几个语法.



限制泛型可用类型
可以在定义类型持有者时,同时使用extends指定这个类型持有者实例化,实例化的对象必须
是扩充自某个类型或实现某个接口.
例:
   public class ListGenericFoo<T extends List>{
     private T[] fooArray;
     public void setFooArray(T[] fooArray){
       this.fooArray = fooArray;
     }
     public T[] getFooArray(){
       return fooArray;
     }
   }
   ListGenericFoo在声明类型持有者时,一并指定这个持有者实例化的对象,必须是实现
   java.util.List接口的类,在限定持有者时,无论要限定的对象是接口或类,都是使用
   extends关键字.范例中使用extends限定类型持有者实例化的对象,必须是实现了
   List接口的类,如:LinkedList.
  
   ListGenericFoo<LinkedList> foo1 = new ListGenericFoo<LinkedList>();
  
大家在看看更复杂一点的:
   public class ListGenericFoo<T extends List<String>>{
     .................
   }
   这么定义后,我们可以使用ArrayList<String>来实例化ListGenericFoo.
   ListGenericFoo<ArrayList<String>> foo = new ListGenericFoo<ArrayList<String>>();
  


类型通配符节
   可以使用?(通配符).?代表未知类型,还可以使用extends关键字来作限定.
   <? extends List>表示类型未知,只知道是实现List接口的类.
  
   GenericFoo<? extends List> foo = null;
   foo = new GenericFoo<ArrayList>();
   foo = new GenericFoo<LinkedLst>();
  
在声明名称时如果指定了<?>而不使用extends,则默认是允许Object及其下的子类,
也就是所有的java对象.那为什么不直接使用<xxx>声明?何必要用<?>来声明?
使用通配符有一点要注意:
通过使用通配符声明的名称所参考的对象,你没有办法对它加入新的信息,您只能取得
它当中的信息或是移除当中的信息.
例:
   GenericFoo<String> foo = new GenericFoo<String>();
   foo.setFoo("caterpillar");
  
   GenericFoo<?> immutableFoo = foo;
   //可以取得信息
   System.out.println(immutableFoo.getFoo());
   //可通过immutableFoo来移去foo所参考实例内的信息
   immutableFoo.setFoo(null);
   //不可通过immutableFoo来设置新的信息给foo所参考的实例
   immutableFoo.setFoo("sssss"); //不能通过
  
所以使用<?>或是<? extends SomeClass>的声明方式,意味着只能通过该名称来取得
所参考实例的信息,或者是删除某些信息,但不能增加它的信息.理由很简单,因为您不
知道<?>或是<? extends SomeClass>声明的参考名.实际上参考的对象,当中确实存储
着什么类型的信息.基于泛型的设计理念,当然也就没有理由加入新的信息了,因为若能
加入的对象同样也会有失去类型信息的问题.


除了可以向下限制,也可以向上限制,只要使用super关键字,例如:
 
   GenericFoo<? super StringBuilder> foo = null;
   这样,foo就只接受StringBuilder及其上层的父类类型,也就是只能接受
   GenericFoo<StringBuilder>与GenericFoo<Object>的实例.
  
  
  
扩充泛型类和实现泛型接口
可以扩充一个泛型类,保留其类型持有者,并新增自己的类型持有者,例如:
   public class GenericFoo4<T1,T2>{
     private T1 foo1;
     private T2 foo2;
     public void setFoo1(T1 foo1){
       this.fool = foo;
     }
     public T1 getFool(){
       return fool;
     }
     public void setFoo2(T2 foo2){
       this.foo2 = foo2;
     }
     public T2 getFoo2(){
       return foo2;
     }
   }
  
   public class SubGenericFoo4<T1,T2,T3> extends GenericFoo4<T1,T2>{
     private T3 foo3;
     public void setFoo3(T3 foo3){
       this.foo3 = foo3;
     }
     public T3 getFoo3(){
       return foo3;
     }
   }
如果决定要保留类型持有者,则父类上声明的类型持有者数目在继承下来时必须写齐全,
也就是说,在上例中,父类上GenericFoo4上出现的T1与T2在SubGenericFoo4中都要出现.
如果不保留类型持有者,则继承下来的T1与T2自动变为Object,建议是父类的类型持有者都保留.
接口实现也是一样的.
分享到:
评论

相关推荐

    Java泛型的用法及T.class的获取过程解析

    Java泛型的用法及T.class的获取过程解析 Java泛型是Java编程语言中的一种重要特性,它允许开发者在编写代码时指定类型参数,从而提高代码的灵活性和可读性。本文将详细介绍Java泛型的用法 及T.class的获取过程解析...

    Java泛型三篇文章,让你彻底理解泛型(super ,extend等区别)

    Java 泛型详解 Java 泛型是 Java SE 5.0 中引入的一项特征,它允许程序员在编译时检查类型安全,从而减少了 runtime 错误的可能性。泛型的主要优点是可以Reusable Code,让程序员编写更加灵活和可维护的代码。 ...

    Java泛型应用实例

    Java泛型是Java编程语言中的一个强大特性,它允许我们在定义类、接口和方法时指定类型参数,从而实现代码的重用和类型安全。在Java泛型应用实例中,我们可以看到泛型如何帮助我们提高代码的灵活性和效率,减少运行时...

    很好的Java泛型的总结

    Java泛型机制详解 Java泛型是Java语言中的一种机制,用于在编译期检查类型安全。Java泛型的出现解决了Java早期版本中类型安全检查的缺陷。Java泛型的好处是可以在编译期检查类型安全,避免了运行时的...

    java 泛型类的类型识别示例

    综上所述,虽然Java泛型在编译后会进行类型擦除,但通过上述技巧,我们仍然能够在运行时获得关于泛型类实例化类型的一些信息。在实际开发中,这些方法可以帮助我们编写更加灵活和安全的代码。在示例文件`GenericRTTI...

    java泛型技术之发展

    Java泛型是Java编程语言中的一个关键特性,它在2004年随着Java SE 5.0的发布而引入,极大地增强了代码的类型安全性和重用性。本篇文章将深入探讨Java泛型的发展历程、核心概念以及其在实际开发中的应用。 1. **发展...

    SUN公司Java泛型编程文档

    Java泛型是Java编程语言中的一个关键特性,它在2004年随着JDK 5.0的发布被引入。这个特性极大地提高了代码的类型安全性和可读性,减少了在运行时出现ClassCastException的可能性。SUN公司的Java泛型编程文档,包括...

    java 泛型接口示例

    下面我们将详细探讨Java泛型接口的相关知识点。 1. **泛型接口的定义** 泛型接口的定义方式与普通接口类似,只是在接口名之后添加了尖括号`&lt;T&gt;`,其中`T`是一个类型参数,代表某种未知的数据类型。例如: ```java...

    java 泛型方法使用示例

    下面我们将深入探讨Java泛型方法的概念、语法以及使用示例。 **一、泛型方法概念** 泛型方法是一种具有类型参数的方法,这些类型参数可以在方法声明时指定,并在方法体内部使用。与类的泛型类似,它们提供了编译时...

    java泛型的内部原理及更深应用

    Java泛型是Java编程语言中的一个强大特性,它允许在定义类、接口和方法时使用类型参数,从而实现参数化类型。这使得代码更加安全、可读性更强,并且能够减少类型转换的必要。在“java泛型的内部原理及更深应用”这个...

    Java 泛型擦除后的三种补救方法

    Java 泛型是一种强大的工具,它允许我们在编程时指定变量的类型,提供了编译时的类型安全。然而,Java 的泛型在运行时是被擦除的,这意味着在运行时刻,所有的泛型类型信息都会丢失,无法直接用来创建对象或进行类型...

    JAVA泛型加减乘除

    这是一个使用JAVA实现的泛型编程,分为两部分,第一部分创建泛型类,并实例化泛型对象,得出相加结果。 第二部分用户自行输入0--4,选择要进行的加减乘除运算或退出,再输入要进行运算的两个数,并返回运算结果及...

    java泛型学习ppt

    "Java 泛型学习" Java 泛型是 Java 语言的类型系统的一种扩展,以支持创建可以按类型进行参数化的类。泛型的主要目标是提高 Java 程序的类型安全。通过知道使用泛型定义的变量的类型限制,编译器可以在一个高得多的...

    Java泛型使用详细分析.pdf

    Java 泛型使用详细分析 Java 泛型是 Java 语言中的一种类型系统特性,允许开发者在编译期检查类型安全,以避免在运行时出现类型相关的错误。在本文中,我们将详细介绍 Java 泛型的使用方法和实现原理。 一、泛型的...

    Java泛型技术之发展.pdf

    Java泛型是Java编程语言中的一个关键特性,它在2004年随着Java SE 5.0的发布而引入,极大地增强了代码的类型安全性和重用性。本篇文章将深入探讨Java泛型的发展历程、核心概念以及其在实际开发中的应用。 1. **发展...

    面试必须资料java泛型攻略、

    #### 一、什么是Java泛型? Java泛型(Generics)是一种在编译时确保类型安全的机制,它允许程序员编写类型安全的通用类或方法,而无需进行显式的类型转换。在Java 1.5引入泛型之前,集合类(如`ArrayList`)只能...

Global site tag (gtag.js) - Google Analytics