Java 里的泛型简介.

喜欢ヅ旅行 2022-08-27 13:40 143阅读 0赞

我们在JDK中有时回见到1个类or接口后面跟这1个尖括号.

例如:

java.util.HashMap<K,V>

我们一开始大概知道K,V 大概就是Key和Value的意思, 键值对嘛, 但是不知道这个特性对编程的影响.

其实这个设计Java的泛型问题. 把本文看完就明白了.

## 一. Java里泛型的定义    ##

在数据结构中, 泛型(generic)这个词代表一种编程思想.

它的意思就是:  不论存储结构如何差异, 都可以令其具有看起来一样的操作方法.

例如 ArrayList 和 LinkList 这两个容器, 它们在内存内的存储结构是完全不同的.

但是它们的操作方法基本上是一样的.

都具有相同的,add() 方法, remove()方法, size()方法等等.

这就是泛型的编程思想.

但是在Java里不能直接操作内存, Java里泛型是另一种定义:

**java里泛型用于限制传入容器和接口的数据类型.**

## 二. 容器里的泛型. ##

我们打开Java JDK API, 查看ArrayList这个类

会见到下面的字眼

java.util  
类 **ArrayList<E>**

ArrayList后面有个尖括号, 里面一个大写E.

其实E代表的是Element的意思,  它告诉我们, ArrayList可以用泛型来限制放入容器里的对象类型.

### 2.1 假如不使用泛型    ###

假如我们不适用泛型

代码是这样写的:

import java.util.ArrayList;
    
    class Student{
        int id;
        private String name;
        public Student(int id, String name){
            this.id = id;
            this.name = name;
        }
    
        public String toString(){
            return this.id + ": " + this.name;
        }
    }
    
    public class ArrayList1{
        public static void main(String args[]){
            ArrayList arr = new ArrayList();
            arr.add(new Student(1,"Jack"));
            arr.add(new Student(2,"Bill"));
            arr.add(1);
            arr.add("Jack");
    
            Student st = arr.get(1);
            System.out.println(st);
            
        }
    
    }

上面的代码中, arr这个容器添加了两个Student对象, 1个integer对象(自动装箱),1个String对象.

但是编译失败

原因在于这行代码:

Student st = arr.get(1);

在JDK API中, get()方法是这样定义的:

### get ###

public E get(int index)

返回此列表中指定位置上的元素。

其实上面的定义告诉我们, 可以使用泛型来决定get()方法的返回值类型, 但是如果不使用泛型, 返回的类型是object.

上面用1个Student的引用st 来接收1个Object类型对象, 所以会编译失败.

所以我们需要强制转换, 将出错的代码改为:

Student st = (Student)arr.get(1);

这样就编译通过了.

但是编译信息有两句warning:

Note: ArrayList1.java uses unchecked or unsafe operations.
    Note: Recompile with -Xlint:unchecked for details.

它告诉我们这样是不安全的, 因为没有使用泛型, arr容器内还可能有其它的类型的对象.

一旦我把上面的get方法里的参数从1改成2, 则会发生转会失败, 抛出异常..

### 2.2 使用泛型: ###

我们可以在定义1个容器时使用泛型, 方法很简单, 就是在容器类名后面加上尖括号,后面写上你要放入的对象类名.

例如:

Arraylist<Student> arr = new ArrayList<Student>();

修改后的代码如下:

import java.util.ArrayList;
    
    class Student{
        int id;
        private String name;
        public Student(int id, String name){
            this.id = id;
            this.name = name;
        }
    
        public String toString(){
            return this.id + ": " + this.name;
        }
    }
    
    public class ArrayList2{
        public static void main(String args[]){
            ArrayList<Student> arr = new ArrayList<Student>();
            arr.add(new Student(1,"Jack"));
            arr.add(new Student(2,"Bill"));
            //arr.add(1);
            //arr.add("Jack");
    
            Student st = arr.get(1);
            //Student st = (Student)arr.get(1);
            System.out.println(st);
            
        }
    
    }

上面的 get()方法已经不需要强制转换了.

值得注意的是, 当使用了泛型以后, 上面的arr容器就不能再放入除Student对象之外的其他类型元素. 否则会报错!

## 三. 接口里的泛型. ##

我地再一次打开JDKAPI,  看看Comparable接口的定义:

## ava.lang    接口 Comparable<T> ##

**类型参数：**

`T`  - 可以与此对象进行比较的那些对象的类型

然后再看看Comparable里面最重要的方法:

<table style=""> 
 <tbody> 
  <tr style="background-color:rgb(255,255,255); color:rgb(0,0,0)"> 
   <td align="right"><span style=""><code>int</code></span></td> 
   <td><code><strong><a rel="nofollow">compareTo</a></strong>(<a title="Comparable 中的类型参数" rel="nofollow">T</a>&nbsp;o)</code>&nbsp;<br> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;比较此对象与指定对象的顺序。</td> 
  </tr> 
 </tbody> 
</table>

里面都有1个T, 意思也是可以利用泛型来指定传入Comparable接口里方法的参数类型:

### 3.1 假如不使用泛型: ###

如果不使用泛型, 那么使用实现了Comparable接口的对象里的comparaTo方法里就能接受各种类型的对象, 必须使用强制转会:

例子:

import java.lang.Comparable;
    
    class Student implements Comparable{
        int id;
        private String name;
        public Student(int id, String name){
            this.id = id;
            this.name = name;
        }
    
        public String toString(){
            return this.id + ": " + this.name;
        }
    
        public int compareTo(Object o){
            Student st = (Student)o;
            return this.id - st.id;
        } 
    }
    
    public class Comparable1{
        public static void main(String args[]){
            Student jack = new Student(1,"Jack");
            Student bill= new Student(2,"Bill");
    
            System.out.println(bill.compareTo(jack));
        }
    }

例如上面的例子

类Student 实现了Comparable接口,  重写comparaTo时的参数必须是对象Object

内容里还必须强制转会:

Student st = (Student)o;

这样写虽然看起来ok, 但是实际上也不安全

因为这样写, Student对象调用compareTo方法时就能放入各种类型的参数.

**编译时是无错的,但是执行时就有可能转换失败了.**

### 3.2 假如使用泛型. ###

接口使用泛型的方法也很简单:

只需要在接口名后面加上<参数类名>就ok

修改后的例子:

import java.lang.Comparable;
    
    class Student implements Comparable<Student>{
        int id;
        private String name;
        public Student(int id, String name){
            this.id = id;
            this.name = name;
        }
    
        public String toString(){
            return this.id + ": " + this.name;
        }
    
        public int compareTo(Student s){
            return this.id - s.id;
        } 
    }
    
    public class Comparable2{
        public static void main(String args[]){
            Student jack = new Student(1,"Jack");
            Student bill= new Student(2,"Bill");
    
            System.out.println(bill.compareTo(jack));
            //System.out.println(bill.compareTo("jack")); compile error
        }
    }

上面修改后, 重写的compareTo方法参数就应该指定为Student类.

而且不能将其他类型对象作为参数调用, 否则编译出错.

## 四. 使用泛型的意义 ##

通过上面的例子, 我们可以得出使用java泛型 有如下好处:

1.避免强制转换的代码

2.限制传入容器的对象类型 和 接口方法参数的类型

**3.避免了编译通过, 但是因为强制转换失败而执行出错的情况. 令java程序更加安全健壮.**