黑马程序员—泛型

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

1.什么是泛型？
泛型：JDK1.5版本以后出现新特性，用于解决安全问题，是一个类型安全机制。
1、JDK1.5版本以后出现的新特性。用于解决安全问题，是一个类型安全机制。
2、JDK1.5的集合类希望在定义集合时，明确表明你要向集合中装入那种类型的数据，无法加入指定类型以外的数据。
3、泛型是提供给javac编译器使用的可以限定集合中的输入类型说明的集合时，会去掉“类型”信息，使程序运行效率不受影响，对参数化的泛型类型，getClass()方法的返回值和原始类型完全一样。
4、由于编译生成的字节码会去掉泛型的类型信息，只要能跳过编译器，就可以往某个泛型集合中加入其它类型的数据，如用反射得到集合，再调用add方法即可。
5、没有使用泛型时，只要是对象，不管是什么类型的对象，都可以存储进同一个集合中。使用泛型集合，可以将一个集合中的元素限定为一个特定类型，集合中只能存储同一个类型的对象，这样更安全；并且当从集合获取一个对象时，编译器也可以知道这个对象的类型，不需要对对象进行强制类型转换，这样更方便。泛型就是把原来的类名进行了延长！在JDK 1.5中，你还可以按原来的方式将各种不同类型的数据装到一个集合中，但编译器会报告unchecked警告。

2.泛型的好处：
1.将运行时期出现的问题ClassCastException，转移到了编译时期。
方便于程序员发现问题并解决问题，让运行时期问题减少，安全系数变高。

2.避免了强制转换麻烦。

3.泛型的格式：
通过<>来定义要操作的引用数据类型。
在使用java提供的对象时，什么时候写泛型呢？
通常在集合框架中很常见，只要见到<>就要定义泛型。
其实<>就是用来接收类型的。
当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可。

演示代码1：

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

        al.add("java00");
        al.add("asd");
        al.add("1234");
        //al.add(1);//al.add(new Integer(4));

        Iterator<String> it = al.iterator(); 
        //迭代器也要声明类型
        while (it.hasNext())
        {
            String s = it.next();
            System.out.println(s+":"+s.length());
        }
    }
}

演示代码2：

import java.util.*;
class GenericDemo
{
    public static void main(String[] args)
    {
        TreeSet<String> ts = new TreeSet<String>(new LenComparator());
        ts.add("abcd");
        ts.add("abcd");
        ts.add("cc");
        ts.add("bb");
        ts.add("cba");
        ts.add("cbb");
        ts.add("z");
        ts.add("hahaha");
    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)
    {
        /*
        if(!(o1 instanceof String))
            throw new RuntimeException("不是字符串对象");
        if(!(o2 instanceof String))
            throw new RuntimeException("不是字符串对象");
        */
        int num = new Integer(o1.length()).compareTo(new        Integer(o2.length()));
                if(num == 0)
                    return o1.compareTo(o2);
                return num;
    }

}

4.泛型类：
什么时候使用泛型类？
当类中要操作的引用数据类型不确定的时候，
早期定义Object来完成拓展，
需要强制转换类型，而且强制转换异常编译时发现不了，运行时候才能发现，安全性不高。

现在定义泛型来完成扩展。
不需要强制转换类型，强制转换异常编译时就能发现，程序员可以及时发现并且更改，安全性高。

泛型前：
class Tool
{
private Object obj;
public void setObject(Object obj)
{
this.obj = obj;
}
public Object getObject()
{
return obj;
}
}

泛型后：
class Utils
{
private QQ q;
public void setObject(QQ q)
{
this.q = q;
}
public QQ getObject()
{
return q;
}

}

class GenericDemo1
{
public static void main(String[] args)
{
/*
Tool t = new Tool();
t.setObject(new Worker());
Worker w = (Worker)t.getObject();
*/
Utils u = new Utils();
u.setObject(new Worker());
Worker w =u.getObject();
}
}

5. 泛型方法：
书写规范：泛型如果定义在方法上，写在返回值类型前面，修饰符后面。

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

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

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

静态方法泛型：
因为静态都是先加载后有对象的。

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

演示代码：

class Demo<T>
{
    public void show(T t)//必须跟着类的数据类型走。
    {
        System.out.println("show:"+t);
    }
    public <Q> void print(Q q)
    {
        System.out.println("print:"+q);
    }
    public static <W> void method(W w)
    {
        System.out.println("method:"+w);
    }
}
class GenericDemo2
{
    public static void main(String[] args) 
    {
        Demo<String> d = new Demo<String>();
        d.show("haha");
        //d.show(135);
        d.print("hehe");
        d.print(new Integer(135));
        d.method("heihei");
        d.method(135);
    }
}

6. 通配符：
?通配符，也可以理解为占位符。
泛型的限定：
? extends E：可以接收E类型或者E的子类型。上限限定。
? super E:可以接收E类型或者E的父类型。下限限定。

泛型限定：是用于泛型扩展用的。

演示代码：

import java.util.*;
class GenericDemo4
{
    public static void main(String[] args)
    {
        ArrayList<Person> al = new ArrayList<Person>();
        al.add(new Person("abc1"));
        al.add(new Person("abc2"));
        al.add(new Person("abc3"));
        ArrayList<Student> all = new ArrayList<Student>();
        all.add(new Student("abc4"));
        all.add(new Student("abc5"));
        all.add(new Student("abc6"));
        printColl(al);
        printColl(all);
        //ArrayList<Person> al = new ArrayList<Student>();
        //Error,这种写法是错误的，要两边一致。
        }
    public static void printColl(ArrayList< ? extends Person> al)
    {
            Iterator< ? extends Person> it = al.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);
    }
}

7. 类型参数的类型推断
1、编译器判断范型方法的实际类型参数的过程称为类型推断，类型推断是相对于知觉推断的，其实现方法是一种非常复杂的过程。
2、根据调用泛型方法时实际传递的参数类型或返回值的类型来推断，具体规则如下：
1）当某个类型变量只在整个参数列表中的所有参数和返回值中的一处被应用了，那么根据调用方法时该处的实际应用类型来确定，这很容易凭着感觉推断出来，即直接根据调用方法时传递的参数类型或返回值来决定泛型参数的类型，例如：
swap(new String[3],3,4)
——> static voidswap(E[] a, int i, int j)
2）当某个类型变量在整个参数列表中的所有参数和返回值中的多处被应用了，如果调用方法时这多处的实际应用类型都对应同一种类型来确定，这很容易凭着感觉推断出来，例如：
add(3,5)
——> static T add(T a, T b)
3）当某个类型变量在整个参数列表中的所有参数和返回值中的多处被应用了，如果调用方法时这多处的实际应用类型对应到了不同的类型，且没有使用返回值，这时候取多个参数中的最大交集类型，例如，下面语句实际对应的类型就是Number了，编译没问题，只是运行时出问题：
fill(new Integer[3],3.5f)
——> static void fill(T[] a, T v)
4）当某个类型变量在整个参数列表中的所有参数和返回值中的多处被应用了，如果调用方法时这多处的实际应用类型对应到了不同的类型，并且使用返回值，这时候优先考虑返回值的类型，例如，下面语句实际对应的类型就是Integer了，编译将报告错误，将变量x的类型改为float，对比eclipse报告的错误提示，接着再将变量x类型改为Number，则没有了错误：
intx =(3,3.5f)
——> static T add(T a, T b)
5）参数类型的类型推断具有传递性，下面第一种情况推断实际参数类型为Object，编译没有问题，而第二种情况则根据参数化的Vector类实例将类型变量直接确定为String类型，编译将出现问题：
copy(newInteger[5],new String[5])
——> static void copy(T[] a,T[] b);
copy(newVector(), new Integer[5])
——> static void copy(Collection a , T[] b);

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