简单理解泛型及其特性

泛型概述

	 Collection<E>,  E - 在此 collection 中保持的元素的类型

泛型好处

	* 提高安全性(将运行期的错误转换到编译期) 
	* 省去强转的麻烦

泛型基本使用

	* <>中放的必须是引用数据类型 

:泛型使用注意事项

	* 前后的泛型必须一致,或者后面的泛型可以省略不写(1.7的新特性菱形泛型) 

import java.util.ArrayList;
import java.util.Iterator;
import bean.Student;
public class c {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ArrayList list = new ArrayList();
		list.add(10);
		list.add(true);
		list.add(new Student("张三", 23));
		list.add(new Student("李四", 24));
		Iterator it = list.iterator();
		while(it.hasNext()) {
			System.out.println(it.next());
			//Student p = (Student) it.next();	向下转型		
			//System.out.println(p.getName() + "..." + p.getAge());
			//java.lang.ClassCastException
			}
		/*10
		true
		Student [name=张三, age=23]
		Student [name=李四, age=24]*/
		
		
		ArrayList<Student> list1 = new ArrayList<Student>();
		//list1.add(10);
		//The method add(int, Student) in the type ArrayList<Student> is not applicable for the arguments (int)
		//list.add(true);
		list1.add(new Student("张三", 23));
		list1.add(new Student("李四", 24));
		Iterator<Student> it1 = list1.iterator();
		while(it1.hasNext()) {
			//Student p = it1.next();	//不用强转		
			//System.out.println(p.getName() + "..." + p.getAge());
			/*张三...23
			李四...24*/
			
			//System.out.println(it1.next().getName() + "..." + (it1.next()).getAge());
			//next方法只能调用一次,如果调用多次会将指针向后移动多次
		}
		
		
		//int[] arr = new byte[5];	//数组要保证前后的数据类型一致
		//ArrayList<Object> list = new ArrayList<Person>();	//集合的泛型要保证前后的数据类型一致
		//ArrayList<Object> list = new ArrayList<>();		//1.7版本的新特性,菱形泛型
		ArrayList<Object> list2 = new ArrayList<>();//泛型最好不要定义成Object,没有意义
		list2.add("aaa");
		list2.add(true);
			
			
	}

}

泛型集合的遍历

import java.util.ArrayList;
import java.util.Iterator;
import bean.Student;
public class d {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ArrayList<String> list = new ArrayList<>();	//创建集合对象
		list.add("a");
		list.add("b");
		list.add("c");
		list.add("d");
		//list.add(arg0)
		Iterator<String> it = list.iterator();
		while(it.hasNext()) {
			System.out.println(it.next());//a b c d
		}
		
		
		ArrayList<Student> list1 = new ArrayList<>();
		list1.add(new Student("张三", 23));
		list1.add(new Student("李四", 24));
		list1.add(new Student("王五", 25));
		list1.add(new Student("赵六", 26));
		Iterator<Student> it1 = list1.iterator();
		while(it1.hasNext()) {
			Student p = it1.next();	//将集合中的每一个元素用Student记录
			System.out.println(p.getName() + "..." + p.getAge());
		}
	}
}

泛型的由来

 	泛型的由来:通过Object转型问题引入
	 早期的Object类型可以接收任意的对象类型，
	 但是在实际的使用中，会有类型转换的问题。也就存在这隐患，
	 所以Java提供了泛型来解决这个安全问题。
	 早期的Object类型可以接收任意的对象类型，
	 但是在实际的使用中，会有类型转换的问题。也就存在这隐患，
	 所以Java提供了泛型来解决这个安全问题。

泛型类概述<T>

	* 把泛型定义在类上
	定义格式
	* public class 类名<泛型类型1,…>
	注意事项	
	* 泛型类型必须是引用类型

泛型方法概述

	* 把泛型定义在方法上
	定义格式	
	* public <泛型类型> 返回类型 方法名(泛型类型 变量名)

泛型接口概述

	* 把泛型定义在接口上
	定义格式	
	* public interface 接口名<泛型类型>

public class e {
	public static void main(String[] args) {
		/*Demo d = new Demo<String>();
		d.show("a");*/
		Demo dd = new Demo();
		dd.show("aa");
		System.out.println("接口");
	}
}
//
interface Inter<T> {
	public void show(T t);
}

class Demo implements Inter<String> {//推荐用这种
	@Override
	public void show(String t) {
		System.out.println("接口 String");	
	}
}

/*class Demo<T> implements Inter<T> {//没有必要在实现接口的时候给自己类加泛型
	@Override
	public void show(T t) {
		System.out.println("接口T");
	}
	
}*/

泛型高级之通配符<?>

	* 任意类型，如果没有明确，那么就是Object以及任意的Java类了
	? extends E
	* 向下限定，E及其子类
	? super E
	* 向上限定，E及其父类

Collection类中的一个add方法
boolean addAll(Collection<? extends E> c)
	将指定 collection 中的所有元素都添加到此 collection 中（可选操作）。
	如果在进行此操作的同时修改指定的 collection，那么此操作行为是不确定的。
	（这意味着如果指定的 collection 是此 collection，并且此 collection 为非空，那么此调用的行为是不确定的。） 
	参数：
	c - 包含要添加到此 collection 的元素的 collection 
	返回：
	如果此 collection 由于调用而发生更改，则返回 true 

import java.util.ArrayList;
import java.util.List;
import bean.Person;
import bean.Student;
public class f {
	public static void main(String[] args) {
		//List<?> list = new ArrayList<Integer>();//当右边的泛型是不确定时,左边可以指定为?
		ArrayList<Student> list1 = new ArrayList<>();
		list1.add(new Student("张三", 23));
		list1.add(new Student("李四", 24));
		list1.add(new Student("王五", 25));
		
		ArrayList<Person> list2 = new ArrayList<>();
		list2.add(new Person("赵六", 26));
		list2.add(new Person("周七", 27));
		
		System.out.println(list2);
		list1.addAll(list2);//person是student的子类，自动类型提升
		System.out.println(list1);
		
		//list2.addAll(list1);

	}

}

还有一个person类，继承于student

package bean;
public class Person extends Student {
	public Person() {
		super();	
	}
	public Person(String name, int age) {
		super(name ,age);
	}
}