Java上路13-泛型

       泛型是JDK1.5为类型安全做的更新，将运行时期出现的ClassCaseException转移到了编译时期。通过尖括号定义要引用的数据类型。

import java.util.*; class GenericDemo{       public static void main(String[] args)       {              //使用尖括号声明String类型的集合              TreeSet<String> al=new TreeSet<String>(new MyComparator());               al.add("abcde");              al.add("bbeed");              al.add("ddfee");               //迭代器也得声明              Iterator<String> it=al.iterator();              while(it.hasNext())              {                     String s=it.next();       //省略强转                     System.out.println(s);              }       }} //比较器class MyComparator implements Comparator<String>{       public int compare(String o1, String o2)       {              int num=new Integer(o2.length()).compareTo(new Integer(o1.length()));               if(num==0)                     return o2.compareTo(o1);               return num;       }}    

一. 自定义泛型类：

       当类中要操作的引用数据类型不确定时，可以自定义泛型类扩展。

import java.util.*; class Worker{       Worker()       {              System.out.println("泛型...");       }} class CustomGeneric<MyClass> //自定义的泛型类{       private MyClass mc;       public void setObject(MyClass mc)       {              this.mc=mc;       }       public MyClass getObject()       {              return mc;       }} class GenericDemo{       public static void main(String[] args)       {              CustomGeneric<Worker> cg=new CustomGeneric<Worker>();              cg.setObject(new Worker());              System.out.println(cg.getObject());       }}    

二. 泛型方法：

       为了让不同方法操作不同类型，将泛型定义在方法上。

import java.util.*; class CustomGeneric{       public<Custom> void showCustom(Custom c)     //自定义的泛型方法       {              System.out.println("show"+c);       }} class GenericDemo{       public static void main(String[] args)       {              CustomGeneric cg=new CustomGeneric();              cg.showCustom("HelloGeneric");              cg.showCustom(123);       }}  

   

三. 泛型类和泛型方法的混合使用：

import java.util.*; class CustomGeneric<Custom> //泛型类{       public void showCustom(Custom c)  //追随类的泛型方法       {              System.out.println("show"+c);       }        public <Cust> void printCustom(Custc)  //自定义的泛型方法       {              System.out.println("print"+c);       }        //静态的泛型方法       public static <CustomStatoc> void staticCustom (CustomStatoc cs)       {              System.out.println("static"+cs);       }} classGenericDemo{       public static void main(String[] args)       {              CustomGeneric<String> cg=new CustomGeneric<String>();              cg.showCustom("HelloGeneric");               cg.printCustom(123);              cg.printCustom("abc");               CustomGeneric.staticCustom(46);              CustomGeneric.staticCustom("tom");       }}  

   

四. 泛型接口：

import java.util.*; interface Inter<T>{       void show(T t);} class InterImp<Ttt> implements Inter<Ttt>{       public void show(Ttt t)       {              System.out.println(""+t);       }} class GenericDemo{       public static void main(String[] args)       {              InterImp<Integer> i=new InterImp<Integer>();              i.show(469);       }}   

五. 泛型限定：

       ？通配符，泛型方法中替代不确定类型的元素，

import java.util.*; class GenericDemo{       public static void main(String[] args)       {              ArrayList<String> als=new ArrayList<String>();              als.add("dfk");              als.add("jhutyr");              als.add("sdfh");              als.add("kgrere");               ArrayList<Integer> ali=new ArrayList<Integer>();              ali.add(14);              ali.add(24);              ali.add(50);              ali.add(23);               printColl(als);              printColl(ali);       }        public static void printColl(ArrayList<?> al)       {              Iterator<?> it=al.iterator();              while (it.hasNext())              {                     System.out.println(it.next());              }       }}   

       ？ extends E，可以接受E类型或E的子类，设置了上限；

       ？ super E，可以接受E或E的父类，设置了下限；

import java.util.*; class GenericDemo{       public static void main(String[] args)       {              ArrayList<Person> alp=new ArrayList<Person>();              alp.add(new Person("张三"));              alp.add(new Person("李四"));              alp.add(new Person("王五"));              printColl(alp);               System.out.println();               ArrayList<Student> als=new ArrayList<Student>();              als.add(new Student("学生1"));              als.add(new Student("学生2"));              als.add(new Student("学生3"));              printColl(als);               System.out.println();               TreeSet<Student> tss=new TreeSet<Student>(new MyComparator());              tss.add(new Student("学生4"));              tss.add(new Student("学生2"));              tss.add(new Student("学生3"));              tss.add(new Student("学生5"));              for(Iterator<Student>itt=tss.iterator();itt.hasNext();)              {                     Student s=itt.next();                     System.out.println(s.getName());              }       }        //只能引用Person或子类实例       public static void printColl(ArrayList<? extends Person> al)       {              Iterator<?> it=al.iterator();              while (it.hasNext())              {                     Person p=(Person)it.next();                     System.out.println(p.getName());              }       }} //Person的所有子类都可引用class MyComparator implements Comparator<Person>{       public int compare(Person p1, Person p2)       {              return p1.getName().compareTo(p2.getName());       }} class Person{       private String name;        Person(String name)       {              this.name=name;       }        public String getName()       {              return name;       }} class Student extends Person{       Student(String name)       {              super(name);       }}