黑马程序员-----JDK1.5新特性-泛型总结*

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

 

 

泛型的由来：

往集合中存入数据时可能会存入不同类型的数据，而编译时无法发现，运行时会报错，为了消除这种隐患，提高安全性，JDK1.5以后引入了泛型，泛型是借鉴了数组定义的原则，在声明时就定义了数据类型，保证往集合中存入数据时只能够存入同一种类型数据

 

泛型的好处：

1、将编译时可能发生的ClassCastException转移到了编译时期，方便于程序员解决问题

2、避免了强制转换的麻烦

 

什么时候定义泛型？

当类中要操作的引用数据类型不确定的时候，早期是定义的Object，现在定义泛型。

public class ClassDemo {
	public static void main(String[] args) {
		Tool<Person> t = new Tool<Person>();
		t.setObject(new Person());
		t.getObject();
	}
}

// 自定义泛型类
class Tool<T> {
	private T t;

	public void setObject(T t) {
		this.t = t;
	}

	public T getObject() {
		return t;
	}
}

class Person{
	
}

 

 

泛型定义在方法上：

1、泛型定义在类上的弊端是：一旦创建对象指定了泛型类型，那么类中所有的方法全部都必须是该类型

2、泛型定义在方法上，该类型只在该方法内有效，不同方法可以定义不同的泛型类型，这样互不影响

3、泛型<>定义在返回值类型的前面

public class ClassDemo {
	public static void main(String[] args) {
		Tool t = new Tool();
		//不同的方法可以定义不同的泛型类型
		t.setObject(new Person());
		t.getObject("哈哈,学编程好快乐");
	}
}

class Tool{

	public <T> void setObject(T t){
		System.out.println("1"+t);
	}
	public <Q> void getObject(Q q){
		System.out.println("2"+q);
	}
}

class Person{
	
}

 

 

既定义在类上又定义在方法上：

1、如果方法上没有重新定义泛型类型，那么该方法的泛型类型和类一样

2、如果方法上重新定义了泛型类型，那么该方法的泛型类型为任意

 

public class ClassDemo {
	public static void main(String[] args) {
		Tool<String> t = new Tool<String>();

		t.setObject("哈哈,学编程好快乐");
		t.getObject("哈哈,学编程好快乐");
		
		t.getObject(new Person());
	}
}

class Tool<T>{

	public void setObject(T t){
		System.out.println("1"+t);
	}
	public <Q> void getObject(Q q){
		System.out.println("2"+q);
	}
}

class Person{
	
}

 

 

泛型定义在静态方法上：

1、因为泛型只有在对象创建时才被确定，所以静态方法中不能够调用类或方法上的泛型

2、只能够在静态方法上定义泛型

 

public class ClassDemo {
	public static void main(String[] args) {
		Tool<String> t = new Tool<String>();

		t.getObject("haha");
		t.getObject(new Person());
		
		Tool.setObject("haha");
		Tool.setObject(new Person());
	}
}

class Tool<T>{

	public static <C> void setObject(C c){
		System.out.println("1"+c);
	}
	public <Q> void getObject(Q q){
		System.out.println("2"+q);
	}
}

class Person{
	
}

 

泛型定义在接口上：

public class ClassDemo{
	public static void main(String[] args) {
		ImpleInter ii = new ImpleInter();
		ii.method("haha");
		
		ImpleInter1<String> ii1 = new ImpleInter1<String>();
		ii1.method("haha");
	}
}

interface Inter<T>{
	public static final int i = 3;
	public abstract void method(T t);
}

//第一种情况：在实现时就指定泛型类型
class ImpleInter implements Inter<String>{
	public void method(String s){
		System.out.println(s);
	}
}

//第二种情况：在实现时不指定泛型类型
class ImpleInter1<T> implements Inter<T>{
	public void method(T t){
		System.out.println(t);
	}
}

 

 

泛型的上限与下限： 

上限：<? extends Person>

下限：<? super Student>

import java.util.*;

public class ClassDemo{
	public static void main(String[] args) {
		ArrayList<Person> al1 = new ArrayList<Person>();
		al1.add(new Person("zhangsan"));
		al1.add(new Person("lisi"));
		
		ArrayList<Student> al2 = new ArrayList<Student>();
		al2.add(new Student("wangwu"));
		al2.add(new Student("liuliu"));
		
		method(al1);
		method(al2);
	}
	
	public static void method(ArrayList<? extends Person> al){
		Iterator<? extends Person> i = al.iterator();
		
		while(i.hasNext()){
			System.out.println(i.next().getName());
		}
	}
}


class Person{
	private String name;
	public Person(String name){
		this.name = name;
	}
	public String getName(){
		return name;
	}
}


class Student extends Person{
	public Student(String name){
		super(name);
	}
}

 

总结：TreeSet集合中的比较器Comparator<? super E>，E定义成父类，既可以比较父类又可以比较子类

 

 

 

 

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

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