黑马程序员------集合框架（No.4）（泛型、泛型类、泛型方法、泛型接口、泛型限定）

---------------------- ASP.Net+Android+IO开发S、.Net培训、期待与您交流！ ---------------------- 

 

泛型

 

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

好处：

1.将运行是出现的问题ClassCastException，转移到了编译时期，方便于程序员解决问题。让运行事情问题减少，安全。

2.避免了强制转换的问题。

 

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

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

 

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

其实<>就是用来接收类型的。

当使用集合事，将集合中要存储的数据类型作为参数传递到<>中即可。

import java.util.*;
class GenericDemo{
	public static void main(String[] args){
		TreeSet<String> ts = new TreeSet<String>(new myComp());
		ts.add("sda");
		ts.add("a");
		ts.add("cdsc");
		ts.add("fsdff");
		ts.add("sas");
		ts.add("ecccwadc");
		
		Iterator<String> it = ts.iterator();
		while(it.hasNext()){
			String s = it.next();
			System.out.println(s);
		}
	}
}
class myComp implements Comparator<String>{
	public int compare(String str1,String str2){
		//字符长的放在后面
		int num = new Integer(str1.length()).compareTo(new Integer(str2.length()));
		if(num==0){
			//默认顺序，自然顺序。
			return str1.compareTo(str2);
		}
		return num;
	}
}

 

泛型类

什么时候定义泛型类

当类中要操作的引用数据类型不确定的时候；早期定义Object来完成扩展，现在定义类型来完成扩展。

import java.util.*;
class Worker{
}
class Student{
}
class Utils<QQ>{
	private QQ qq;
	public void setObject(QQ qq){
		this.qq = qq;
	}
	public QQ getObject(){
		return qq;
	}
}
class GenericDemo2{
	public static void main(String[] args){
		Utils<Worker> u = new Utils<Worker>();
		Worker w = new Worker();
		u.setObject(w);
		System.out.println(u.getObject());
	}
}

 

泛型方法

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

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

import java.util.*;
/*
泛型类定义的泛型，在整个类中有效。如果被方法使用，那么泛型类的对象明确要操作的
具体类型后，所有要操作的类型就已经固定了。为了让不同方法可以操作不同类型，而且
类型还不确定，那么可以将泛型定义在方法上。
*/
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 GenericDemo3 
{
	public static void main(String[] args) 
	{
		Demo d1 = new Demo();
		d1.show(new Integer(4));
		d1.print("java");

		Demo d2 = new Demo();
		d2.show("hah");
		d2.print(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);
	}
}

特殊之处：

静态方法不可以访问类上定义的泛型。

如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。

class Demo<T>{
	//这是错误的，因为静态方法在对象建立之前就被初始化。静态方法操作的应用数据类型不确定。
	public static void method(T t){}
	//下面是正确的。
	public static <W> void method(W w){}//<W>放在返回值类型的前面，修饰符的后面。
}

 

 泛型接口

 

泛型定义在接口上

interface Inter<T>{
	void show(T t);
}
class InterImpl<T> implements Inter<T>
{
	public void show(T t){
		语句
	}
}

 

泛型限定

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

泛型的限定：

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

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

 

？extends E

import java.util.*;
//定义一个父类Person
class Person{
	private String name;
	Person(String name){
		this.name = name;
	}
	public String getName(){
		return name;
	}
}
//定义一个子类 Student
class Student extends Person{
	Student(String name){
		super(name);
	}
}
class GenericDemo4{
	public static void main(String[] args){
		ArrayList<Student> a1 = new ArrayList<Student>();
		a1.add(new Student("stu1----"));
		a1.add(new Student("stu2----"));
		a1.add(new Student("stu3----"));
		a1.add(new Student("stu4----"));
		ArrayList<Person> a2 = new ArrayList<Person>();
		a2.add(new Student("----per1"));
		a2.add(new Student("----per2"));
		a2.add(new Student("----per3"));
		a2.add(new Student("----per4"));
		printColl(a1);
		printColl(a2);	
	}
	//？extends E：可以接收E类型或者E的子类型，上限。
	public static void printColl(ArrayList<?extends Person> a){
		Iterator<? extends Person> it = a.iterator();
		while(it.hasNext()){
			System.out.println(it.next().getName());
		}
	}
}

？super E

import java.util.*;

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);
	}
}
class GenericDemo5{
	public static void main(String[] args){
		TreeSet<Student> ts = new TreeSet<Student>(new MyCompare());
		ts.add(new Student("lisi01"));
		ts.add(new Student("lisi03"));
		ts.add(new Student("lisi02"));
		TreeSet<Person> ts1 = new TreeSet<Person>(new MyCompare());
		ts1.add(new Person("----lisi01"));
		ts1.add(new Person("----lisi03"));
		ts1.add(new Person("----lisi02"));
		printColl(ts);
		printColl(ts1);
	}
	public static void printColl(TreeSet<?extends Person> a){
		Iterator<? extends Person> it = a.iterator();
		while(it.hasNext()){
			System.out.println(it.next().getName());
		}
	}
}

class MyCompare implements Comparator<Person>{  //? super Student
	public int compare(Person o1,Person o2){
		return o2.getName().compareTo(o1.getName());
	}
}

 

---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ---------------------- 

详情请查看：http://edu.csdn.net