【Java基础】集合(4) —— 泛型

【Java基础】集合(1) —— Collection
【Java基础】集合(2) —— List
【Java基础】集合(3) —— Set
【Java基础】集合(4) —— 泛型
【Java基础】集合(5) —— Map
【Java基础】集合(6) —— Collections

泛型

ArrayList list=new ArrayList();
list.add("java01");
list.add("java02");
list.add("java03");
list.add(66);
Iterator ite = list.iterator();
while(ite.hasNext()){
	Object obj = ite.next();
	String str=(String)obj;
	System.out.println(str.toUpperCase());
}

编译正常，运行出问题了，程序不够安全

从 jdk1.5 开始

• 使用<>指定一种引用数据类型，作用是在程序的编译时期检查集合中存储的数据的类型是否是<>中指定的类型。如果不是，编译出错，从而把运行时期的问题转移到了编译时期，提高了程序的安全性

jdk中，类名后带有的，是可以使用泛型的类（E是任意的，我们常用E、T）

ArrayList<String> list=new ArrayList<>();
list.add("java01");
list.add("java02");
list.add("java03");
//list.add(66);
Iterator ite = list.iterator();
while(ite.hasNext()){
//	不需要向下转型了
//	Object obj = ite.next();
//	String str=(String)obj;
	System.out.println(str.toUpperCase());
}

泛型类

在定义类的时候定义了泛型，使用该类时才可以使用泛型

泛型方法

1. 当类上的泛型的类型确定了，该方法的参数的类型才确定
2. 方法自己使用泛型，不受类上泛型的影响
3. 静态方法:
   类上的泛型是在创建类的对象时才确定，而静态方法可以通过类名直接调用。
   只能自己用泛型

class Test<E>{
	public void show(E e){//1
		System.out.println(e);
    }
    public <E> void fun(E e){//2
        System.out.println(e);
    }
    public static <E> void ff(E e){//3
        System.out.println(e);
    }
}
class Demo3{
    public static void main(String[] args) {
        Test<String> test=new Test<>();
        test.show("hello");
        test.fun(66);
        test.fun(6.6);
        test.fun("hh");
        Test.ff(666);
    }
}

泛型接口

定义接口时定义了泛型，该接口才能使用泛型

interface Test<E>{
	void show(E e);
	void fun(String str);
}
class Demo implements Test<String>{
	public void show(String e){
		System.out.println(e);}
	public void fun(String str){
		System.out.println(str);}
}
class Demos<E> implements Test<E>{
	public void show(E e){
		System.out.println(e);}
	public void fun(String str){
		System.out.println(str);}
}
class Demo3 {
	public static void main(String[] args) {
		Demo d=new Demo();
		d.show("hello");
		d.fun("world");
		Demos<String> dd=new Demos();
		//dd.show(88);//错误: 不兼容的类型: int无法转换为String
		dd.show("okk");
	}
}

通配符

public static void dieDai2(List<?> list){//通配符
	Iterator<?> ite = list.iterator();
	while(ite.hasNext()){
		Object obj = ite.next();
		System.out.println(obj);
	}
}
//迭代集合的方法
public static <E> void dieDai(List<E> list){
	Iterator<E> ite = list.iterator();
	………………
}

泛型限定

<? entends E>：要求集合中对象的类型是E类型或其子类类型，限定了一个上限

<? super E>：要求集合中对象的类型是E类型或其父类类型，限定了一个下限

class Person{…………}
class Student extends Person{…………}
class Worker extends Person{…………}
class Demo6 
{
	public static void main(String[] args) 
	{
		ArrayList<Student> list=new ArrayList<>();
		list.add(new Student("lisi",20));
		list.add(new Student("zhaosi",22));
		list.add(new Student("wangwu",18));
		dieDai2(list);
		ArrayList<Worker> list2=new ArrayList<>();
		list2.add(new Worker("xiaobai",28));
		list2.add(new Worker("zhaoliu",29));
		list2.add(new Worker("wangwu",16));
		dieDai2(list2);
	}
	public static void dieDai2(List<? extends Person> list) {
		Iterator<?> ite = list.iterator();
		while(ite.hasNext()){
			Object obj = ite.next();
			System.out.println(obj);
		}
	}
}