JAVA基础复习（三）泛型的使用

泛型的学习主要是格式，但是如果不经常使用，格式也是很难记住的。JAVA一代一代的更新，不断走向成熟和完善，

它变得不仅仅是一门语言，而是像一件工具，而且它的使用变得越来越简单。

学习使用一件工具，就只能选择别人需要你学习的工具，所以伴随着JAVA的更新，工具使用者的更新也是必然的。

泛型是JDK1.5之后出现的类型安全机制。JAVA的使用者不用再顾虑从集合中取出的元素是否是类型安全的，因为不安全的类型在存放之前

就已经被限定了，ClassCastException错误的提示，从运行时提前到了编译时期。

泛型使得集合的使用，可以像数组一样，事先确定要存放什么类型的元素。而且在取出的时候不再需要类型强转。

①基本格式：

ArrayList<String> a=new ArrayList<String>();//存储限定

Iterator<String> it=a.iterator();//取出限定

注：<String>是示例，即<T>/<E>。

②TreeSet中的比较器：

class MyComparator extends Comparator<String>

compare(T t,T t)

class A implements Comparable<String>

compareTo(T t)

注意：在HashSet中，元素类中覆写hashCode()方法时不接收参数，但equals(Object obj)方法不可以使用泛型，因为Object类不支持泛型，无法覆写。

③泛型类：

泛型出现之前，扩展类中接收的引用数据类型参数一般用Object类，以实现扩展。泛型的做法：

class Util<T>

Util<Student> u=new Util<Student>();

class Util<R>//泛型类——————————————————————————
{
	private R r;
	public void setObject(R r)
	{
		this.r=r;
	}
	public R getObject()
	{
		return r;
	}
}
class GenericDemo2
{
	public static void main(String[]args)
	{
		Util<Worker> u=new Util<Worker>();//——————————————————
		u.setObject(new Worker());
		Worker w=/*(Worker)*/u.getObject();//泛型之后，类型强转不再需要，因为这是提前强制安全的
	}
}

④泛型方法：

public class GenericDemo3
{
	public static void main(String[]args)
	{
		Demo2/*<String>*/ d=new Demo2/*<String>*/();//泛型类时才加<String>
		d.show("haha");
		d.show(7);
		d.print(new Integer(4));
		d.print("godlike");
	}
	public static<T> void sop(T t)
	{
	System.out.println(t);
	}
} 
class Demo<T>//这种方法在这个类中都是同一类型的泛型
{
	public void show(T t)
	{
		System.out.println("show___"+t);
	}
	public void print(T t)
	{
		System.out.println("print___"+t);
	}
	public static <W> void method(W w)//注意<>的位置格式，另外因为静态先于对象，必须独立于类泛型才可以。
	{
		System.out.println("method___"+w);
	}
}
class Demo2//泛型定义在方法上，不同方法操作不同类。
{
	public <T> void show(T t)
	{
		System.out.println("show___"+t);
	}
	public <R> void print(R r)
	{
		System.out.println("print___"+r);
	}
}
class Demo3<T>//
{
	public void show(T t)//跟随类的泛型
	{
		System.out.println("show___"+t);
	}
	public <R> void print(R r)//独立于类的泛型
	{
		System.out.println("print___"+r);
	}
}

至于什么时候使用泛型类什么时候使用泛型方法，根据需求而定：比如集合，定义了类泛型，他的所有需要使用泛型的方法都与之一致，简化书写。

⑤泛型接口：

class GenericDemo4
{
	public static void main(String[]args)
	{
		InterIm2<Integer> im=new InterIm2<Integer>();
		im.show(4);
	}
	public static<T> void sop(T t)
	{
	System.out.println(t);
	}
} 
interface Inter<T> 
{
	void show(T t);
}
class InterIm implements Inter<String>//这种方法在主函数中产生对象的时候就不用再<String>了,但需要实现时明确类型。
{
	public void show(String t)
	{
		System.out.println("show---"+t);
	}
}
class InterIm2<T> implements Inter<T>//这种方法还是需要在主函数中产生对象的时候定义泛型
{
	public void show(T t)
	{
		System.out.println("show---"+t);
	}
}

泛型接口一般是JAVA类定义好的，拿来用就可以了，所以并不常用到，泛型类和泛型方法使用的机会多一些。

⑥通配符：<?>

import java.util.*;
public class GenericDemo5
{
	public static void main(String[]args)
	{
	ArrayList <String> a1=new ArrayList<String>();
	a1.add("java00");
	a1.add("java01");
	ArrayList <Integer> a2=new ArrayList<Integer>();
	a2.add(00);
	a2.add(11);
	sop(a1);
	sop(a2);
	
	}
	public static/*<T>*/  void sop(ArrayList <?> a)//在泛型出现之前的老版本，这里可以不写<>，没有错误，但写上通配符更加严谨。
	{
		for(Iterator<?> it=a.iterator();it.hasNext();)
		{
			//T t=it.next();这里T是可以具体使用的，而?仅仅是占位符。
			
			System.out.println(it.next());//这里无法使用子类的特有方法，如.length(),但可以使用公用方法如toString()
		}
	}
} 

泛型在提高扩展性的同时局限在于不能预先使用子类中的特有方法。

⑦泛型限定：

*？extends E :可以接受E类型及其子类型，定上限，不能高于E。
*？super E:可以接受E类型及其父类型，定下限，不能低于E。

public static void sop(ArrayList<? extends Person> a)
	{
		for(Iterator<? extends Person> it=a.iterator();it.hasNext();)
		{
			System.out.println(it.next().getName());
		}
	}

public class CompGeneric
{
	public static void main(String[]args)
	{
		TreeSet<Student> ts=new TreeSet<Student>(newMyComparator());

                //*TreeSet<E>
                //*TreeSet(Comparator<? super E> comparator)构造函数,即，TreeSet可以使用E以及E之上父类的比较器。

                //如E是Student/Worker时，使用Person的比较器。
		ts.add(new Student("java001"));
		ts.add(new Student("java002"));
		ts.add(new Student("java003"));
		for(Iterator<Student> it=ts.iterator();it.hasNext;)
		{
			sop(it.next());
		}
	}
	public static<T> void sop(T t)
	{
		System.out.println(t);
	}
} 
class Student implements Comparable<Person>//------------Student/Worker父类的比较器，这样一个比较器，所有的子类都可以使用。
{
	private String name;
	public String getName()
	{
		return name;
	}
	public int compareTo(Person a)
	{
		return this.getName().compareTo(a.getName());
	}
}
class MyComparator implements Comparator<Person>//TreeSet中TreeSet(Comparator<? super E> comparator) ； Comparator<? super E>  comparator()
{
	public int compare(Person s1,Person s2)
	{
		return s1.getName().compareTo(s2.getName());
	}
}

注意这里都省略了：import java.util.*;

这里毕老师当年没讲好，挺乱的，最后发现其实就是上面两句话。
就是这样，最后：泛型限定适用于泛型扩展。

记录如上。