黑马程序员——java基础——泛型

------ Java培训、Android培训、iOS培训、.Net培训、期待与您交流! -------

 

一、泛型

1、泛型简介:

1)泛型:JDK1.5版本以后出现的一个安全机制。JDK1.5的集合类希望在定义集合时,明确表明你要向集合中装入那种类型的数据,无法加入指定类型以外的数据。

2)格式:通过<>来定义要操作的引用数据类型

    如:ArrayList //定义要存入集合中的元素指定为String类型

3)泛型的好处:

    a)将运行时期的问题ClassCastException问题转换成了编译失败,体现在编译时期,程序员就可以解决问题。

    b)避免了强制转换的麻烦。

注意:只要带有<>的类或者接口,都属于带有类型参数的类或者接口,在使用这些类或者接口时,必须给<>中传递一个具体的引用数据类型。

4)泛型技术:其实应用在编译时期,是给编译器使用的技术,到了运行时期,泛型就不存在了。为什么? 

    因为泛型的擦除:也就是说,编辑器检查了泛型的类型正确后,在生成的类文件中是没有泛型的。

5)关于参数化类型的几点说明:

    a)参数化类型与原始类型的兼容性

    第一、参数化类型可引用一个原始类型的对象,编译只是报警告。

        如:Collectioncoll= new Vector();

    第二、原始类型可引用一个参数化类型的对象,编译报告警告

        如:Collectioncoll =new Vector();

    原来的方法接受一个集合参数,新类型也要能传进去。

    b)参数的类型不考虑类型参数的继承关系:

        Vectorv = newVector();//错误的

        不写Object没错,写了就是明知故犯

        Vectorv = newVector();//错误的

    c)编译器不允许创建泛型变量的数组。即在创建数组实例时,数组的元素不能使用参数化的类型

        如:VectorvectorList[]= new Vector[10];//错误的

6)在运行时,如何知道获取的元素类型而不用强转呢?

    泛型的补偿:因为存储的时候,类型已经确定了是同一个类型的元素,所以在运行时,只要获取到该元素的类型,在内部进行一次转换即可,所以使用者不用再做转换动作了。

7)什么时候用泛型类呢?

    当类中的操作的引用数据类型不确定的时候,以前用的Object来进行扩展的,现在可以用泛型来表示。这样可以避免强转的麻烦,而且将运行问题转移到的编译时期。

 

2、通配符

1)当传入的类型不确定时,可以使用通配符”?”。也可以理解为占位符。

    使用通配符的好处是可以不用明确传入的类型,这样在使用泛型类或者泛型方法时,提高了扩张性。

    如:Collection a可以与任意参数化的类型匹配,但到底匹配的是什么类型,只有以后才知道,所以:a=newArrayList和a=newArrayList都可以,但a.add(new Date())或a.add(“abc”)都不行。

2)泛型限定

        对于一个范围内的一类事物,可以通过泛型限定的方式定义,有两种方式:

        a)?extends E:可接收E类型或E类型的子类型;称之为上限。

       如:ArrayListx = new ArrayList();

        b)?super E:可接收E类型或E类型的父类型;称之为下限。

       如:ArrayListx = new ArrayList();

代码示例:

importjava.util.*;

//  父类

classPerson{

       private String name;

       Person(String name){

              this.name= name;

       }

       public String getName(){

              return name;

       }

}

//学生  继承父类

classStudent extends Person{

       Student(String name){

              super(name);

       }

}

class  Demo{

       public static void main(String[] args) {

              ArrayList al = newArrayList();

              al.add(newPerson("abc1"));

              al.add(newPerson("abc2"));

              al.add(newPerson("abc3"));

              printColl(al);//父类对象的元素集合可以调用

 

              ArrayList al1 = newArrayList();

              al1.add(newStudent("abc--1"));

              al1.add(newStudent("abc--2"));

              al1.add(newStudent("abc--3"));

              printColl(al1);  //子类对象的元素集合也可以调用

       }

//定义一个上限的泛型方法

publicstatic void printColl(Collection al){

              Iteratorit = al.iterator();

              while(it.hasNext()){

                     System.out.println(it.next().getName());

              }

       }

}

 

3、泛型在代码中的体现

1)泛型类:

    若类实例对象中要使用到同一泛型参数,即这些地方引用类型要保持同一个实际类型时,这时候就要采用泛型类型的方式进行定义,也就是类级别的泛型。

    语法格式:

    classUtils{

            private XX s;

            public void setxx(XX s){

                this.s=s;

            }

            public XX getXX() {

                 return s;

            }

       }

注意:

       a)在对泛型进行参数化时,类型参数的实例必须是引用类型,不能是基本类型。

       b)当一个变量被声明为参数时,只能被实例变量和方法调用(还有内嵌类型),而不能被静态变量和静态方法调用,因为静态成员是被所有参数化的类共享的,所以静态成员不应该有类级别的类型参数。

 

2)泛型方法:

    为了让不同方法可以操作不同类型,而且类型还不确定。那么可以将泛型定义在方法上。其中方法中上的泛型可以不和类泛型相同。

    特殊之处:静态方法不可以访问类上定义的泛型。如果静态方法操作的应用数据类型不确定,可以将泛型定义在方法上。

    泛型方法的特点:

        a)位置:用于放置泛型的类型参数的<>应出现在方法的其他所有修饰符之后和在方法的返回类型之前,也就是紧邻返回值之前,按照惯例,类型参数通常用单个大写字母表示。

        b)只有引用类型才能作为泛型方法的实际参数。

        c)除了在应用泛型时可以使用extends限定符,在定义泛型时也可以使用extends限定符。例如,Class.getAnnotation()方法的定义。并且可以用&来指定多个边界,如 void method(){}。 

        d)普通方法、构造函数和静态方法中都可以使用泛型。

        e)可以用类型变量表示异常,称之为参数化的异常,可用于方法的throws列表中,但是不能用于catch子句中。

        f)在泛型中可同时有多个类型参数,在定义它们的<>中用逗号分开。例如:

               publicstatic V getValue(K key) { return map.get(key);}

 

代码示例:

class Tool { //定义在类上的泛型

private Q obj;

public  void setObject(Q obj) {

this.obj = obj;

}

public Q getObject() {

return obj;

}

}

public  void method(W w) {//定义在方法上的泛型

System.out.println("method:"+w);

}

//静态方法上的泛型:静态方法无法访问类上定义的泛型。如果静态方法操作的引用数据类型不确定的时候,必须要将泛型定义在方法上。

public static  void function(Q t) {

System.out.println("function:"+t);

}

interface Inter {//泛型接口.

void show(T t);

}

class InterImpl implements Inter {

public void show(R r) {

System.out.println("show:"+r);

}

}

4、泛型的细节:

1)泛型到底代表什么类型取决于调用者传入的类型,如果没传,默认是Object类型;

2)使用带泛型的类创建对象时,等式两边指定的泛型必须一致;

    原因:编译器检查对象调用方法时只看变量,然而程序运行期间调用方法时就要考虑对象具体类型了;

3)等式两边可以在任意一边使用泛型,在另一边不使用(考虑向后兼容);

    如:ArrayList al = new ArrayList();  //错,要保证左右两边的泛型具体类型一致就可以了,这样不容易出错。

      ArrayList al = new ArrayList();

    al.add("aa");  //错,因为集合具体对象中既可存储String,也可以存储Object的其他子类,所以添加具体的类型对象不合适,类型检查会出现安全问题。 ?extends Object 代表Object的子类型不确定,怎么能添加具体类型的对象呢?

    public static void method(ArrayList al) {

    al.add("abc");  //错只能对al集合中的元素调用Object类中的方法,具体子类型的方法都不能用,因为子类型不确定。

    }

 


你可能感兴趣的:(日记,java,黑马程序员,泛型)