Javase基础学习笔记之集合（4）

</pre>----------------------          <span style="font-family:Arial,Helvetica,sans-serif">泛型</span><span style="font-family:Arial,Helvetica,sans-serif">                       ---------------------</span>
package cn.itcast.generic;

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

public class GenericDemo {
	public static void main(String[] args) {
		List<String> list =new ArrayList<String>();
		list.add("1");
		list.add("abc");
		for(Iterator<String> it =list.iterator();it.hasNext();){
			System.out.println(it.next());
		}
	}
}
	
泛型表现：只要看到类，或者接口在描述时右边定义<>，就需要泛型 
	  其实就是容器提供了一个参数
	  使用容器时，只要将具体的类型实参传递给该参数即可
	  因此泛型就是传递类型参数
定义：定义集合时，明确集合中存储元素的具体类型，编译时就能发现问题
擦除：编译器编译时检查无问题后，生成class文件，在class中将泛型标识删除了
带着参数全传，指定什么类型接收什么类型的元素，

泛型定义在类上即是泛型类
GenericDemo .java
package cn.itcast.collection;

public class GenericDemo {
	public static void main(String[] args) {
		Tool tool =new Tool();
		tool.setObj(new Worker());
		
	
		Util<Student> util =new Util<Student>();
		util.setObj(new Student());
		Student stu =util.getObj();
		System.out.println(stu);
	}
}

class Tool{
	private Object obj;

	public Tool() {
		super();
		
	}

	public Object getObj() {
		return obj;
	}

	public void setObj(Object obj) {
		this.obj = obj;
	}

	
	
	
}
//类定义时就明确参数，有使用该类的调用者，来传递具体的类型。
class Util<W>{//泛型类传说
	private W obj;

	public W getObj() {
		return obj;
	}

	public void setObj(W obj) {
		this.obj = obj;
	}
	
}

/*
*创建一人瞬息于操作stuent对象工具类，获取和设置
*类型向上抽取
*
*jdk1.5以后，新的解决方案，类型不确定时，可以对外提供参数，有使用者通过
*传递参数的形式安然无恙成类型的确定
*/
/*class Tool{
	private Student stu;

	public Student getStu() {
		return stu;
	}

	public void setStu(Student stu) {
		this.stu = stu;
	}
	
}*/
----------------------          泛型方法                       ---------------------
GenericDemo3
package cn.itcast.collection;

public class GenericDemo3 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Demo<String> d =new Demo<String>();
		d.show("abc");
		Demo<Integer> da =new Demo<Integer>();
		da.print(6);
		
	}

}
class Demo<W>{
	//public static void show(W w){
	//静态方法随着类存在而存在，而泛型那个必须要new出来对象才行
	//静态方法无法访问类上定义的泛型
	public  void show(W w){
		System.out.println("show:"+w);
	}
	public static <A> void stasd(A a){
		System.out.println("statsd:"+a);
	}
	public <Q> void print(Q w){//泛型方法，Q位置相当于object
		System.out.println("print:"+w);
	}
}

    
    

     
     
----------------------          泛型接口                       ---------------------
     
     
package cn.itcast.collection;

public class GenericDemo6 {
	public static void main(String[] args) {
		SubDemo d =new SubDemo();
		d.show("abc");
	}
}
//接口类型不确定把它定义为参数，传参就行了

interface Inter<T>{//泛型接口
	public void show(T t);
}
class InterImpl<W> implements Inter<W>{

	@Override
	public void show(W t) {
		System.out.println("show"+t);
	}
	
}
class SubDemo extends InterImpl<String>{
	
}
/*class InterIm implements Inter<String>{

	@Override
	public void show(String t) {
	}
	
}
*/
----------------------          泛型限定                       ---------------------
ddsfsdf
     
     
/*	private static void printCollection(Collection<?> coll ) {//在不明确具体类型的情况 下，可以使用通配符来表示
		
		for (Iterator<?> it = coll.iterator(); it.hasNext();) {
			Object obj = it.next();
			//通配符取出来元素一定是Object
			System.out.println(obj);
			
		}
	}*/
	/*
	 * 泛型的限定：
	 * 上限即上面限定住了
	 * 而下限同理即下面限定住了
	 * ？extends E: 接收E类型或者E的子类型
	 * ? super E:  接收E类型或者E的父类型
	 */
	private static void printCollection(Collection<? extends Person> coll ) {//在不明确具体类型的情况 下，可以使用通配符来表示
		
		for (Iterator<? extends Person> it = coll.iterator(); it.hasNext();) {
			Person obj =it.next();
			System.out.println(obj.getName()+":"+obj.getAge());
			
		}
	}
	
}
----------------------          泛型上限
什么时候用上限： 一般往集合中存储元素时，如果集合定义了E类型，通常情况下应该存储E类型的对象，
		 * 对于E的子类型对象E类型也可接受，可将泛型E改为？ extends E
     
     
package cn.itcast.collection;

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

public class GenericDemo9 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		/*
		 * 演示泛型限定在api中应用 
		 * TreeSet构造函数
		 * TreeSet(Collection<? extends E> coll);
		 * 一般往集合中存储元素时，如果集合定义了E类型，通常情况下应该存储E类型的对象，
		 * 对于E的子类型对象E类型也可接受，可将泛型E改为？ extends E
		 * 
		 */
		Collection<Student> coll  =new ArrayList<Student>();
		coll.add(new Student("lisi2", 22));
		coll.add(new Student("lisi3", 28));
		coll.add(new Student("lisi4", 24));

		
		TreeSet<Person> ts =new TreeSet<Person>(coll);
		ts.add(new Person("abc",23));
		
		for (Iterator<Person> it = ts.iterator(); it.hasNext();) {
			Person person = it.next();
			System.out.println(person.getName());
			
		}
		
		
	}

}

class MyTreeSet<E>{
	MyTreeSet(){
		
	}
	MyTreeSet(Collection<? extends E> c){
		
	}
}
----------------------          泛型下限
啥时候用：当从容器中取出元素时，可以用E的类型接收，也可以用E的父类型接收。

package cn.itcast.collection;

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

public class GenericDemo9 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		/*
		 * 演示泛型限定在api中应用 
		 * TreeSet构造函数
		 * TreeSet(Comparator<? super E> comparator);
		 * 
		 * 
		 */
		//创建比较器
		Comparator<Person> comp=new Comparator<Person>(){

			@Override
			public int compare(Person o1, Person o2) {
				int temp =o1.getAge()-o2.getAge();
				return temp==0?o1.getName().compareTo(o2.getName()):temp;
			
			}
			
		};
		


		
		TreeSet<Student> ts=new TreeSet<Student>(comp);
		
		ts.add(new Student("lisi2", 22));
		ts.add(new Student("lisi3", 28));
		ts.add(new Student("lisi4", 24));
		TreeSet<Worker> tp=new TreeSet<Worker>();
			
		tp.add(new Worker("li2s", 13));
		tp.add(new Worker("abd", 18));
		tp.add(new Worker("qwwe", 15));
		tp.add(new Worker("cwwe", 23));
		for (Iterator<Student> it = ts.iterator(); it.hasNext();) {
			Student student = it.next();
			System.out.println(student);
			
		}
		
	}

}

class NewTreeSet<E>{
	NewTreeSet(Comparator<? super E> comparator){
		System.out.println("12123");
	}
	
}