(34)Java学习笔记——集合框架 / 泛型

泛型：

是一种吧类型明确的工作推迟到创建对象或者调用方法的时候才去明确的特殊的类型。参数化类型，把类型当作参数一样的传递。

格式：

<数据类型>

此处的数据类型只能是引用类型。

好处：

A/ 把运行时期的问题提前到了编译期间

B/ 避免了强制类型转换

C/ 优化了程序设计，解决了黄色警告线

泛型的使用：

如果类，接口，抽象类后面跟着<E>就说要使用泛型，一般来说就是在集合中使用。

范例：

package cn.itcast_01;

import java.util.ArrayList;
import java.util.Iterator;

/*
 * ArrayList存储字符串并遍历
 */
public class GenericDemo {
	public static void main(String[] args) {
		//创建集合对象
		ArrayList<String> array = new ArrayList<String>();	//泛型的应用
		
		//创建字符串并添加
		array.add("hello");
		array.add("world");
		array.add("java");
		
		//遍历
		Iterator<String> it = array.iterator();	//明确了是String类型
		while(it.hasNext()){
//			String s = (String) it.next();
			String s = it.next();	//不需要强转了
			System.out.println(s);
		}
	}
}

泛型的应用：

A/ 泛型类

---|a / 把泛型定义在类上

---|b / 格式： public class 类名 < 泛型类型1,.....>

---|c / 注意：泛型类型必须是引用类型

B/ 泛型方法

---|a / 把泛型定义在方法上

---|b / 格式：public<泛型类型> 返回值类型  方法名 （泛型类型）

好处：方法可以接收任意类型的数据，接收什么自定义成什么。

C/ 泛型接口

---|a / 把反省定义在接口上

---|b / 格式：public interface 接口名 <泛型类型1， ...>

范例01：泛型类

package cn.itcast_02;
/*
 *  泛型类：把泛型定义在类上
 */
public class ObjectTool<T> {   //<>泛型表示参数类型，参数是变量，所以可依据需要命名
	private T obj;
	
	public T getObj(){
		return obj;
	}
	
	public void setObj(T obj){
		this.obj = obj;
	}
}

package cn.itcast_02;
/*
 * 泛型类的测试
 */
public class ObjectToolDemo {
	public static void main(String[] args) {
		ObjectTool<String> ot = new ObjectTool<String>();	//传递给泛型类的参数是String类型
		ot.setObj(new String("猪八戒"));
		String s = ot.getObj();
		System.out.println("姓名："+s);
		
		ObjectTool<Integer> ot2 = new ObjectTool<Integer>();  //传递给泛型类的参数是Integer类型
		ot2.setObj(new Integer(33));
		Integer i = ot2.getObj();
		System.out.println("年龄："+i);

	}
}

范例02：泛型方法

package cn.itcast_02;
/*
 * 定义泛型方法
 */
public class ObjectToolDemo02 {
	//定义一个泛型方法
	public <T> void show(T t){
		System.out.println(t);
	}
}

package cn.itcast_02;
/*
 * 泛型方法测试
 */
public class ObjectToo02 {
	public static void main(String[] args) {
		
		//定义集合对象
		ObjectToolDemo02 ob = new ObjectToolDemo02();
		
		//调用泛型方法
		ob.show("hello"); //调用方法时，方法接收的是什么类型的数据，就自定义为什么类型返回值的方法
		ob.show(100);
		ob.show(true);
	}
}

范例03：泛型接口

package cn.itcast_03;
/*
 * 定义一个泛型接口
 */
public interface Inter<T> {
	public abstract void show(T t);
}

package cn.itcast_03;
/*
 * 定义一个接口的实现类
 */
public class InterImpl<T> implements Inter<T> {

	@Override
	public void show(T t) {
		System.out.println(t);
	}
	
}

package cn.itcast_03;
/*
 * 泛型接口测试类
 */
public class InterDemo {

	public static void main(String[] args) {
		Inter<String> i = new InterImpl<String>();
		i.show("hello");
		
		Inter<Integer> ii = new InterImpl<Integer>();
		ii.show(100);
	}

}

泛型高级（通配符）

泛型如果明确的写的时候，前后必须一致

泛型通配符

<?>

任意类型，如果没有明确，那么就是Object以及任意的java类了

？extends E

向下限定，E及其子类

？super E

向上限定，E及其父类

范例：

package cn.itcast_04;

import java.util.ArrayList;
import java.util.Collection;

public class GenericDemo {
	public static void main(String[] args) {
		 //泛型如果明确的写的时候，必须前后一直
		Collection<Object> c1 = new ArrayList<Object>();	  //这是对的，//泛型如果明确的写的时候，必须前后一直
		//Collection<Object> c2 = new ArrayList<Animal>();	//这是错的，//泛型如果明确的写的时候，必须前后一直
		//Collection<Object> c3 = new ArrayList<Dog>();		//这是错的，//泛型如果明确的写的时候，必须前后一直
		//Collection<Object> c4 = new ArrayList<Cat>();		//这是错的，//泛型如果明确的写的时候，必须前后一直
		
		//?表示任意的类型都是可以的
		Collection<?> c5 = new ArrayList<Object>();	  //这是对的，?表示任意的类型都是可以的
		Collection<?> c6 = new ArrayList<Animal>();	//这是对的，?表示任意的类型都是可以的
		Collection<?> c7 = new ArrayList<Dog>();		//这是对的，?表示任意的类型都是可以的
		Collection<?> c8 = new ArrayList<Cat>();		//这是对的，?表示任意的类型都是可以的
		
		//? extends E  向下限定，E及其子类有效
		//Collection<? extends Animal> c9 = new ArrayList<Object>();	//这是错的，? extends E  向下限定，E及其子类有效
		Collection<? extends Animal> c10 = new ArrayList<Animal>();	//这是对的，? extends E  向下限定，E及其子类有效
		Collection<? extends Animal> c11 = new ArrayList<Dog>();	//这是对的，? extends E  向下限定，E及其子类有效
		Collection<? extends Animal> c12 = new ArrayList<Cat>();	//这是对的，? extends E  向下限定，E及其子类有效
	
		//? super E   向上限定，E及其父类有效
		Collection<? super Animal> c13 = new ArrayList<Object>();	//这是对的，? extends E  ? super E   向上限定，E及其父类有效
		Collection<? super Animal> c14 = new ArrayList<Animal>();	//这是对的，? extends E  ? super E   向上限定，E及其父类有效
		//Collection<? super Animal> c15 = new ArrayList<Dog>();		//这是错的，? extends E  ? super E   向上限定，E及其父类有效
		//Collection<? super Animal> c16 = new ArrayList<Cat>();		//这是错的，? extends E  ? super E   向上限定，E及其父类有效
		
		
	}
	
	class Animal{
		
	}
	
	class Dog extends Animal{
		
	}
	
	class Cat extends Animal{
		
	}
}