黑马程序员-----泛型（第四篇）

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

1．泛型

JDK1.5版本以后出现的新特性，用于解决安全问题，是一个安全机制

好处：

1.       将运行时期可能出现的ClassCastException，转移到了编译时期。更加的方便了程序员解决问题，使得运行期间出现的问题减少，安全。

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

 

二．泛型格式

通过<>来定义要操作的引用数据类型。

使用情况：在集合框架很常见，只要见到<>就要定义泛型。其实<>就是用来接受数据类型的。

      

三．泛型定义在类上

什么时候使用：当类中引用数据类型不确定的时候，早期用object来完成，现在定义泛型来完成扩展。

实例如下。

class Worker
{
}
class Student
{
}
class Util<T>
{
       private T t;
       public void set(T t)
       {
              this.t=t;
       }
       public T get(T t)
       {
              return t;
       }
       public void show(T t)

       {
              System.out.println(t);
       }
}
class test

{
       public static void main(String[] args)
       {
              Util<Worker> u=new Util<Worker>();
              u.set(new Worker());
              u.get(new Worker());
              //泛型指定数据类型
              Util<String> u1=new Util<String>();
              u1.show("haha");
       }
}

4．泛型定义在方法上

什么时候使用：为了让不同的方法可以操作不同类型，类型不确定，将泛型定义在方法上。

实例如下：

//自定义泛型类和泛型方法

class Util
{
       //泛型方法定义
       public <T> void set(T t)
       {
              System.out.println(t);
       }
       public <T> void show(T t)
       {
              System.out.println(t);
       }
}
class test
{
       public static void main(String[] args)
      {
              Util u=new Util();
              u.set("haha");
              u.set(2);
       }
}

5．特殊之处

静态方法不可以访问类上定义的泛型，如果静态方法操作的引用数据不确定可以将泛型定义在方法上。<>放在static之后，返回类型之前。泛型也可定义在接口上。

 

6..泛型的应用

“？”通配符。可以理解为占位符。

泛型的限定：

？ extends E，可以接受E和E的子类型，上限

？ super E，可以接受E类型的父类型，下限

应用实例：

import java.util.*;
class Person<T>
{
       private String name;
       Person(String name )
       {
              this.name=name;
       }
       public String getName()
       {
              return name;
       }
}
class Student extends Person
{     
       Student(String name)
       {
              super(name);
       }
}
class test
{
       public static void main(String[] args)
       {
              ArrayList<Person> a=new ArrayList<Person>();
              a.add(new Person("java1"));
              a.add(new Person("java3"));
              a.add(new Person("java4"));
             ArrayList<Student> a2=new ArrayList<Student>();
              a2.add(new Student("java6"));
              a2.add(new Student("java7"));
              a2.add(new Student("java8")); 
              printcoll(a);
            printcoll(a2);
       }
       /泛型的限定。可以实现person和person的子类
       public static void printcoll(ArrayList<? extends Person> a)
       {
              Iterator<? extends Person> it=a.iterator();
              while(it.hasNext())
              {
                     System.out.println(it.next().getName());
              }        
       }
}