集合框架__【泛型】

泛型：

JDK1.5版本的新特性，用于解决安全问题，是一个类型安全机制
泛型的好处
1，将运行时期出现的问题ClassCastException转移到了编译时期；便于程序员解决问题，减小安全隐患
2，避免了强转的麻烦，
使用场景：
格式：通过<>来定义要操作的引用数据类型
在集合框架中比较常见，见到<>就定义了泛型，<>就是用来接收类型的；在迭代器，比较器，容器中使用
当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可

例如描述学生类时复写hashCode()、equals()、compare()方法。HashSet、TreeSet中都可以存入

泛型使用示例

import java.util.*;
class GenericDemo 
{
	public static void main(String[] args) 
	{
		TreeSet<String> al = new TreeSet<String>(new LenComparator());	//泛型，只能传入String类对象，否则编译报错
		al.add("add1");
		al.add("fa2");
		al.add("ddgxa3");
		al.add("dda3");

		Iterator<String> it = al.iterator();//迭代器中使用泛型
		while (it.hasNext())
		{
			String s = it.next();
			System.out.println(s+":"+s.length());
		}
	}
}
class LenComparator implements Comparator<String>	//比较器中定义泛型
{
	public int compare(String o1,String o2)	//传入类型限制为String，不需要再向下转型
	{
		int num = new Integer(o1.length()).compareTo(new Integer(o2.length()));//比较长度
		if (num == 0)
			return o1.compareTo(o2);	//如果长度相同，则进行正常比较
		return num;						//如要换位将o1、o2换位即可
	}
}

泛型类

当类中要操作的引用数据不确定时：早期定义Object完成扩展，而且会在运行时引发安全隐患；需要类型强转
现在定义泛型来完成扩展，将错误转移到编译时期，安全隐患会在编译时就排除；而且不用强转类型

示例：

class Worker
{}
class Student
{}
class Utils<haha>	//泛型类，作为获取不同对象的工具
{
	private haha h;
	public void set(haha h)
	{
		this.h = h;
	}
	public haha get()
	{
		return h;
	}
}
class  GenericDemo2
{
	public static void main(String[] args) 
	{
		Utils<Worker> u = new Utils<Worker>();
		u.set(new Student());	//定义泛型为Worker，传入Student时编译报错
		Worker w = u.get();		//如果不定义泛型，传入Student，编译时正常，运行时抛异常
	}
}

泛型类的优点 ：
强大之处在于可以传入任何类型的对象引用，而不需要再定义多个重载函数
泛型类的局限性：
泛型类定义的泛型在整个类中都有效，被方法调用泛型类的对象要操作的类型一旦确定，就固定了，如下示例：

		Demo<Integer> d = new Demo<Integer>();//只能操作Integer型，要想操作其他类型必须new一个Demo出来
		d.show(new Integer(4));
		d.print(9);

		Demo<String> s = new Demo<String>();//只能操作String型，否则编译出错
		s.show(new String("haha"));
		s.print("bbb");

泛型方法

为了让让不同方法可以操作不同的类型，且类型不确定，可以将泛型定义在方法上；打破了泛型类的局限性
在泛型类中可以同时存在泛型方法；
该类中的方法如果不自定义泛型就与类的泛型一致，
而如果该类中的方法也定义了泛型，该方法就不受类泛型的限制，可以传入任意对象。
特殊之处：静态方法不可以访问类上的泛型，如果静态方法操作的应用数据类型不确定，就将泛型定义在方法上

示例：

class Demo<T>//泛型类
{
	public <T> void show(T t)//泛型方法
	{
		System.out.println("show :"+t);
	}
	public <Q> void print(Q q)//泛型方法
	{
		System.out.println("print:"+q);
	}
	public static <S> void method(S s)//静态方法不能访问类的泛型，泛型类中必须将泛型定义在方法上
	{
		System.out.println("method:"+s);
	}
}
class GenericDemo3
{
	public static void main(String[] args)
	{
		Demo<String> d = new Demo<String>();
		d.show("haha");
		d.print(6);
		d.print("bbs");//访问类的泛型
		//d.print(true);可以通过

		d.method("hahhaha");//静态
	}
}

泛型接口

泛型定义在接口上，作为了解

interface Inter<T>
{
	void show(T t);
}/*
class Demo implements Inter<String>//泛型的类型确定
{
	public void show(String t)
	{
		System.out.println("show:"+t);
	}
}*/
class Demo<T> implements Inter<T>	//类型不确定
{
	public void show(T t)
	{
		System.out.println("show:"+t);
	}
}
class GenericDemo4 
{
	public static void main(String[] args) 
	{
		Demo<Integer> d = new Demo<Integer>();//由调用者来确定类型
		i.show();
/*		Demo d = new Demo();
		d.show("haha");
		d.show(4);	//类型错误	
*/	}
}

泛型限定

高级应用

? 通配符，也可理解为占位符，可以传入任意类型
？extends E：可以接受E类型或E的子类型。 上限 <? extends Person>
？ super E ：可以接收E类型或者E的父类型。下限<? super Student>

上限示例：

import java.util.*;
class GenericDemo5 
{
	public static void main(String[] args) 
	{
		ArrayList<Person> a1 = new ArrayList<Person>();
		a1.add(new Person("aaa1"));
		a1.add(new Person("aaa2"));
		a1.add(new Person("aaa3"));
		print(a1);
		ArrayList<Student> a2= new ArrayList<Student>();
		a2.add(new Student("bbb1"));
		a2.add(new Student("bbb2"));
		a2.add(new Student("bbb3"));
		print(a2);	//ArrayList<Person> = new ArrayList<Student>();
	}
	public static void print(ArrayList<? extends Person> a)//<? extends E>限定为Person和Person的子类
	{
		Iterator<? extends Person> it = a.iterator();
		while (it.hasNext())
		{
			System.out.println(it.next().getName());//提高扩展性，但不能使用类型特有方法；类似于多态
		}
	}
}

class Person
{
	private String name;
	Person(String name)
	{
		this.name = name;
	}
	public String getName()
	{
		return name;
	}
}

class Student extends Person
{
	Student(String name)
	{
		super(name);
	}
}

下限示例：

class Student implements Comparable<Student>//<? super E>
{
	public int compareTo(Person s)
	{
		this.getName();
	}
}
class Comp implements Comparator<Person>//下限
{
	public int compare(Person s1,Person s2)
	{
		//Person s1 = new Student("hahha");
		return s1.getName().compareTo(s2.getName());
	}
}
//在主函数中的操作中：
	TreeSet<Student> ts = new TreeSet<Student>(new Comp());//下限可以接收Person及其子类Student
	ts.add(new Student("aaa1"));
	ts.add(new Student("aaa2"));
	ts.add(new Student("aaa3"));

泛型下限时用到了对象的多态性，只能访问父类方法，而不能访问子类特有方法；提高扩展性的同时也会有局限性