集合框架__【泛型】

泛型：

JDK1.5版本的新特性，用于解决安全问题，是一个类型安全机制
泛型的好处
1，将运行时期出现的问题ClassCastException转移到了编译时期；便于程序员解决问题，减小安全隐患
2，避免了强转的麻烦，
使用场景：
格式：通过<>来定义要操作的引用数据类型
在集合框架中比较常见，见到<>就定义了泛型，<>就是用来接收类型的；在迭代器，比较器，容器中使用
当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可

例如描述学生类时复写hashCode()、equals()、compare()方法。HashSet、TreeSet中都可以存入

泛型使用示例

import java.util.*;class GenericDemo {public static void main(String[] args) {TreeSet<String> al = new TreeSet<String>(new LenComparator());//泛型，只能传入String类对象，否则编译报错al.add("add1");al.add("fa2");al.add("ddgxa3");al.add("dda3");Iterator<String> it = al.iterator();//迭代器中使用泛型while (it.hasNext()){String s = it.next();System.out.println(s+":"+s.length());}}}class LenComparator implements Comparator<String>//比较器中定义泛型{public int compare(String o1,String o2)//传入类型限制为String，不需要再向下转型{int num = new Integer(o1.length()).compareTo(new Integer(o2.length()));//比较长度if (num == 0)return o1.compareTo(o2);//如果长度相同，则进行正常比较return num;//如要换位将o1、o2换位即可}}

泛型类

当类中要操作的引用数据不确定时：早期定义Object完成扩展，而且会在运行时引发安全隐患；需要类型强转
现在定义泛型来完成扩展，将错误转移到编译时期，安全隐患会在编译时就排除；而且不用强转类型

示例：

class Worker{}class Student{}class Utils<haha>//泛型类，作为获取不同对象的工具{private haha h;public void set(haha h){this.h = h;}public haha get(){return h;}}class  GenericDemo2{public static void main(String[] args) {Utils<Worker> u = new Utils<Worker>();u.set(new Student());//定义泛型为Worker，传入Student时编译报错Worker w = u.get();//如果不定义泛型，传入Student，编译时正常，运行时抛异常}}

泛型类的优点 ：
强大之处在于可以传入任何类型的对象引用，而不需要再定义多个重载函数
泛型类的局限性：
泛型类定义的泛型在整个类中都有效，被方法调用泛型类的对象要操作的类型一旦确定，就固定了，如下示例：

Demo<Integer> d = new Demo<Integer>();//只能操作Integer型，要想操作其他类型必须new一个Demo出来d.show(new Integer(4));d.print(9);Demo<String> s = new Demo<String>();//只能操作String型，否则编译出错s.show(new String("haha"));s.print("bbb");

泛型方法

为了让让不同方法可以操作不同的类型，且类型不确定，可以将泛型定义在方法上；打破了泛型类的局限性
在泛型类中可以同时存在泛型方法；
该类中的方法如果不自定义泛型就与类的泛型一致，
而如果该类中的方法也定义了泛型，该方法就不受类泛型的限制，可以传入任意对象。
特殊之处：静态方法不可以访问类上的泛型，如果静态方法操作的应用数据类型不确定，就将泛型定义在方法上

示例：

class Demo<T>//泛型类{public <T> void show(T t)//泛型方法{System.out.println("show :"+t);}public <Q> void print(Q q)//泛型方法{System.out.println("print:"+q);}public static <S> void method(S s)//静态方法不能访问类的泛型，泛型类中必须将泛型定义在方法上{System.out.println("method:"+s);}}class GenericDemo3{public static void main(String[] args){Demo<String> d = new Demo<String>();d.show("haha");d.print(6);d.print("bbs");//访问类的泛型//d.print(true);可以通过d.method("hahhaha");//静态}}

泛型接口

泛型定义在接口上，作为了解

interface Inter<T>{void show(T t);}/*class Demo implements Inter<String>//泛型的类型确定{public void show(String t){System.out.println("show:"+t);}}*/class Demo<T> implements Inter<T>//类型不确定{public void show(T t){System.out.println("show:"+t);}}class GenericDemo4 {public static void main(String[] args) {Demo<Integer> d = new Demo<Integer>();//由调用者来确定类型i.show();/*Demo d = new Demo();d.show("haha");d.show(4);//类型错误*/}}

泛型限定

高级应用

? 通配符，也可理解为占位符，可以传入任意类型
？extends E：可以接受E类型或E的子类型。 上限 <? extends Person>
？ super E ：可以接收E类型或者E的父类型。下限<? super Student>

上限示例：

import java.util.*;class GenericDemo5 {public static void main(String[] args) {ArrayList<Person> a1 = new ArrayList<Person>();a1.add(new Person("aaa1"));a1.add(new Person("aaa2"));a1.add(new Person("aaa3"));print(a1);ArrayList<Student> a2= new ArrayList<Student>();a2.add(new Student("bbb1"));a2.add(new Student("bbb2"));a2.add(new Student("bbb3"));print(a2);//ArrayList<Person> = new ArrayList<Student>();}public static void print(ArrayList<? extends Person> a)//<? extends E>限定为Person和Person的子类{Iterator<? extends Person> it = a.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 Student implements Comparable<Student>//<? super E>{public int compareTo(Person s){this.getName();}}class Comp implements Comparator<Person>//下限{public int compare(Person s1,Person s2){//Person s1 = new Student("hahha");return s1.getName().compareTo(s2.getName());}}//在主函数中的操作中：TreeSet<Student> ts = new TreeSet<Student>(new Comp());//下限可以接收Person及其子类Studentts.add(new Student("aaa1"));ts.add(new Student("aaa2"));ts.add(new Student("aaa3"));

泛型下限时用到了对象的多态性，只能访问父类方法，而不能访问子类特有方法；提高扩展性的同时也会有局限性