黑马程序员---集合框架<泛型>

---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------

 

泛型：JDK1.5版本以后出现的新特性，用于解决安全问题，是一个类型安全机制。

 

加上泛型，解决了以下这个问题：

 

好处：

    1.将运行时期出现的问题ClassCastException，转移到了编译时期。

       方便于程序员解决问题，让运行时期问题减少，安全。

    2.避免了强制转换麻烦。

 

import java.util.*;class GenericDemo {public static void sop(Object obj){System.out.println(obj);}public static void main(String[] args) {TreeSet<String> al = new TreeSet<String>(new LenCompare());al.add("hfjz");al.add("abcdef");al.add("hgf");al.add("aaa");al.add("a");Iterator<String> it = al.iterator();while(it.hasNext()){sop(it.next());}}}class LenCompare implements Comparator<String>{public int compare(String s1, String s2){int num = new Integer(s2.length()).compareTo(new Integer(s1.length()));if(num==0){return s2.compareTo(s1);}return num;}}

 

现在定义一个像Student这样的自定义类，我们就需要实现它的所有基本功能，不管能不能用的上。

包括：hashCode() 、 equals() 、 实现Comparable:覆盖compareTo() 、 toString() 。

 

import java.util.*;class Student implements Comparable<Student>{private String name;private int age;Student(String name, int age){this.name = name;this.age = age;}public String getName(){return name;}public int getAge(){return age;}public String toString(){return name+"::"+age;}public int hashCode(){return name.hashCode()+age*39;}public boolean equals(Object obj){if(!(obj instanceof Student)){throw new RuntimeException("不是学生");}Student s = (Student)obj;return this.name.equals(s.name)&&this.age==s.age;}public int compareTo(Student s){int num = new Integer(this.age).compareTo(new Integer(s.age));if(0==num){return this.name.compareTo(s.name);}return num;}}class GenericTest {public static void sop(Object obj){System.out.println(obj);}public static void method_HashSet(){HashSet<Student> hs = new HashSet<Student>();hs.add(new Student("lisi03",11));hs.add(new Student("lisi01",12));hs.add(new Student("lisi01",12));hs.add(new Student("lisi09",11));hs.add(new Student("lisi03",15));Iterator<Student> it = hs.iterator();while(it.hasNext()){sop(it.next().toString());}}public static void method_TreeSet(){TreeSet<Student> ts = new TreeSet<Student>(new MyCompare());ts.add(new Student("lisi03",12));ts.add(new Student("lisi01",13));ts.add(new Student("lisi01",12));ts.add(new Student("lisi09",11));ts.add(new Student("lisi03",15));Iterator<Student> it = ts.iterator();while(it.hasNext()){sop(it.next().toString());}}public static void main(String[] args){//method_TreeSet();method_HashSet();}}class MyCompare implements Comparator<Student>{public int compare(Student s1, Student s2){int num = s1.getName().compareTo(s2.getName());if(0==num){return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));}return num;}}

 

泛型类：

假如：我们定义了一个Worker类，

 

class  Worker

{

}

 

就需要一个操作Worker类的工具类，

 

class  Tool

{

        private  Worker  w;

        public  void  setWorker ( Worker  w )

        {

                this.w = w;

        }

        public  Worker  getWorker ( )

        {

                return w;

        }

}

 

如果我们又定义了一个Student类，那么我们就又需要一个操作Student类的工具类。

如果我们定义许许多多的类，那么就需要定义许许多多的工具类。

这样很麻烦，所以我们就想办法定义一个特殊的工具类，它能够操作任何的自定义类，下面就产生了它，

 

class Tools

{

        private  Object  obj;

        public  void  setObject ( Object  obj )

        {

                this.obj = obj;

        }

        public  Object  getObject ( )

        {

                return obj;

        }

}

 

这样的工具类也有它的不安全性，比如说，我们误将一个Student类的引用当作参数传递给了一个Worker的引用，但是在编译时期是可以通过的，只能等到在运行时期才会报错，

 

class  GenericTest

{

        public  static  void  main ( String  args[ ] )

        {

                Tools  t  =  new  Tools () ;

                t . setObject ( new  Student () ) ;

                Worker  w  =  ( Worker )  t . getObject () ;  

        }

}

 

 

我们把这种编译时期检测不到的错误看成是不安全性，这时我们就需要通过泛型来把运行时期的问题转移到编译时期来，这样开发人员能看到错误，提高了安全性，

 

class Worker{}class Student{}class Tools<QQ>{private QQ q;public void setObject(QQ q){this.q = q;}public QQ getObject(){return q;}}class GenericTest1 {public static void main(String[] args) {Tools<Worker> t = new Tools<Worker>();t.setObject(new Worker());Worker w = t.getObject();}}

 

总结：

什么时候定义泛型类？
当类中要操作的引用数据类型不确定的时候，
早期定义Object来完成扩展。
现在定义泛型来完成扩展。

 

泛型类定义的泛型，在整个类中有效。如果被方法使用，
那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。
为了让不同方法可以操作不同类型，而且类型还不确定。
那么可以将泛型定义在方法上。

 

class Demo{public <T> void show(T t){System.out.println("show :"+t);}public <T> void print(T t){System.out.println("print :"+t);}}class GenericDemo1 {public static void main(String[] args) {Demo d = new Demo();d.show("abcde");d.print(3);}}

 

class Demo<T>{public void show(T t){System.out.println("show :"+t);}public <Q> void print(Q q){System.out.println("print :"+q);}}class GenericDemo2 {public static void main(String[] args) {Demo<String> d = new Demo<String>();d.show("abcde");d.print(3);}}

 

特殊之处：
静态方法不可以访问类上定义的泛型。

因为泛型类在建立对象之后才能明确要操作的具体类型，产生静态方法的时候，类型还没确定，所以不可以使用类上定义的泛型。
如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。

 

class Demo<T>{public void show(T t){System.out.println("show :"+t);}public static <Q> void print(Q q){System.out.println("print :"+q);}}class GenericDemo3 {public static void main(String[] args) {Demo<String> d = new Demo<String>();d.show("abcde");Demo.print(3);}}

 

泛型定义在接口上：

 

interface Inter<T>{void show(T t);}class InterImpl<T> implements Inter<T>{public void show(T t){System.out.println("show :"+t);}}class GenericDemo4 {public static void main(String[] args) {InterImpl<Integer> in = new InterImpl<Integer>();in.show(3);}}

 

通配符 <?>  和 泛型 <T> 的区别：

 

写泛型 <T> 可以对此T类型进行操作，

 

import java.util.*;class GenericDemo5 {public static void main(String[] args) {ArrayList<String> al = new ArrayList<String>();al.add("aaa01");al.add("aaa02");al.add("aaa03");al.add("aaa04");ArrayList<Integer> al1 = new ArrayList<Integer>();al1.add(1);al1.add(3);al1.add(7);printColl(al);printColl(al1);}public static <T> void printColl(ArrayList<T> al){Iterator<T> it = al.iterator();while(it.hasNext()){T t = it.next();//写泛型，可以使用此类型进行操作。System.out.println(t);}}}

 

写通配符 <?> 不可以对此类型进行操作，

 

import java.util.*;class GenericDemo6 {public static void main(String[] args) {ArrayList<String> al = new ArrayList<String>();al.add("aaa01");al.add("aaa02");al.add("aaa03");al.add("aaa04");ArrayList<Integer> al1 = new ArrayList<Integer>();al1.add(1);al1.add(3);al1.add(7);printColl(al);printColl(al1);}public static void printColl(ArrayList<?> al){Iterator<?> it = al.iterator();while(it.hasNext()){System.out.println(it.next());}}}

 

这两个符号都叫泛型。用泛型的好处是，可以扩展，提高代码复用性，坏处是不可以使用类型特有的方法如length()；但是可以使用toString()，因为所有类型都具备，不写toString()直接打印默认也是toString()。

 

 ? 通配符。也可以理解为占位符。
泛型的限定；
？ extends E: 可以接收E类型或者E的子类型。上限。

 

import java.util.*;class GenericDemo7 {public static void main(String[] args) {ArrayList<Person> al = new ArrayList<Person>();al.add(new Person("abc001"));al.add(new Person("abc002"));al.add(new Person("abc003"));al.add(new Person("abc004"));ArrayList<Student> al1 = new ArrayList<Student>();al1.add(new Student("S-abc--001"));al1.add(new Student("S-abc--002"));al1.add(new Student("S-abc--003"));al1.add(new Student("S-abc--004"));ArrayList<Worker> al2 = new ArrayList<Worker>();al2.add(new Worker("W-abc--001"));al2.add(new Worker("W-abc--002"));al2.add(new Worker("W-abc--003"));al2.add(new Worker("W-abc--004"));printCollection(al);printCollection(al1);printCollection(al2);}public static void printCollection(ArrayList<? extends Person> al){Iterator<? extends Person> it = al.iterator();while(it.hasNext()){System.out.println(it.next().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);}}class Worker extends Person{Worker(String name){super(name);}}

？ super E: 可以接收E类型或者E的父类型。下限。

 

import java.util.*;class GenericDemo8 {public static void main(String[] args) {//因为Student本身不具备比较性，所以可以传本身的比较器对象或者父类的比较器对象。//TreeSet(Comparator<? super E> comparator) TreeSet<Student> ts = new TreeSet<Student>(new MyCompare());ts.add(new Student("s-abc--001"));ts.add(new Student("s-abc--002"));ts.add(new Student("s-abc--003"));ts.add(new Student("s-abc--004"));TreeSet<Worker> ts1 = new TreeSet<Worker>(new MyCompare());ts1.add(new Worker("w-abc--001"));ts1.add(new Worker("w-abc--002"));ts1.add(new Worker("w-abc--003"));ts1.add(new Worker("w-abc--004"));printCollection(ts);printCollection(ts1);}/*给每一个TreeSet对象定义一个迭代器比较麻烦，所以将功能抽取，封装成函数，此函数定义了一个<? extends E>类型参数，指定了上限，可以接收E或者E的子类*/public static void printCollection(TreeSet<? extends Person> ts){Iterator<? extends Person> it = ts.iterator();while(it.hasNext()){System.out.println(it.next().getName());}}}class MyCompare 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);}}class Worker extends Person{Worker(String name){super(name);}}

 

---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------

详细请查看：http://edu.csdn.net