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

——- android培训、java培训、期待与您交流！ ———-

泛型

一 初识泛型

泛型:JDK1.5版本以后出现的新特性,用于解决安全问题 是一个类型安全机制
- JDK1.5的集合类希望在定义集合时，明确表明你要向集合中装入那种类型的数据，无法加入指定类型以外的数据。
- 泛型是提供给javac编译器使用的可以限定集合中的输入类型说明的集合时，会去掉“类型”信息，使程序运行效率不受影响，对参数化的泛型类型，getClass()方法的返回值和原始类型完全一样。
- 使用泛型集合，可以将一个集合中的元素限定为一个特定类型，集合中只能存储同一个类型的对象，这样更安全；并且当从集合获取一个对象时，编译器也可以知道这个对象的类型，不需要对对象进行强制类型转换，这样更方便。泛型就是把原来的类名进行了延长！
- 泛型的格式
- 通过<>来定义要操作的引用数据类型
如：ArrayList //定义要存入集合中的元素指定为String类型

• 泛型的好处
  
  1. 将运行时期出现的问题ClassCastException, 转移到编译时期
  2. 避免了强制类型转换的麻烦

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

二 在使用java提供的对象时, 什么时候写泛型呢?

通常在集合框架中很常见，只要见到<>就要定义泛型
其实<>就是用来接收类型的，当使用集合时,将集合中要存储的数据类型作为参数传递到<>中即可

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

三 泛型的符号解释

如：ArrayList类和ArrayList

1. ArrayList整个称为泛型类型
2. ArrayList中的E称为类型变量或类型参数
3. 整个ArrayList称为参数化类型
4. ArrayList中的Integer称为类型参数的实例或实际类型参数
5. ArrayList中的<>称为typeof
6. ArrayList称为原始类型

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

四 泛型基本应用

泛型在比较器中的使用

import java.util.*;
class GenericDemo2
{
    public static void main(String[] args)
    {
        //带泛型的TreeSet
        TreeSet<String> ts = new TreeSet<String>(new LenComparator());

        ts.add("abcd");//往容器里面添加元素
        ts.add("cc");
        ts.add("cba");
        ts.add("aaa");
        ts.add("zz");
        ts.add("hahhaha");
        //迭代器
        Iterator<String> it = ts.iterator();
        while(it.hasNext())
        {
            String s = it.next();//因为迭代器已经带泛型,因此不用在强转
            System.out.println(s);
        }
    }   
}

//定义自己的比较器
class LenComparator implements Comparator<String>
{
    public int compare(String o1,String o2)
    {
        int num = new Integer(o1.length()).compareTo(new Integer(o2.length()));
        if(num==0)
            return o2.compareTo(o1);
            return num;
    }
}

运行结果：

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

总结:
从上面的代码可以看出来, 引入泛型给我们带来的最大的好处就是 避免了强制类型转换的麻烦, 让程序的健壮性得以提高. 提高的代码的安全性.

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

五 泛型类

1. 什么时候定义泛型类?

   • 当类中要操作的引用数据类型不确定的时候,我们就要引入泛型类.
   • 早期定义Object来完成扩展, 现在定义泛型来完成扩展

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

3. 定义泛型类的格式:

  class Utils<XX>
        {
             private XX s;
             public void setxx(XX s)
             {
                 this.s=s;
             }
             public XX getXX()
             {
                  return s;
             }
        }

下面是一个小例子:

class GenericDemo3
{
    public static void main(String[] args)
    {
        Utils<Worker>u = new Utils<Worker>();

        u.setObject(new Worker());
        Worker w = u.getObject();
    }
}

class Worker
{

}
class Student
{

}

//泛型类
class Utils<QQ>
{
    private QQ q;
    public void setObject(QQ q)
    {
        this.q = q;
    }

    public QQ getObject()
    {
        return q;
    }
}

运行结果.

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

引入了泛型类: 避免了一下以下情况的发生,将运行时期出现的问题ClassCastException, 转移到编译时期.提高了代码的安全性
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

引入泛型类之前:

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

引入泛型类之后:

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

总结:

1. 在对泛型进行参数化时，类型参数的实例必须是引用类型，不能是基本类型。
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);
    }
}

public class GenericDemo4
{
    public static void main(String[] args)
    {   
        Demo d = new Demo();
        d.show("haha");
        d.show(new Integer(4));
        d.print("hehe");
    }
}

运行结果:

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

总结:

1. 类型定义在方法上, 方法的类型由参数传递的时候确定.
2. 泛型方法比泛型类更方便一些.

注意:
静态泛型:
静态方法不可以访问类上定义的泛型.
如果静态方法操作的数据类型不确定,可以将泛型定义在方法上.
类型<>必须定义在static关键字之后 返回值之前

如下面的代码片:

    //类型<>必须定义在static关键字之后 返回值之前
    public static<W> void method(W w)
    {
        System.out.println("method:"+t);
    }

• 知识点:
  泛型定义在接口上:

/*
    泛型定义在接口上
*/
interface Inter<T>
{
    void show(T t);
}

class InterSub implements Inter<String>
{
    public void show(String t)
    {
        System.out.println("show:"+t);
    }
}

class InterSub_1<T> implements Inter<T>
{
    public void show(T t)
    {
        System.out.println("show:"+t);
    }
}

public class GenericDemo5
{
    public static void main(String[] args)
    {
        InterSub_1<Integer> is = new InterSub_1<Integer>();
        is.show(3);
    }
}

运行结果:

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

七 泛型限定

?: 占位符, 也可以理解为通配符
泛型限定:
- ? Extends E 可以接受E或者E的子类型 上限
- ? super E 可以接受E类型或者E的父类型 下限定

示例代码:

import java.util.*;
class GenericDemo6
{
    public static void main(String[] args)
    {
        ArrayList<String> al = new ArrayList<String>();

        al.add("java01");
        al.add("java02");
        al.add("java03");

        ArrayList<Integer> al2 = new ArrayList<Integer>();

        al2.add(1);
        al2.add(2);
        al2.add(3);

        printColl(al);
        printColl(al2);

    }
    public static void printColl(ArrayList<?> al)
    {
        Iterator<?> it = al.iterator();
        while(it.hasNext())
        {
            System.out.println(it.next());
        }
    }
}

运行结果:

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

总结：

1. 通配符可以解决当传入的类型不确定时，可以不用明确传入的类型，这样在使用泛型类或者泛型方法时，提高了扩展性。

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
——- android培训、java培训、期待与您交流！ ———-