java泛型(一)、泛型的基本介绍和使用

简介: 现在开始深入学习java的泛型了,以前一直只是在集合中简单的使用泛型,根本就不明白泛型的原理和作用。泛型在java中,是一个十分重要的特性,所以要好好的研究下。 泛 型的定义:泛型是JDK 1.5的一项新特性,它的本质是参数化类型(Parameterized Type)的应用,也就是说所操作的数据类型被指定为一个参数,在用到的时候在指定具体的类型。

现在开始深入学习java的泛型了,以前一直只是在集合中简单的使用泛型,根本就不明白泛型的原理和作用。泛型在java中,是一个十分重要的特性,所以要好好的研究下。

泛 型的定义:泛型是JDK 1.5的一项新特性,它的本质是参数化类型(Parameterized Type)的应用,也就是说所操作的数据类型被指定为一个参数,在用到的时候在指定具体的类型。这种参数类型可以用在类、接口和方法的创建中,分别称为泛 型类、泛型接口和泛型方法。

  泛型思想早在C++语言的模板(Templates)中就开始生根发芽,在Java语言处于还没有出现泛型的版本时,只能通过Object是所有类型的父 类和类型强制转换两个特点的配合来实现类型泛化。例如在哈希表的存取中,JDK 1.5之前使用HashMap的get()方法,返回值就是一个Object对象,由于Java语言里面所有的类型都继承于 java.lang.Object,那Object转型为任何对象成都是有可能的。但是也因为有无限的可能性,就只有程序员和运行期的虚拟机才知道这个 Object到底是个什么类型的对象。在编译期间,编译器无法检查这个Object的强制转型是否成功,如果仅仅依赖程序员去保障这项操作的正确性,许多 ClassCastException的风险就会被转嫁到程序运行期之中。

  泛型技术在C#和Java之中的使用方式看似相同,但实现上却有着根本性的分歧,C#里面泛型无论在程序源码中、编译后的IL中 (Intermediate Language,中间语言,这时候泛型是一个占位符)或是运行期的CLR中都是切实存在的,List<int>与 List<String>就是两个不同的类型,它们在系统运行期生成,有自己的虚方法表和类型数据,这种实现称为类型膨胀,基于这种方法实现 的泛型被称为真实泛型。

  Java语言中的泛型则不一样,它只在程序源码中存在,在编译后的字节码文件中,就已经被替换为原来的原始类型(Raw Type,也称为裸类型)了,并且在相应的地方插入了强制转型代码,因此对于运行期的Java语言来说,ArrayList<int>与 ArrayList<String>就是同一个类。所以说泛型技术实际上是Java语言的一颗语法糖,Java语言中的泛型实现方法称为类型 擦除,基于这种方法实现的泛型被称为伪泛型。(类型擦除在后面在学习)

  使用泛型机制编写的程序代码要比那些杂乱的使用Object变量,然后再进行强制类型转换的代码具有更好的安全性和可读性。泛型对于集合类来说尤其有用。

  泛型程序设计(Generic Programming)意味着编写的代码可以被很多不同类型的对象所重用。


实例分析:

  在JDK1.5之前,Java泛型程序设计是用继承来实现的。因为Object类是所用类的基类,所以只需要维持一个Object类型的引用即可。就比如ArrayList只维护一个Object引用的数组:

[java] view plain copy
  1. public class ArrayList//JDK1.5之前的  
  2. {  
  3.     public Object get(int i){......}  
  4.     public void add(Object o){......}  
  5.     ......  
  6.     private Object[] elementData;  
  7. }  

这样会有两个问题:

1、没有错误检查,可以向数组列表中添加类的对象

2、在取元素的时候,需要进行强制类型转换

这样,很容易发生错误,比如:

[java] view plain copy
  1. /**jdk1.5之前的写法,容易出问题*/  
  2. ArrayList arrayList1=new ArrayList();  
  3. arrayList1.add(1);  
  4. arrayList1.add(1L);  
  5. arrayList1.add("asa");  
  6. int i=(Integer) arrayList1.get(1);//因为不知道取出来的值的类型,类型转换的时候容易出错  

这里的第一个元素是一个长整型,而你以为是整形,所以在强转的时候发生了错误。

所以。在JDK1.5之后,加入了泛型来解决类似的问题。例如在ArrayList中使用泛型:

[java] view plain copy
  1.                 /** jdk1.5之后加入泛型*/  
  2.         ArrayList<String> arrayList2=new ArrayList<String>();  //限定数组列表中的类型  
  3. //      arrayList2.add(1); //因为限定了类型,所以不能添加整形  
  4. //      arrayList2.add(1L);//因为限定了类型,所以不能添加整长形  
  5.         arrayList2.add("asa");//只能添加字符串  
  6.         String str=arrayList2.get(0);//因为知道取出来的值的类型,所以不需要进行强制类型转换  

 

还要明白的是,泛型特性是向前兼容的。尽管 JDK 5.0 的标准类库中的许多类,比如集合框架,都已经泛型化了,但是使用集合类(比如 HashMap 和 ArrayList)的现有代码可以继续不加修改地在 JDK 1.5 中工作。当然,没有利用泛型的现有代码将不会赢得泛型的类型安全的好处。


在学习泛型之前,简单介绍下泛型的一些基本术语,以ArrayList<E>ArrayList<Integer>做简要介绍:

整个成为ArrayList<E>泛型类型

ArrayList<E>中的 E称为类型变量或者类型参数

整个ArrayList<Integer> 称为参数化的类型

ArrayList<Integer>中的integer称为类型参数的实例或者实际类型参数

·ArrayList<Integer>中的<Integer>念为typeof   Integer

ArrayList称为原始类型


二、泛型的使用

泛型的参数类型可以用在类、接口和方法的创建中,分别称为泛型类、泛型接口和泛型方法。下面看看具体是如何定义的。

1、泛型类的定义和使用

一个泛型类(generic class)就是具有一个或多个类型变量的类。定义一个泛型类十分简单,只需要在类名后面加上<>,再在里面加上类型参数:

[java] view plain copy
  1. class Pair<T> {  
  2.     private T value;  
  3.         public Pair(T value) {  
  4.                 this.value=value;  
  5.         }  
  6.         public T getValue() {  
  7.         return value;  
  8.     }  
  9.     public void setValue(T value) {  
  10.         this.value = value;  
  11.     }  
  12. }  
现在我们就可以使用这个泛型类了:
[java] view plain copy
  1. public static void main(String[] args) throws ClassNotFoundException {  
  2.         Pair<String> pair=new Pair<String>("Hello");  
  3.         String str=pair.getValue();  
  4.         System.out.println(str);  
  5.         pair.setValue("World");  
  6.         str=pair.getValue();  
  7.         System.out.println(str);  
  8.     }  

     

     

  9. 参数:
    [java] view plain copy
    1. class Pair<T> {  
    2.     private T value;  
    3.         public Pair(T value) {  
    4.                 this.value=value;  
    5.         }  
    6.         public T getValue() {  
    7.         return value;  
    8.     }  
    9.     public void setValue(T value) {  
    10.         this.value = value;  
    11.     }  
    12. }  
    现在我们就可以使用这个泛型类了:
    [java] view plain copy
    1. public static void main(String[] args) throws ClassNotFoundException {  
    2.         Pair<String> pair=new Pair<String>("Hello");  
    3.         String str=pair.getValue();  
    4.         System.out.println(str);  
    5.         pair.setValue("World");  
    6.         str=pair.getValue();  
    7.         System.out.println(str);  
    8.     }  

Pair类引入了一个类型变量T,用尖括号<>括起来,并放在类名的后面。泛型类可以有多个类型变量。例如,可以定义Pair类,其中第一个域和第二个域使用不同的类型:

public class Pair<T,U>{......}

注意:类型变量使用大写形式,且比较短,这是很常见的。在Java库中,使用变量E表示集合的元素类型,K和V分别表示关键字与值的类型。(需要时还可以用临近的字母U和S)表示“任意类型”。


2、泛型接口的定义和使用

定义泛型接口和泛型类差不多,看下面简单的例子:

[java] view plain copy
  1. interface Show<T,U>{  
  2.     void show(T t,U u);  
  3. }  
  4.   
  5. class ShowTest implements Show<String,Date>{  
  6.     @Override  
  7.     public void show(String str,Date date) {  
  8.         System.out.println(str);  
  9.         System.out.println(date);  
  10.     }  
  11. }  

测试一下:

[java] view plain copy
  1. public static void main(String[] args) throws ClassNotFoundException {  
  2.         ShowTest showTest=new ShowTest();  
  3.         showTest.show("Hello",new Date());  
  4.     }  


3、泛型方法的定义和使用

泛型类在多个方法签名间实施类型约束。在 List<V> 中,类型参数 V 出现在 get()、add()、contains() 等方法的签名中。当创建一个 Map<K, V> 类型的变量时,您就在方法之间宣称一个类型约束。您传递给 add() 的值将与 get() 返回的值的类型相同。

类似地,之所以声明泛型方法,一般是因为您想要在该方法的多个参数之间宣称一个类型约束。

举个简单的例子:

[java] view plain copy
  1. public static void main(String[] args) throws ClassNotFoundException {  
  2.         String str=get("Hello", "World");  
  3.         System.out.println(str);  
  4.     }  
  5.   
  6.     public static <T, U> T get(T t, U u) {  
  7.         if (u != null)  
  8.             return t;  
  9.         else  
  10.             return null;  
  11.     }  



三、泛型变量的类型限定

在上面,我们简单的学习了泛型类、泛型接口和泛型方法。我们都是直接使用<T>这样的形式来完成泛型类型的声明。

有的时候,类、接口或方法需要对类型变量加以约束。看下面的例子:

有这样一个简单的泛型方法:

[java] view plain copy
  1. public static <T> T get(T t1,T t2) {  
  2.         if(t1.compareTo(t2)>=0);//编译错误  
  3.         return t1;  
  4.     }  

因为,在编译之前,也就是我们还在定义这个泛型方法的时候,我们并不知道这个泛型类型T,到底是什么类型,所以,只能默认T为原始类型Object。所以它只能调用来自于Object的那几个方法,而不能调用compareTo方法。

可我的本意就是要比较t1和t2,怎么办呢?这个时候,就要使用类型限定,对类型变量T设置限定(bound)来做到这一点。

我们知道,所有实现Comparable接口的方法,都会有compareTo方法。所以,可以对<T>做如下限定:

[java] view plain copy
  1. public static <T extends Comparable> T get(T t1,T t2) { //添加类型限定  
  2.         if(t1.compareTo(t2)>=0);  
  3.         return t1;  
  4.     }  


类型限定在泛型类、泛型接口和泛型方法中都可以使用,不过要注意下面几点:

1、不管该限定是类还是接口,统一都使用关键字 extends

2、可以使用&符号给出多个限定,比如

[java] view plain copy
  1. public static <T extends Comparable&Serializable> T get(T t1,T t2)  

3、如果限定既有接口也有类,那么类必须只有一个,并且放在首位置

[java] view plain copy
    1. public static <T extends Object&Comparable&Serializable> T get(T t1,T t2) 
相关文章
|
3月前
|
安全 Java 编译器
揭秘JAVA深渊:那些让你头大的最晦涩知识点,从泛型迷思到并发陷阱,你敢挑战吗?
【8月更文挑战第22天】Java中的难点常隐藏在其高级特性中,如泛型与类型擦除、并发编程中的内存可见性及指令重排,以及反射与动态代理等。这些特性虽强大却也晦涩,要求开发者深入理解JVM运作机制及计算机底层细节。例如,泛型在编译时检查类型以增强安全性,但在运行时因类型擦除而丢失类型信息,可能导致类型安全问题。并发编程中,内存可见性和指令重排对同步机制提出更高要求,不当处理会导致数据不一致。反射与动态代理虽提供运行时行为定制能力,但也增加了复杂度和性能开销。掌握这些知识需深厚的技术底蕴和实践经验。
78 2
|
23天前
|
Java API
[Java]泛型
本文详细介绍了Java泛型的相关概念和使用方法,包括类型判断、继承泛型类或实现泛型接口、泛型通配符、泛型方法、泛型上下边界、静态方法中使用泛型等内容。作者通过多个示例和测试代码,深入浅出地解释了泛型的原理和应用场景,帮助读者更好地理解和掌握Java泛型的使用技巧。文章还探讨了一些常见的疑惑和误区,如泛型擦除和基本数据类型数组的使用限制。最后,作者强调了泛型在实际开发中的重要性和应用价值。
19 0
[Java]泛型
|
1月前
|
存储 安全 Java
🌱Java零基础 - 泛型详解
【10月更文挑战第7天】本文收录于「滚雪球学Java」专栏,专业攻坚指数级提升,希望能够助你一臂之力,帮你早日登顶实现财富自由🚀;同时,欢迎大家关注&&收藏&&订阅!持续更新中,up!up!up!!
11 1
|
1月前
|
Java 语音技术 容器
java数据结构泛型
java数据结构泛型
27 5
|
1月前
|
存储 Java 编译器
Java集合定义其泛型
Java集合定义其泛型
18 1
|
2月前
|
Java 编译器 容器
Java——包装类和泛型
包装类是Java中一种特殊类,用于将基本数据类型(如 `int`、`double`、`char` 等)封装成对象。这样做可以利用对象的特性和方法。Java 提供了八种基本数据类型的包装类:`Integer` (`int`)、`Double` (`double`)、`Byte` (`byte`)、`Short` (`short`)、`Long` (`long`)、`Float` (`float`)、`Character` (`char`) 和 `Boolean` (`boolean`)。包装类可以通过 `valueOf()` 方法或自动装箱/拆箱机制创建。
37 9
Java——包装类和泛型
|
1月前
|
存储 Java 编译器
【用Java学习数据结构系列】初识泛型
【用Java学习数据结构系列】初识泛型
20 2
|
2月前
|
安全 Java API
【Java面试题汇总】Java基础篇——String+集合+泛型+IO+异常+反射(2023版)
String常量池、String、StringBuffer、Stringbuilder有什么区别、List与Set的区别、ArrayList和LinkedList的区别、HashMap底层原理、ConcurrentHashMap、HashMap和Hashtable的区别、泛型擦除、ABA问题、IO多路复用、BIO、NIO、O、异常处理机制、反射
【Java面试题汇总】Java基础篇——String+集合+泛型+IO+异常+反射(2023版)
|
1月前
|
安全 Java 编译器
Java基础-泛型机制
Java基础-泛型机制
16 0
|
2月前
|
存储 安全 搜索推荐
Java中的泛型
【9月更文挑战第15天】在 Java 中,泛型是一种编译时类型检查机制,通过使用类型参数提升代码的安全性和重用性。其主要作用包括类型安全,避免运行时类型转换错误,以及代码重用,允许编写通用逻辑。泛型通过尖括号 `&lt;&gt;` 定义类型参数,并支持上界和下界限定,以及无界和有界通配符。使用泛型需注意类型擦除、无法创建泛型数组及基本数据类型的限制。泛型显著提高了代码的安全性和灵活性。