黑马程序员_JAVA学习日记_JAVA中的泛型

黑马程序员-学习日记

 

黑马程序员_JAVA学习日记_JAVA中的泛型

 

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

 

一：泛型概述：

   泛型是JDK1.5版本以后出现的一个安全机制；泛型其实给编译器使用的。

   泛型的表现形式就是<>

   集合中存储了不同类型的对象，取出时，容易在运行时时期发生ClassCastExcepti类型转换异常；为了避免这个问题的发生;我们在存储的时候就明确了集合要操作的数据类型，这样取出就没有问题了，就需要在定义集合时，就立刻明确元素的类型。其实借鉴于数组；可以通过<>来明确元素的类型。

二：泛型的好处：

 1，将运行时期出现的ClassCastException问题，转移到了编译时期。

 2，避免了强制转换的麻烦。

三：编码时，什么时候使用泛型呢？

  只要用到的类或者接口的旁边有<>时，就要明确具体类型。泛型的使用其实就是 给<>传递实际参数，而这个参数就是一个具体引用数据类型。

举例：

importjava.util.*;

class  GenericDemo{

public static voidmain(String[] args) {            

ArrayList<String>al = new ArrayList<String>();

al.add("ahah");

al.add("heheaa");

//al.add(3);相当于al.add(new Integer(3));因为jdk1.5以后有自动装箱机制。所以会自动把3封装成对象。

Iterator<String>it = al.iterator();

while(it.hasNext()){

String s =it.next();

System.out.println(s+"::"+s.length());

}

}

}

四：泛型在自定义对象(类)中的应用：

现在要Person对象进行年龄排序。使用TreeSet集合。

importjava.util.*;

class GenericDemo2{

    public static void main(String[] args) {

       TreeSet<Person> ts = newTreeSet<Person>(new CompareByName());

       //HashSet<Person> ts = newHashSet<Person>();

       ts.add(new Person("abc1",21));

       ts.add(new Person("abc0",20));

       ts.add(new Person("abc0",20));

       ts.add(new Person("abc4",24));

       ts.add(new Person("abc3",28));

       Iterator<Person> it= ts.iterator();

       while(it.hasNext()){

              Person p = it.next();

              System.out.println(p.getName()+"....."+p.getAge());

       }

    }

}

classCompareByName implements Comparator<Person>{

      public int compare(Person p1,Person p2){

       int temp =p1.getName().compareTo(p2.getName());

       returntemp==0?p1.getAge()-p2.getAge():temp;

       }

}

class Personimplements Comparable<Person>{

   private String name;

       private int age;

       Person(String name,int age){

       this.name = name;

       this.age = age;

       }

       public int compareTo(Person p){        

       int temp = this.age-p.age;

       returntemp==0?this.name.compareTo(p.name):temp;

       }

       public int hashCode(){

       final int NUM = 34;

       return name.hashCode()+age*NUM;

       }

       public boolean equals(Object obj){

       if(this==obj)

              return true;

       if(!(obj instanceof Person))

              return false;

       Person p = (Person)obj;

       return this.name.equals(p.name)&& this.age==p.age;

      }     

       public String getName(){

              return name;

       }

       public int getAge(){

              return age;

       }

       public String toString(){

              return name+"::"+age;

       }

}

五：泛型类概述：

  1.什么时候使用泛型类呢？

  当类要操作的引用数据类型不确定的时候，可以使用泛型来定义，也就是定义一个类型参数。具体要操作什么类型的对象，有使用该类的使用者来明确，将具体的类型做为实际参数传递给<>.    

   2.当泛型定义在类上；该泛型作用于整个类。当该类建立对象时，就明确了具体类型；那么凡是使用了类上定义的泛型的方法，操作的类也就固定了。

 

六：泛型方法：

1.当方法中操作的应用数据类型不确定，而且和对应的对象执行的类型也不一定一致；这时就将泛型定义在方法上。

2.当类中定义static方法时，静态方法是不可以直接访问类上的泛型，因为类上的泛型只有通过建立对象才可以明确具体类型；所以静态方法如果操作的引用数据类型不确定，只能将泛型定义在方法上。

在静态方法上定义泛型，必须定义在static关键字之后。

如下举例：

classTool<T>{

       public void show(T t){

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

       }

       public <Q> void print(Q q)// 在print方法定义了一个泛型变量 Q.{

              System.out.println("print:"+q);

       }

       public static <W> void method(W t){

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

       }

}

class GenericDemo4{

       public static void main(String[] args) {

              Tool<String> t = newTool<String>();

              //t.show("haha");

              t.print("hehe");

              t.print(new Integer(3));

              Tool.method("kkk");

              Tool.method(new Integer(3));

              /*

              Tool<String> t =newTool<String>();

              t.show("haha");

              t.print(new Integer(4));

              Tool<Integer> t1 = newTool<Integer>();

              t1.print(new Integer(4));

              t1.show("haha");

              */

       }

}

七：泛型限定：

1.泛型：通配符:?  代表任意类型。

2．定义集合要保证左右两边的类型一致。两边只有一边定义泛型，也是可以支持，至少新老版本兼容。但是一样会出现，安全提示信息。

3.在泛型方法中，不可以使用具体类型的方法，最多只能使用Object类中方法。

4.传入的集合有一个特点，就是元素类型，要么是Person，要么是Person的子类型。这时可以使用泛型的高级应用，泛型的限定。

5.定义T只能固定一种类型，定义？可以是任意类型。只想操作Person或者Person的子类类型。

6.使用泛型的限定：? extends E:接收E类型或者E的子类型。

?super E:接收E类型或者E的父类型。

 

------- android培训、java培训、期待与您交流！ ----------　　详细请查看：http://edu.csdn.net/heima/