黑马程序员技术交流社区

标题: 泛型总结和练习 [打印本页]
作者: Sakuratossi    时间: 2014-9-1 11:19
标题: 泛型总结和练习

泛型定义：
jdk 1.5 新特性！ 是类型的一种拓展,相当于类型占位符,就好比方法的形式参数是实际参数的占位符一样.
泛型能保证大型应用程序的类型安全和良好的维护性;

使用泛型的好处:
类型安全,使编译器对泛型定义的类型做判断限制.如保证TreeSet里的元素类型必须一致;消除强制类型的转换,如,使用Comparable比较时每次都需要类型强转；


泛型类

在类声明时通过一个标识符表示类中某个字段的类型或者某个方法的返回值或参数的类型，这样在类声明或实例化的时候只要指定自己需要的类型就ok。

声明带泛型的类:
class 类名<泛型类型1,泛型类型2……>{
     泛型类型  变量名；
     泛型类型  方法名(){}
     返回值类型 方法名(泛型类型 变量名){}
}
使用带泛型的类：
类名<具体类> 对象名 = new 类名<具体类>();


泛型方法

方法中可定义泛型参数，形参的参数类型就是实参的类型。
格式：
<泛型标签> 返回值类型 方法名([泛型标签 参数]…)


泛型的上限与下限

设置泛型对象的上限使用extends,表示参数类型只能是该类型或该类型的子类：
声明对象：类名<? extends 类> 对象名
定义类：类名<泛型标签 extends 类>{}
设置泛型对象的下限使用super,表示参数类型只能是该类型或该类型的父类：
声明对象：类名<? super 类> 对象名称
定义类：类名<泛型标签 extends类>{}


  2. // 泛型的简单示例
  3. class GenericDemo1
  4. {
  5.         public static void main(String[] args)
  6.         {
  7.                 Demo d = new Demo();

  9.                 d.show(new Integer(5));
  10.                 d.print('s');
  11.                 d.writeStatic(true);

  13.                 Demo1<Integer> d1 = new Demo1<Integer>();
  14.                 d1.show(new Integer(1));
  15.                 d1.writeStatic("abc");
  16.                 d1.writeStatic1(new Integer(14));
  17.         }
  18. }

  20. // 泛型方法：
  21. class Demo
  22. {
  23.         public <T> void show(T t)
  24.         {
  25.                 System.out.println("show----" + t);
  26.         }
  27.        
  28.         public <Q> void print(Q t)
  29.         {
  30.                 System.out.println("print---" + t);
  31.         }

  33.         public static <M> void writeStatic(M m)
  34.         {
  35.                 System.out.println("writeStatic---" + m);
  36.         }
  37. }


  40. //泛型类：

  42. class Demo1<T>
  43. {
  44.         public void show(T t)
  45.         {
  46.                 System.out.println("show1----" + t);
  47.         }
  48.        
  49.         public void print(T t)
  50.         {
  51.                 System.out.println("print1---" + t);
  52.         }

  54. //        public static void writeStatic1(T t)  // 错误: 无法从静态上下文中引用非静态 类型变量 T
  55. //        {
  56. //                System.out.println("writeStatic1---" + t);
  57. //        }

  59.         public static <W> void writeStatic(W w)
  60.         {
  61.                 System.out.println("writeStatic1---" + w);
  62.         }
  63. }
复制代码


泛型在集合中的应用

  1. import java.util.*;

  3. class GenericDemo
  4. {
  5.         public static void main(String[] args)
  6.         {
  7.                 TreeSet<String> ts = new TreeSet<String>(new StrComparator());

  9.                 ts.add("lide");
  10.                 ts.add("flieedde");
  11.                 ts.add("liddgde");
  12.                 ts.add("hhhidd");

  14.                 for (Iterator<String> it = ts.iterator(); it.hasNext(); )
  15.                 {
  16.                         String s = it.next();
  17.                         sop(s);
  18.                 }

  20.         }

  22.         public static void sop(Object obj)
  23.         {
  24.                 System.out.println(obj);
  25.         }
  26. }

  28. class StrComparator implements Comparator<String>  // 不用类型强转
  29. {
  30.         public int compare(String o1,String o2)
  31.         {
  32.                 String s1 = o1;
  33.                 String s2 = o2;

  35.                 int num = new Integer(s2.length()).compareTo(new Integer(s1.length()));  //如果倒序排列，把o1和
  36.                                                                                                                                                                 //o1换位
  37.                 if(num == 0)
  38.                 {
  39.                         return s1.compareTo(s2);
  40.                 }
  41.                 return num;
  42.         }
  43. }
复制代码




欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2