Java基础—泛型

1、 泛型产生的原因

     JDK升级至1.5后，为了解决集合中不指定类型，增加的安全机制，通过强制规定输入集合中元素的类型，避免后面操作过程中的类型错误。使程序在运行中出现的错误的问题   转移到编译阶段。  

       （1）定义泛型方法

                 在类中的方法支持多个数据类型，就需要对方法进行重载，在引入范型后，可以解决此问题（多态），更进一步可以定义多个参数以及返回值之间的关系。

                    重载方式

                       public void write(Integer i, Integer[] ia);
                        public void write(Double  d, Double[] da);
                  泛型：
                   public <T> void write(T t, T[] ta);

     （2）  定义泛型类：

          当要操作的引用数据不确定，早期定义Object类来拓展，但是面临期操作过程中（编译能通过），需要强转。现在用泛型类来定义。定义泛型类时，对于类中的方法都可以通过泛型对象调用，只要确定具体类型，操作就固定了。(对于方法的类型单一)。

        class < T >{

               private T t;

               public   T  Methid(T  m){

                ..............     

                 }

               }

                 定义之后，在该类的作用域内，均可使用该类型。

2、  泛型限定

           （1）  限定特点

                   泛型是编译期检查的，匹配引用类型。 
                          ArrayList<Animal> list = new ArrayList<Animal>();
                          Animal animal = new Animal();
                          Animal cat = new Cat();
                         Cat cat2 = new Cat();
                          list.add(animal);//ok
                          list.add(cat);//ok
                          list.add(cat2);//complile error

           （2）

                       限定下限：

            一般用于定义 迭代器： 只需定义 父类类型的迭代器，否则 面向具体的话，扩展性和维护性不好

class Personed {
	private String Name;
	private int Age;

	public String getName() {
		return Name;
	}

	public int getAge() {
		return Age;
	}

	public Personed(String name, int age) {
		super();
		this.Name = name;
		this.Age = age;
	}

}

class Student extends Personed {

	public Student(String name, int age) {
		super(name, age);
		// TODO Auto-generated constructor stub
	}
}

class Teacher extends Personed {

	public Teacher(String name, int age) {
		super(name, age);		
	}
}
class CompareByAge implements Comparator<Personed> {
	public int compare(Personed s1, Personed s2) {
		int num = new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
		if (num == 0)
			return s1.getName().compareTo(s2.getName());
		return num;
	}

}
class Demo13 {
	// TreeSet<E>(Comparator<? super E> comparator)
	// 定义比较器时，可以是E类型，还可以是E的父类型,E在创建集合对象时确定
	public static void main(String[] args) {
		TreeSet<Student> t1 = new TreeSet<Student>(new CompareByAge());
		t1.add(new Student("zhaosi", 23));
		t1.add(new Student("lisi", 25));
		t1.add(new Student("wangwu", 20));

		TreeSet<Teacher> t2 = new TreeSet<Teacher>(new CompareByAge());
		t2.add(new Teacher("wang", 38));
		t2.add(new Teacher("lilaoshi", 48));
		t2.add(new Teacher("zhanglaoshi", 58));
	}

}

               限定上限：

定义父类 填装子类 类型！

import java.util.*;  
  
//泛型限定上限的应用  
  
class Demo12   
{  
    public static void main(String[] args)   
    {   
        Collection<Student> c = new ArrayList<Student>();  
  
        c.add(new Student("zhaosi",23));  
        c.add(new Student("lisi",25));  
        c.add(new Student("wangwu",20));  
       
       //TreeSet(Collection<? extends E> c)  
       // class TreeSet<E>  
       //{  
       //}  
        TreeSet<Person> ts = new TreeSet<Person>(c);  
  
        Iterator<Person> ite = ts.iterator();  
        while(ite.hasNext())  
        {  
            sop(ite.next());  
        }  
    }  
      
    public static void sop(Object obj)  
    {  
        System.out.println(obj);  
    }  
}