《Java编程思想_ 深入理解java虚拟机_Thinking in java__Effiect java__设计模式》学习笔记7——泛型编程基础

转载地址:http://blog.csdn.net/chjttony/article/details/6785221

还有相关的文章:http://blog.csdn.net/waldmer/article/details/12704963

一般的类和方法都是针对特定数据类型的,当写一个对多种数据类型都适用的类和方法时就需要使用泛型编程,java的泛型编程类似于C++中的模板,即一种参数化类型的编程方法,具体地说就是将和数据类型相关的信息抽象出来,主要提供通用的实现和逻辑,和数据类型相关的信息由使用时参数决定。

1.泛型类/接口:

(1).泛型接口:

如一个提供产生指定类的接口:

[java] 
view plain
copy

  1. public interface Gernerator<T>{  
  2.     T next() ;  
  3. }  
  4. public class A implement Generator<A>{  
  5.     A next(){  
  6.         return new A();  
  7. }  
  8. }  

(2).泛型类:

一个使用泛型实现的栈数据结构如下:

[java] 
view plain
copy

  1. public class LinkedListStack<T>{  
  2.     //节点内部类  
  3.     private static class Node<U>{  
  4.         U item;  
  5.         Node<U> next;  
  6.         Node(){  
  7.             item = null;  
  8.             next = null;  
  9. }  
  10.         Node(U item, Node<U> next){  
  11.     this.item = item;  
  12.     this.next = next;  
  13. }  
  14. Boolean end(){  
  15.     return item == null && next == null;  
  16. }  
  17. }  
  18. private Node<T> top = new Node<T>();  
  19. public void push<T>(T item){  
  20.     top = new Node<T>(item, top);  
  21. }  
  22. public T pop(){  
  23.     T result = top.item;  
  24.     if(!top.end()){  
  25.         top = top.next();  
  26. }  
  27. return result;  
  28. }   
  29. }  

使用这个使用泛型实现的栈,可以操作各种数据类型。

2.泛型方法:

例如:

[java] 
view plain
copy

  1. public class GenericMethods{  
  2.     public <T> void f(T x){  
  3.         System.out.println(x.getClass().getName()) ;  
  4. }  
  5. public static void main(String[] args){  
  6.     GenericMethods gm = new GenericMethods();  
  7.     gm.f(“”);  
  8.     gm.f(1);  
  9.     gm.f(1.0);  
  10.     ……  
  11. }   
  12. }  

输出结果为:

java.lang.String

java.lang.Integer

java.lang.Double

3.泛型集合:

Java中泛型集合使用的非常广泛,在Java5以前,java中没有引入泛型机制,使用java集合容器时经常遇到如下两个问题:

a.       java容器默认存放Object类型对象,如果一个容器中即存放有A类型对象,又存放有B类型对象,如果用户将A对象和B对象类型弄混淆,则容易产生转换错误,会发生类型转换异常。

b.       如果用户不知道集合容器中元素的数据类型,同样也可能会产生类型转换异常。

鉴于上述的问题,java5中引入了泛型机制,在定义集合容器对象时显式指定其元素的数据类型,在使用集合容器时,编译器会检查数据类型是否和容器指定的数据类型相符合,如果不符合在无法编译通过,从编译器层面强制保证数据类型安全。

(1).java常用集合容器泛型使用方法:

如:

[java] 
view plain
copy

  1. public class New{  
  2.     public static <K, V> Map<K, V> map(){  
  3.         return new HashMap<K, V>();  
  4. }  
  5. public static <T> List<T> list(){  
  6.     return new ArrayList<T>() ;  
  7. }  
  8. public static <T> LinkedList<T> lList(){  
  9.     return new LinkedList<T>();  
  10. }  
  11. public static <T> Set<T> set(){  
  12.     return new HashSet<T>();  
  13. }  
  14. public static <T> Queue<T> queue(){  
  15.     return new LinkedList<T>() ;  
  16. }  
  17. ;public static void main(String[] args){  
  18.     Map<String, List<String>> sls = New.map();  
  19.     List<String> ls = New.list();  
  20.     LinkedList<String> lls = New.lList();  
  21.     Set<String> ss = New.set();  
  22.     Queue<String> qs = New.queue();  
  23. }  
  24. }  

(2).Java中的Set集合是数学上逻辑意义的集合,使用泛型可以很方便地对任何类型的Set集合进行数学运算,代码如下:

[java] 
view plain
copy

  1. public class Sets{  
  2.     //并集  
  3.     public static <T> Set<T> union(Set<T> a, Set<T> b){  
  4.         Set<T> result = new HashSet<T>(a);  
  5.         result.addAll(b);  
  6.         return result;  
  7. }  
  8. //交集  
  9. public static <T> Set<T> intersection(Set<T> a, Set<T> b){  
  10.     Set<T> result = new HashSet<T>(a);  
  11.     result.retainAll(b);  
  12.     return result;  
  13. }  
  14. //差集  
  15. public static <T> Set<T> difference(Set<T> a, Set<T> b){  
  16.     Set<T> result = new HashSet<T>(a);  
  17.     result.removeAll(b);  
  18.     return Result;  
  19. }  
  20. //补集  
  21. public static <T> Set<T> complement(Set<T> a, Set<T> b){  
  22.     return difference(union(a, b), intersection(a, b));  
  23. }  
  24. }  
    原文作者:java虚拟机
    原文地址: https://blog.csdn.net/lijinhua7602/article/details/44916661
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞

发表评论

电子邮件地址不会被公开。 必填项已用*标注