黑马程序员_学习笔记泛型

Java培训、Android培训、iOS培训、.Net培训 期待与您交流！ 

泛型是jdk1.5引入的新特性，为的是将运行时错误，改为编译时错误，让通过程序员识别强制类型转换变成了javac时就可识别的错误。同时也简化了编程代码。

举例

在jdk1.5之前，要分别将Worker和Student作为参数传入方法，需要创建重载的方法

	public void print(Student stu){
		
	}
	public void print(Worker w){
		
	}

在jdk1.5之后，就可以使用泛型只需要一个方法就可以了

	public <T> void print(T t){
		
	}

特别是在框架中，当引入泛型，就避免了强制类型转换，并检查了输入的参数是否符合程序要求

如使用TreeSet来使用

1.不使用泛型

		TreeSet ts=new TreeSet();
		ts.add("123");
		ts.add(new String("234"));
//		ts.add(123);//当强制类型转换时，会出现错误ClassCastException
		
		Iterator it=ts.iterator();
		while(it.hasNext()){
			String s=(String)it.next();
			System.out.println(s);
		}

2.使用了泛型之后，加强了安全检查

<span style="white-space:pre">		</span>TreeSet<String> ts = new TreeSet<>();
		ts.add("123");
		ts.add(new String("234"));
		// ts.add(123);//无法添加进去

		Iterator<String> it = ts.iterator();
		while (it.hasNext()) {
			String s = it.next();// 不需要强制类型转换
			System.out.println(s);
		}

二、泛型

有泛型类

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

class GenericDemo<T>{
	private T t;
	
}

然后在类中就可以把该类型当成一种对象来使用，

泛型方法，在方法定义时声明

<span style="white-space:pre">	</span>public <T> void method(T t){
		
	}

在不同方法声明时可以定义自己不同的泛型限定，是不同方法操作不同类型，而且类型还不确定。

特殊之处：

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

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

泛型定义放在方法上时，应放在返回值类型前，修饰符后

泛型接口

第一种

interface Inter<T>{
	void show(T t);
}

class InterImp2 implements Inter<String>{
	public void show (String t){
		System.out.println("show: "+t);
	}
}

第二种

interface Inter<T>{
	void show(T t);
}

class InterImp1<T> implements Inter<T>{
	public void show (T t){
		System.out.println("show: "+t);
	}

}

泛型的高级应用

import java.util.ArrayList;
import java.util.Collection;
import java.util.Comparator;
import java.util.Iterator;

/*
 ? 通配符。也可以理解为占位符。
 泛型的限定；
 ？ extends E: 可以接收E类型或者E的子类型。上限。
 ？ super E: 可以接收E类型或者E的父类型。下限

 */

class GenericDemo6 {
	public static void main(String[] args) {
		/*
		 * ArrayList<String> al = new ArrayList<String>();
		 * 
		 * al.add("abc1"); al.add("abc2"); al.add("abc3");
		 * 
		 * ArrayList<Integer> al1 = new ArrayList<Integer>(); al1.add(4);
		 * al1.add(7); al1.add(1);
		 * 
		 * printColl(al); printColl(al1);
		 */

		ArrayList<Person> al = new ArrayList<Person>();
		al.add(new Person("abc1"));
		al.add(new Person("abc2"));
		al.add(new Person("abc3"));
		// printColl(al);

		ArrayList<Student> al1 = new ArrayList<Student>();
		al1.add(new Student("abc--1"));
		al1.add(new Student("abc--2"));
		al1.add(new Student("abc--3"));
		printColl(al1); // ArrayList<? extends Person> al = new
						// ArrayList<Student>();error

	}

	public static void printColl(Collection<? extends Person> al) {
		Iterator<? extends Person> it = al.iterator();

		while (it.hasNext()) {
			System.out.println(it.next().getName());
		}
	}
	/*
	 * public static void printColl(ArrayList<?> al)//ArrayList al = new
	 * ArrayList<Integer>();error { Iterator<?> it = al.iterator();
	 * 
	 * 
	 * while(it.hasNext()) { System.out.println(it.next().toString()); } }
	 */
}

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 Student implements Comparable<Person>//<? super E> { public int
 * compareTo(Person s) { this.getName() } }
 */
class Comp implements Comparator<Person> {
	public int compare(Person s1, Person s2) {

		// Person s1 = new Student("abc1");
		return s1.getName().compareTo(s2.getName());
	}
}
/*
 * TreeSet<Student> ts = new TreeSet<Student>(new Comp()); ts.add(new
 * Student("abc1")); ts.add(new Student("abc2")); ts.add(new Student("abc3"));
 */