黑马程序员——【学习笔记】集合——泛型

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

1 泛型

泛型是JDK1.5以后出现的新特性，他可以解决安全问题，是一个安全机制。

1.1 泛型的利弊

好处

①将运行使其出现的问题ClassCastException转移到编译时期，方便于程序员解决问题。让运行时期问题减少，安全。

②避免了频繁的强制转换的麻烦。

缺点

①增加了书写的麻烦。

PS：在1.5之前，都只能靠程序员的主观判断，泛型的出现，从客观上限定了可以存的内容。

1.2 格式

泛型格式：通过<>来定义要操作的引用数据类型

1.3 使用场合

在使用java提供的对象时，什么时候写泛型呢？

通常在集合框架中常用，只要见到<>，就要定义泛型。

比如Collection<E>，E里限定的是什么，以后add(E e)里就只能加什么。

其实<>就是用来接收类型的，当使用集合时，将集合中要存储的数据类型作为参数类型传入其中即可。

泛型可以定义在类上，可以定义在方法上，也可以定义在接口上。具体那些类或方法或接口上，需要查询API。比如equals的参数是Object，但就是不能泛型。

public class Day18{
	public static void main(String[] args){
		TreeSet<String> ts = new TreeSet<String>(new LenComparator());
		ts.add("heiheiaaaa01");
		ts.add("xixiaaa02");
		ts.add("heheaa03");
		ts.add("wuwuaaaaaaaa04");
		ts.add("wawaaaaa05");
		Iterator<String> i = ts.iterator();
		while(i.hasNext())
			System.out.println(i.next());//按TreeSet自然顺序排序	
	}
}
class LenComparator implements Comparator<String>{
	public int compare(String o1,String o2){//因为要覆写Comparator，需要强制转换
//		String s1 = (String)o1;
//		String s2 = (String)o2;
		int num = new Integer(o1.length()).compareTo(new Integer(o2.length()));
		if (num==0)
			return o1.compareTo(o2);
		return num;
	}
}

heheaa03
xixiaaa02
wawaaaaa05
heiheiaaaa01
wuwuaaaaaaaa04

2 泛型类

泛型出现前做法：用一个可以操作所有Object的工具类，可以处理所有类型，但是接收的时候必须用强制转型操作。

class Day18{
	public static void main(String[] args){
		Tool t = new Tool();
		t.setObject(new Worker());
		Worker w = (Worker)t.getObject();
	}
}
class Worker{

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

}

泛型出现后做法：创建泛型类，限定一个视作类型的变量，调用的时候就可以事先限定可传入的类型。接下来就不用频繁强转操作。

class Day18{
	public static void main(String[] args){
//		Tool t = new Tool();
//		t.setObject(new Worker());
//		Worker w = (Worker)t.getObject();
		
		Tool2<Worker> t = new Tool2<Worker>();
		t.setObject(new Worker());
		Worker w = t.getObject();
	}
}
class Worker{

}
//class Tool{
//	private Object obj;
//	public void setObject(Object obj){
//		this.obj=obj;
//	}
//	public Object getObject(){
//		return obj;
//	}	
//}
class Tool2<T>{
	private T t;
	public void setObject(T t){
		this.t=t;
	}
	public T getObject(){
		return t;
	}	
}
class Student{

}

这个Tool2类就是泛型类。

2.1 什么时候定义泛型类？

当类中需要操作的引用数据类型不确定的时候，早期定义Object来完成扩展，但是需要一系列强转。

现在就定义泛型类，之后运用泛型来扩展。

3 泛型方法

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

为了让不同方法可以操作不同类型，而且类型还不确定，

那么可以将类型定义在方法上。

class Demo{
	public <T> void show(T t){
		System.out.println("show:"+t);
	}
	public <T> void print(T t){
		System.out.println("print:"+t);
	}
}
class Day18{
	public static void main(String[] args){
		Demo d = new Demo();
		d.show("haha");
		d.show(new Integer(4));
		d.print("heihei");
	}
}

show:haha
show:4
print:heihei

PS：以上程序中show方法和print方法的类型T互不干涉，因为T只是一个变量，只作用与自身所属的方法范围内。

一个类既可以本身是泛型类同时内含泛型方法，并不重复

静态方法的类型：因为泛型类的泛型是在建立对象的时候确定的，而静态与类绑定不与类的 实例对象有干系，所以静态方法不可以访问类自定义的泛型。如果静态方法操作的应用数据类型不确定，要定义在方法上。

class Demo<T>{
	public <T> void show(T t){
		System.out.println("show:"+t);
	}
	public <T> void print(T t){
		System.out.println("print:"+t);
	}
	public static <T> void method(T t){
		System.out.println("method:"+t);
	}
}
class Day18{
	public static void main(String[] args){
		Demo d = new Demo();
		d.show("haha");
		d.show(new Integer(4));
		d.print("heihei");
	}
}

4 泛型接口
泛型定义在接口上。

<pre name="code" class="java">interface Inter<T>{
<span style="white-space:pre">	</span>public abstract void show(T t);
}
class Inter1 implements Inter<String>{
<span style="white-space:pre">	</span>public void show(String s){
<span style="white-space:pre">		</span>System.out.println("show:"+s);
<span style="white-space:pre">	</span>}
}
class Inter2<T> implements Inter<T>{//子类也不知道将来调用什么类型，所以子类也是<T>
<span style="white-space:pre">	</span>public void show(T t){
<span style="white-space:pre">		</span>System.out.println("show:"+t);
<span style="white-space:pre">	</span>}
}
class Day18{
<span style="white-space:pre">	</span>public static void main(String[] args){
<span style="white-space:pre">		</span>Inter1 i = new Inter1();
<span style="white-space:pre">		</span>i.show("haha");
<span style="white-space:pre">		</span>Inter2<String> i2 = new Inter2<String>();//创建对象时做出限定
<span style="white-space:pre">		</span>i2.show("wawa");
<span style="white-space:pre">	</span>}
}

5 泛型限定

通配符“？”的使用

public class Day18{
	public static void main(String[] args){
		ArrayList<String> al = new ArrayList<String>();
		al.add("haha");
		al.add("xixi");
		al.add("hehe");
		ArrayList<Integer> all = new ArrayList<Integer>();
		all.add(3);
		all.add(8);
		all.add(10);
		print(al);
		print(all);
		System.out.println("--------------");
		print1(al);
		print1(all);
	}
	public static void print(ArrayList<?> al){
		Iterator<?> i = al.iterator();
		while(i.hasNext()){
			System.out.println(i.next());
		}
	}
	public static <T> void print1(ArrayList<T> al){
		Iterator<T> i = al.iterator();
		while(i.hasNext()){
			T t= i.next();
			System.out.println(t);
		}			
	}
}

？ extends E ：可以接收E类型或者E的子类型。上限。

？ super E：可以接收E类型或者E的父类型。下限。