泛型

产生背景

范例：定义pointer类

class point{
	private Object x;
	private Object y;
	public Object getX() {
		return x;
	}
	public void setX(Object x) {
		this.x = x;
	}
	public Object getY() {
		return y;
	}
	public void setY(Object y) {
		this.y = y;
	}
}

范例：坐标为整数

public class Hello{
	public static void main(String args[]) {
		//第一步：设置坐标数据
		Point p = new Point();
		p.setX(10);
		p.setY(20);
		//第二步：取得坐标
		int x = (Integer) p.getX();
		int y = (Integer) p.getY();
		System.out.println("x="+x+",y="+y);
	}
}

x=10,y=20

范例：保存小数

public class Hello{
	public static void main(String args[]) {
		//第一步：设置坐标数据
		Point p = new Point();
		p.setX(10.1);
		p.setY(20.1);
		//第二步：取得坐标
		double x = (Double) p.getX();
		double y = (Double) p.getY();
		System.out.println("x="+x+",y="+y);
	}
}

x=10.1,y=20.1

范例：保存字符串

public class Hello{
	public static void main(String args[]) {
		//第一步：设置坐标数据
		Point p = new Point();
		p.setX("东经180度");
		p.setY("北纬30度");
		//第二步：取得坐标
		String x = (String) p.getX();
		String y = (String) p.getY();
		System.out.println("x="+x+",y="+y);
	}
}

x=东经180度,y=北纬30度

以上代码的确满足了开发要求，但最严重的问题也产生了。整个代码的实现关键在于利用了Object类型，利用Object操作的优点在于可以接收所有的数据类型。但是缺点也是由优点造成的，表现在Object如果要接收数据必须进行强制性的向下转型。
范例：可能带来的隐患

public class Hello{
	public static void main(String args[]) {
		//第一步：设置坐标数据
		Point p = new Point();
		p.setX(100);//理论上要保存String
		p.setY("北纬30度");
		//第二步：取得坐标
		String x = (String) p.getX();
		String y = (String) p.getY();
		System.out.println("x="+x+",y="+y);
	}
}

以上代码本质上讲一定会存在问题，但是现在的程序明显无法发现问题，因为Object本身就可以存Integer，但是这个代码是在项目执行的时候出错。
现在发现，向下转型本身就会存在有安全隐患，而且这种隐患是不能够在编译的时候检查出来的。传统的利用Object类进行处理的永远都会有这样的问题。
解决：不进行对象的向下转型，这样就打破了Object的优势，于是产生了泛型。
泛型本质：动态绑定数据类型
范例：使用泛型

class Point<T>{//T:Type  P:Param  R:Return
	private T  x;
	private T y;
	public T getX() {
		return x;
	}
	public void setX(T x) {
		this.x = x;
	}
	public Object getY() {
		return y;
	}
	public void setY(T y) {
		this.y = y;
	}
}

范例：使用泛型实例化类对象

public class Hello{
	public static void main(String args[]) {//throws Exception
		//第一步：设置坐标数据
		Point <String> p = new Point<String>();
		p.setX("东经100度");
		p.setY("北纬20度");
		//第二步：取得坐标
		String x = p.getX();
		String y = p.getY();
		System.out.println("x="+x+",y="+y);
	}
}

如果在应用了泛型技术的类使用的时候没有设置泛型类型，JDK默认也不会认为他出现了语法错误，也能够正常执行，同时使用Object作为默认类型

通配符:?

现在假设有如下的一个泛型类：

class Message<T>{
	private T info;
	public void setInfo(T info){
		this.info=info;
	}
	public T getInfo(){
		return info;
	}
}

范例： 编写代码

public class Hello{
	public static void main(String args[]) {
		Message<String> msg = new Message<String>();
		fun(msg);
		System.out.println(msg.getInfo());
	}
	public static void fun(Message<String> temp){
		temp.setInfo("HELLO");
	}
}

这个时候fun()方法将不能使用，并且由于重载是受到参数类型而不是泛型类型的限制，那么也无法通过重载来解决此问题，可是这样的问题怎么解决呢？那么现在就必须有一种类型可以接收全部的泛型种类。方法里面不用泛型声明。
范例：不使用泛型，则用Object描述

public class Hello{
	public static void main(String args[]) {
		Message<String> msg = new Message<String>();
		fun(msg);
		System.out.println(msg.getInfo());
	}
	public static void fun(Message temp){
		temp.setInfo("世界和平O");
	}
}

范例：使用通配符描述

class Message<T>{
	private T info;
	public void setInfo(T info){
		this.info=info;
	}
	public T getInfo(){
		return info;
	}
}
public class Hello{
	public static void main(String args[]) {
		Message<Integer> msg = new Message<Integer>();
		msg.setInfo(1000);
		fun(msg);
	}
	public static void fun(Message<?> temp){
		System.out.println(temp.getInfo());
	}
}

范例：设置泛型的上限

class Message<T extends Number>{
	private T info;
	public void setInfo(T info){
		this.info=info;
	}
	public T getInfo(){
		return info;
	}
}
public class Hello{
	public static void main(String args[]) {
		Message<Integer> msg = new Message<Integer>();
		msg.setInfo(1000);
		fun(msg);
	}
	public static void fun(Message<?extends Nunber> temp){
		System.out.println(temp.getInfo());
	}
}

范例：设置泛型的下限

class Message<T>{
	private T info;
	public void setInfo(T info){
		this.info=info;
	}
	public T getInfo(){
		return info;
	}
}
public class Hello{
	public static void main(String args[]) {
		Message<String> msg = new Message<String>();
		msg.setInfo("1000");
		fun(msg);
	}
	public static void fun(Message<?super String> temp){
		System.out.println(temp.getInfo());
	}
}

看文档时能看懂。

泛型接口（重点）

在接口用泛型就是泛型接口。

interface IMessage<T>{//接口：IXxxx、抽象类：AbstractXxxx、普通类：直接写
	public void print(T t);//此方法上使用了泛型
}

此时实现了泛型接口，但是对于泛型接口的子类实现有两种：

• 模式一：在子类继续使用泛型声明。

interface IMessage<T>{//接口：IXxxx、抽象类：AbstractXxxx、普通类：直接写
	public void print(T t);//此方法上使用了泛型
}	
class MessageImpl<P> implements IMessage<P>{
	public void print(P t){
		System.out.println(t);
	}
}
public class Hello{
	public static void main(String args[]) {
		IMessage<String> msg=new MessageImpl<String>();
		msg.print("Hello");
	}
}

• 模式二：在子类定义时不使用泛型，直接为父接口设置好泛型类型。

interface IMessage<T>{//接口：IXxxx、抽象类：AbstractXxxx、普通类：直接写
	public void print(T t);//此方法上使用了泛型
}	
class MessageImpl implements IMessage<String>{
	public void print(String t){
		System.out.println(t);
	}
}
public class Hello{
	public static void main(String args[]) {
		IMessage<String> msg=new MessageImpl();
		msg.print("Hello");
	}
}

后续学习的时候一定会出现泛型接口的使用，要清楚它的两种实现模式。

泛型方法

如果在一个方法上使用了泛型，那么这个方法就称为泛型方法。

interface IMessage<T>{//接口：IXxxx、抽象类：AbstractXxxx、普通类：直接写
	public void print(T t);//此方法上使用了泛型
}

泛型方法不一定非要定义在泛型声明的类中，也可能就是一个方法定义为泛型方法。
范例：泛型方法

public class Hello{
	public static void main(String args[]) {
		Integer num[]=fun(1,2,3);//泛型操作
		for (Integer temp : num){
			System.out.println(temp);
		}
	}
	public static <T> T[] fun(T...arg){//声明并使用泛型
		return arg;
	}
}

从现实来讲，泛型方法能看懂就好，别用。

总结