黑马程序员_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/