java基础11 泛型

泛型

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

1、泛型的意义

(1)、未加泛型的集合会出现安全隐患,使用泛型后集合中只能添加规定的元素，否则编译会出错。问题从运行时期转移到了编译时期。

(2)、避免了强制转换。

public static void main(String[] args){

       ArrayList<String> al = new ArrayList() ;//加泛型

       al.add(“ abc 01 ”) ;

       al.add(“ abc 02 ”) ;

       al.add(“ abc 03 ”) ;

       al.add( 4 ) ;

       Iterator<String> it = al.iterator() ;//加泛型

       while(it.hasNext()){

       String s = it.next() ;

       System.out.println(s + ”:  ” +s.length()) ;

}

}

如果没有加泛型，语句add(4) ;在运行时会出现类型转换异常 ClassCastException 。

2、泛型的使用

class GenericDemo{

       public static void main(String[] args ){

              TreeSet<String > ts = new TreeSet<String> (new LenComparator()) ;

             

              ts.add(“ abcd ”) ;

       ts.add(“ cccc ”) ;

       ts.add(“ aaaa ”) ;

       Iterator<String > it = ts.iterator() ;

       while(it.hasNext()){

       String s =it.next() ;

       System.out.println(s) ;

}

}

}

//按长度排序的比较器

class LenComparator implements Comparator<String>{

       public int compara(String s1 ,String s2){

       int num = new Integer(o2.length()).compareTo(new Integer(o1.length()))

       if(num == 0){

       return 02.compareTo(o1) ;

return num ;

}

}

}

3、自定义带泛型的类

什么时候使用泛型类

当类中药操作的引用数据类型不确定的时候，可以定义泛型类。

class Worker{

}

class Student{

}

class Utils<QQ >{

       private QQ q ;

       public void setObject(QQ q){

       this.q = q ;

}

public QQ getObject(){

       return q ;

}

}

class GenericDemo{

       public static void main(){

       Utils<> u = new Utils<Worker>() ;

       u.setObject(new Worker) ;

       Worker w = u.getObject() ;

}

}

 

4、自定义泛型方法

(1)、泛型定义在类上

class demo<T>{

       public void show(T t){

       System.out.println(“show: ”+ t ) ;

}

public void print(T t){

       System.out.println(“print : ”+ t )

}

}

泛型类定义的泛型，在整个类中有效，如果被方法使用，那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。

为了让不同方法可以操作不同类型，而且类型还不确定。那么可以将泛型定义在方法上。

(2)、定义在方法上

class Demo{

       public <T> void show(T t){

       System.out.println(“show: ”+ t ) ;

}

public <Q> void print(Q q){

System.out.println(“print : ”+ q) ;

}

}

class Demo2<T>{

       public void show (T t){

       System.out.println(“show: ”+ t ) ;

}

       puclic <Q> void print(Q q){

System.out.println(“print : ”+ q) ;

}

 

}

 

4、静态方法类型

       静态方法不可以访问类上定义的泛型，如果静态方法操作的引用数据类型不确定，可以将泛型定义在方法上。

       如class<W>{

       public static void method(W w){

       System.out.println(“method: ”+ t ) ;

}

}

上面的定义是不可以的。因为静态加载的时候，对象还没有加载。

class{

       pulic static < W > void method( W w){

       System.out.println(“method: ” +t ) ;

}

}

5、泛型定义在接口上

interface Inter<T>{

       void show(T t) ;

}

class InterImpl implements Inter<String>{

       public void show(String st){

}

}

6、泛型限定

(1)、通配符（占位符 ） ：？

(2)、泛型限定

ArrayList<Person> al = new ArrayList<Student> () ;

ArrayList< Student > al = new ArrayList< Person > () ; 这样的定义是不被允许的。

向上限定： <? extends E>

向下限定： <? super E>

7、张孝祥视屏中泛型重点截图

泛型的去类型化：泛型是给编译器看的，运行时，泛型限定的类型就被去掉了。用反射的的方法向集合中添加元素