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

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

 

一、泛型

1、泛型简介：

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

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

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

3）泛型的好处：

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

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

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

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

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

5）关于参数化类型的几点说明：

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

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

        如：Collection<String>coll= new Vector();

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

        如：Collectioncoll =new Vector<String>();

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

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

        Vector<String>v = newVector<Objec>();//错误的

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

        Vector<Objec>v = newVector<String>();//错误的

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

        如：Vector<Integer>vectorList[]= new Vector<Integer>[10];//错误的

6）在运行时，如何知道获取的元素类型而不用强转呢？

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

7）什么时候用泛型类呢？

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

 

2、通配符

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

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

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

2）泛型限定

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

        a）?extends E：可接收E类型或E类型的子类型；称之为上限。

       如：ArrayList<?extends Number>x = new ArrayList<Integer>();

        b）?super E：可接收E类型或E类型的父类型；称之为下限。

       如：ArrayList<?super Integer>x = new ArrayList<Number>();

代码示例：

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<Person> al = newArrayList<Person>();

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

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

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

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

 

              ArrayList<Student> al1 = newArrayList<Student>();

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

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

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

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

       }

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

publicstatic void printColl(Collection<? extends Person> al){

              Iterator<? extends Person>it = al.iterator();

              while(it.hasNext()){

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

              }

       }

}

 

3、泛型在代码中的体现

1）泛型类：

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

    语法格式：

    classUtils<XX>{

            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()方法的定义。并且可以用&来指定多个边界，如<Vextends Serializable& cloneable> void method(){}。 

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

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

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

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

 

代码示例：

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

private Q obj;

public  void setObject(Q obj) {

this.obj = obj;

}

public Q getObject() {

return obj;

}

}

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

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

}

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

public static <Q> void function(Q t) {

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

}

interface Inter<T> {//泛型接口.

void show(T t);

}

class InterImpl<R> implements Inter<R> {

public void show(R r) {

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

}

}

4、泛型的细节：

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

2）使用带泛型的类创建对象时，等式两边指定的泛型必须一致；

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

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

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

      ArrayList<? extends Object> al = new ArrayList<String>();

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

    public static void method(ArrayList<? extends Object> al) {

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

    }