首页 > 编程语言 > 详细

深入理解什么是Java泛型?泛型怎么使用?【纯转】

时间:2019-06-19 23:46:17      阅读:56      评论:0      收藏:0      [点我收藏+]

标签:jdk   ash   表示   abstract   可变   effective   图片   问题   getclass   

本篇文章给大家带来的内容是介绍深入理解什么是Java泛型?泛型怎么使用?有一定的参考价值,有需要的朋友可以参考一下,希望对你们有所助。

 

一、什么是泛型

“泛型” 意味着编写的代码可以被不同类型的对象所重用。泛型的提出是为了编写重用性更好的代码。泛型的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数

比如常见的集合类 LinkedList:

1

2

3

4

5

public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>,Deque<E>,Cloneable,Serializable{

 //.....

 transient Link<E> voidLink;

//.....   

}

可以看到,LinkedList<E> 类名及其实现的接口名后有个特殊的部分<E>,而且它的成员的类型 Link<E> 也包含一个<E>,这个符号的就是类型参数,它使得在运行中,创建一个 LinkedList 时可以传入不同的类型。

二、为什么引入泛型

在引入泛型之前,要想实现一个通用的、可以处理不同类型的方法,你需要使用 Object 作为属性和方法参数,比如这样:

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

public class Generic{

    private Object[] mData;

 

    public Generic(int capacity){

        mData = new Object[capacity];

    }

     

    public Object getData(int index){

       //.....

       return mData[index];

    }

      

    public void add(int index,Object item){

       //.....

       mData[index] = item;

    }  

 

}

它使用一个 Object 数组来保存数据,这样在使用时可以添加不同类型的对象:

1

2

3

Generic generic = new Generic(10);

generic.add(0,"fangxing");

generic.add(1,23);

Object 是所有类的父类,所有的类都可以作为成员被添加到上述类中;当需要使用的时候,必须进行强制转换,而且这个强转很有可能出现转换异常:

1

2

String item1 = (String) generic.getData(0);

String item2 = (String) generic.getData(1);

第二行代码将一个 Integer 强转成 String,运行时会报错 :

技术分享图片

可以看到,使用 Object 来实现通用、不同类型的处理,有这么两个缺点:

  1. 每次使用时都需要强制转换成想要的类型

  2. 在编译时编译器并不知道类型转换是否正常,运行时才知道,不安全

根据《Java 编程思想》中的描述,泛型出现的动机在于:

有许多原因促成了泛型的出现,而最引人注意的一个原因,就是为了创建容器类。

在 JDK 1.5 出现泛型以后,许多集合类都使用泛型来保存不同类型的元素,比如 Collection:

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

public interface Collection<E> extends Iterable<E>{

    

     Iterator<E> iterator();

    

     Object[] toArray();

      

     <T> T[] toArray(T[] a);

 

     boolean add(E e);

      

     boolean remove(Object o);

  

     boolean  containsAll(Collecion<?> c);

 

     boolean addAll(Collection<? extends E> c);

 

     boolean removeAll(Collection<?> c);

    

}

实际上引入泛型的主要目标有以下几点:

类型安全

  • 泛型的主要目标是提高 Java 程序的类型安全

  • 编译时期就可以检查出因 Java 类型不正确导致的 ClassCastException 异常

  • 符合越早出错代价越小原则

消除强制类型转换

  • 泛型的一个附带好处是,使用时直接得到目标类型,消除许多强制类型转换

  • 所得即所需,这使得代码更加可读,并且减少了出错机会

潜在的性能收益

  • 由于泛型的实现方式,支持泛型(几乎)不需要 JVM 或类文件更改

  • 所有工作都在编译器中完成

  • 编译器生成的代码跟不使用泛型(和强制类型转换)时所写的代码几乎一致,只是更能确保类型安全而已

三、泛型的使用方式

泛型的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数。

类型参数的意义是告诉编译器这个集合中要存放实例的类型,从而在添加其他类型时做出提示,在编译时就为类型安全做了保证。

参数类型可以用在类、接口和方法的创建中,分别称为泛型类、泛型接口、泛型方法。

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

public class GenericClass<F>{

    private F mContent;

     

    public GenericClass(F content){

      mContent = content;

    }

   

    /*

      泛型方法

   */

    public F getContent(){

      return mContent;

    }

     

    public void setContent(F content){

      mcontent = content;

    }

    

    /*

       泛型接口

    */

    public interface GenericInterface<T>{

        void  doSomething(T t);

    }

 

}

泛型类

泛型类和普通类的区别就是类名后有类型参数列表 <E>,既然叫“列表”了,当然这里的类型参数可以有多个,比如 public class HashMap<K, V>,参数名称由开发者决定。

类名中声明参数类型后,内部成员、方法就可以使用这个参数类型,比如上面的 GenericClass<F> 就是一个泛型类,它在类名后声明了类型 F,它的成员、方法就可以使用 F 表示成员类型、方法参数/返回值都是 F 类型。

泛型类最常见的用途就是作为容纳不同类型数据的容器类,比如 Java 集合容器类。

泛型接口

和泛型类一样,泛型接口在接口名后添加类型参数,比如以下 GenericInterface<T>,接口声明类型后,接口方法就可以直接使用这个类型。

    /*

       泛型接口

    */

    public interface GenericInterface<T>{

        void  doSomething(T t);

    }

 

实现类在实现泛型接口时需要指明具体的参数类型,不然默认类型是 Object,这就失去了泛型接口的意义。

未指明类型的实现类,默认是 Object 类型:

1

2

3

4

5

6

public class Generic implements GenericInterface{

    @Override

    public void doSomething(Object o){

      //...

    }

}

指明了类型的实现:

1

2

3

4

5

6

public class Generic implements GericInterface<String>{

     @Override

     public void doSomething(String s){

       //.....

     }

}

泛型接口比较实用的使用场景就是用作策略模式的公共策略, Comparator就是一个泛型接口:

1

2

3

4

public interface Comparator<T>{

    public int compare(T lhs, Trhs);

    public bollean equals(Object object);

}

泛型接口定义基本的规则,然后作为引用传递给客户端,这样在运行时就能传入不同的策略实现类。

泛型方法

泛型方法是指使用泛型的方法,如果它所在的类是一个泛型类,那就很简单了,直接使用类声明的参数。

如果一个方法所在的类不是泛型类,或者他想要处理不同于泛型类声明类型的数据,那它就需要自己声明类型。

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

/*

    传统的方法,会有unchecked ... raw type 的警告

*/

public Set union(Set s1, Set s2){

    Set result = new HashSet(s1);

    result.addAll(s2);

    return result;

}

 

/*

    泛型方法,介于方法修饰符和返回值之间的称作 类型参数列表<A,V,F,E....>(可以有多个)

    类型参数列表 指定参数、返回值中泛型的参数类型范围,命名惯例与泛型相同。

*/

public <E> Set<E> union2(Set<E> s1, Set<E> s2){

    Set<E> result = new HashSet<>(s1);

    result.addAll(s2);

    return result;

}

四、泛型的通配符

通配符:传入的类型有一个指定的范围,从而可以进行一些特定的操作

泛型中有三种通配符形式:

1.<?>无限制通配符

2.<? extends E> extends 关键字声明了类型的上界,表示参数化的类型可能是所指定的类型,或者是此类型的子类。

3.<? super E> super 关键字声明了类型的下界,表示参数化类型可能是指定类型,或者是此类型的父类。

无限制通配符 < ?>

要使用泛型,但是不确定或者不关心实际要操作的类型,可以使用无限制通配符(尖括号里一个问号,即 <?> ),表示可以持有任何类型。

? 和 Object 不一样,List<?> 表示未知类型的列表,而 List<Object> 表示任意类型的列表。

如传入个 List<String> ,这时 List 的元素类型就是 String,想要往 List 里添加一个 Object,这当然是不可以的。

上界通配符 < ? extends E>

在类型参数中使用 extends 表示这个泛型中的参数必须是 E 或者 E 的子类,这样有两个好处:

  • 如果传入的类型不是 E 或者 E 的子类,编辑不成功

  • 泛型中可以使用 E 的方法,要不然还得强转成 E 才能使用

下界通配符 < ? super E>

在类型参数中使用 super 表示这个泛型中的参数必须是 E 或者 E 的父类。

1

2

3

4

5

private <E> void add(List<? super E> dst, List<E> Src){

    for (E e : src){

    dst.add(e);

   }

}

上面的 dst 类型 “大于等于” src 的类型,这里的“大于等于”是指 dst 表示的范围比 src 要大,因此装得下 dst 的容器也就能装 src。

通配符比较

无限制通配符 < ?> 和 Object 有些相似,用于表示无限制或者不确定范围的场景。

< ? super E> 用于灵活写入或比较,使得对象可以写入父类型的容器,使得父类型的比较方法可以应用于子类对象。

< ? extends E> 用于灵活读取,使得方法可以读取 E 或 E 的任意子类型的容器对象。

技术分享图片

因此使用通配符的基本原则:

  • 如果参数化类型表示一个 T 的生产者,使用 < ? extends T>;(T 的子类)

  • 如果它表示一个 T 的消费者,就使用 < ? super T>;(T 的父类)

  • 如果既是生产又是消费,那使用通配符就没什么意义了,因为你需要的是精确的参数类型。

小总结一下:

  • T 的生产者的意思就是结果会返回 T,这就要求返回一个具体的类型,必须有上限才够具体;

  • T 的消费者的意思是要操作 T,这就要求操作的容器要够大,所以容器需要是 T 的父类,即 super T;

举个例子:

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

private <E extends Comparable<? super E>> E max(List<? extends E> e1){

 

    if(e1 == null){

        return null;

    }

 

    //迭代器返回的元素属于 E 的某个子类型

    

    Iterator<? extends E> iterator = e1.iterator();

    E result = iterator.next();

    while (iterator.hasNext()){

     E next = iterator.next();

      if(next.compareTo(result)>0){

       result = next;

      }

    }

    return result;

}

1.要进行比较,所以 E 需要是可比较的类,因此需要 extends Comparable<…>(注意这里不要和继承的 extends 搞混了,不一样)

2.Comparable< ? super E> 要对 E 进行比较,即 E 的消费者,所以需要用 super

3.而参数 List< ? extends E> 表示要操作的数据是 E 的子类的列表,指定上限,这样容器才够大

五、泛型的类型擦除

Java 中的泛型和 C++ 中的模板有一个很大的不同:

  • C++ 中模板的实例化会为每一种类型都产生一套不同的代码,这就是所谓的代码膨胀。

  • Java 中并不会产生这个问题。虚拟机中并没有泛型类型对象,所有的对象都是普通类。

在 Java 中,泛型是 Java 编译器的概念,用泛型编写的 Java 程序和普通的 Java 程序基本相同,只是多了一些参数化的类型同时少了一些类型转换。

实际上泛型程序也是首先被转化成一般的、不带泛型的 Java 程序后再进行处理的,编译器自动完成了从 Generic Java 到普通 Java 的翻译,Java 虚拟机运行时对泛型基本一无所知。

当编译器对带有泛型的java代码进行编译时,它会去执行类型检查和类型推断,然后生成普通的不带泛型的字节码,这种普通的字节码可以被一般的 Java 虚拟机接收并执行,这在就叫做 类型擦除(type erasure)。

实际上无论你是否使用泛型,集合框架中存放对象的数据类型都是 Object,这一点不仅仅从源码中可以看到,通过反射也可以看到。

1

2

3

List<String> strings = new ArrayList<>();

List<Integer> integers = new ArrayList<>();

System.out.println(Strings.getClass()==integers.getClass());//true

上面代码输出结果并不是预期的false,而是true。其原因就是泛型的擦除。

六、擦除的实现原理

一直有个疑问,Java 编译器在编译期间擦除了泛型的信息,那运行中怎么保证添加、取出的类型就是擦除前声明的呢?

Java 编辑器会将泛型代码中的类型完全擦除,使其变成原始类型。当然,这时的代码类型和我们想要的还有距离,接着 Java 编译器会在这些代码中加入类型转换,将原始类型转换成想要的类型。这些操作都是编译器后台进行,可以保证类型安全。总之泛型就是一个语法糖,它运行时没有存储任何类型信息。

擦除导致的泛型不可变性

泛型中没有逻辑上的父子关系,如 List 并不是 List 的父类。两者擦除之后都是List,所以形如下面的代码,编译器会报错:

1

2

3

4

5

6

7

8

/*

    两者并不是方法的重载,擦除之后就是同一方法,所以编译不会通过。

    擦除之后:

    void m(List numbers){}

    void m(List Strings){}   //编译不通过,已经存在形同方法签名

*/

   void method(List<Object> numbers){}

   void method(List<String> strings){}

泛型的这种情况称为 不可变性,与之对应的概念是 协变、逆变:

  • 协变:如果 A 是 B 的父类,并且 A 的容器(比如 List< A>) 也是 B 的容器(List< B>)的父类,则称之为协变的(父子关系保持一致)

  • 逆变:如果 A 是 B 的父类,但是 A 的容器 是 B 的容器的子类,则称之为逆变(放入容器就篡位了)

  • 不可变:不论 A B 有什么关系,A 的容器和 B 的容器都没有父子关系,称之为不可变

Java 中数组是协变的,泛型是不可变的。

擦除的拯救者:边界

我们知道,泛型运行时被擦除成原始类型,这使得很多操作无法进行.

如果没有指明边界,类型参数将被擦除为 Object。

如果我们想要让参数保留一个边界,可以给参数设置一个边界,泛型参数将会被擦除到它的第一个边界(边界可以有多个),这样即使运行时擦除后也会有范围。

比如:

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

public class GenericErasure {

    interface Game{

      void play();

    }

    interface Program{

      void code();

   }

   public static calss People<T extends Program & Game>{

       private T mPeople;

        

       public People(T people){

         mPeople = people;

       }

       public void habit(){

         mPeople.code();

         mPeople.play();

        }

   }

    

 

}

上述代码中, People 的类型参数 T 有两个边界,编译器事实上会把类型参数替换为它的第一个边界的类型。

七、泛型的规则

  • 泛型的参数类型只能是类(包括自定义类),不能是简单类型。

  • 同一种泛型可以对应多个版本(因为参数类型是不确定的),不同版本的泛型类实例是不兼容的。

  • 泛型的类型参数可以有多个

  • 泛型的参数类型可以使用 extends 语句,习惯上称为“有界类型”

  • 泛型的参数类型还可以是通配符类型,例如 Class

泛型的使用场景

当类中要操作的引用数据类型不确定的时候,过去使用 Object 来完成扩展,JDK 1.5后推荐使用泛型来完成扩展,同时保证安全性。

八、总结

1.上面说到使用 Object 来达到复用,会失去泛型在安全性和直观表达性上的优势,那为什么 ArrayList 等源码中的还能看到使用 Object 作为类型?

泛型出现时,Java 平台即将进入它的第二个十年,在此之前已经存在了大量没有使用泛型的 Java 代码。人们认为让这些代码全部保持合法,并且能够与使用泛型的新代码互用,非常重要。

这样都是为了兼容,新代码里要使用泛型而不是原始类型。

2.泛型是通过擦除来实现的。因此泛型只在编译时强化它的类型信息,而在运行时丢弃(或者擦除)它的元素类型信息。擦除使得使用泛型的代码可以和没有使用泛型的代码随意互用。

3.如果类型参数在方法声明中只出现一次,可以用通配符代替它。

1

2

3

private <E> void swap(List<E> list, int i, int j){

    //....

}

只出现了一次 类型参数,没有必要声明,完全可以用通配符代替:

1

2

3

private void swap(List<?> list, int i, int j){

    //...

}

对比一下,第二种更加简单清晰吧。

4.数组中不能使用泛型

Array 事实上并不支持泛型,这也是为什么 Joshua Bloch 在 《Effective Java》一书中建议使用 List 来代替 Array,因为 List 可以提供编译期的类型安全保证,而 Array 却不能。

5.Java 中 List<Object> 和原始类型 List 之间的区别?

  • 在编译时编译器不会对原始类型进行类型安全检查,却会对带参数的类型进行检查

  • 通过使用 Object 作为类型,可以告知编译器该方法可以接受任何类型的对象,比如String 或 Integer

  • 你可以把任何带参数的类型传递给原始类型 List,但 却不能把 List< String> 传递给接受 List< Object> 的方法,因为泛型的不可变性,会产生编译错误。

九、补充

静态资源不认识泛型

接上一个话题,如果把<T>去掉,那么:

1

2

3

private static T ifThenElse(boolean b, T first, T second){

    return b ? first : second;

}

报错,T未定义。但是如果我们再把static去掉:

1

2

3

4

5

6

7

8

public class TestMain<T>{

    public static void main(String[] args){}

     

   @SuppressWarnings("unused")

   private List<T> ifThenElse(boolean b,T first, T second){

     return null;

   }

}

这并不会有任何问题。两相对比下,可以看出static方法并不认识泛型,所以我们要加上一个<T>,告诉static方法,后面的T是一个泛型。既然static方法不认识泛型,那我们看一下static变量是否认识泛型:

1

2

3

4

public class TestMain<T>{

    private List<T> notStaticList;

    private static List<T> staticList;

}

这证明了,static变量也不认识泛型,其实不仅仅是staic方法、static变量、static块,也不认识泛型,可以自己试一下。总结起来就是一句话:静态资源不认识泛型。

总结:以上就是本篇文的全部内容,希望能对大家的学习有所帮助。更多相关教程请访问Java视频教程java开发图文教程bootstrap视频教程

以上就是深入理解什么是Java泛型?泛型怎么使用?的详细内容,更多请关注php中文网其它相关文章

 

参考

本文完全参考自: 深入理解什么是Java泛型?泛型怎么使用?==>http://m.php.cn/article/411947.html?tdsourcetag=s_pctim_aiomsg

深入理解什么是Java泛型?泛型怎么使用?【纯转】

标签:jdk   ash   表示   abstract   可变   effective   图片   问题   getclass   

原文:https://www.cnblogs.com/whatlonelytear/p/11055126.html

(0)
(0)
   
举报
评论 一句话评论(0
0条  
登录后才能评论!
© 2014 bubuko.com 版权所有 鲁ICP备09046678号-4
打开技术之扣,分享程序人生!
             

鲁公网安备 37021202000002号