Java——泛型

Java数据类型（type）可以分为两大类：基本类型（直接包含值）和引用类型（引用对象）

基本数据类型：

   numeric:byte、short、int、long、char
   floating-point:float、double、boolean

引用类型：class interface array null

引入：

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

例如
public void write(Integer i, Integer[] ia);
public void write(Double  d, Double[] da);
的范型版本为
public <T> void write(T t, T[] ta);

命名：

 * 定义的泛型类，特点是类名后有<T> 
 * T：可以是任意大写字母，
 * 一般：
 *  E — Element，常用在java Collection里，如：List<E>,Iterator<E>,Set<E>
 *  K,V — Key，Value，代表Map的键值对
 *  N — Number，数字
 *  T — Type，类型，如String，Integer等等

一、demo1:创建不同类型的点并输出

定义一个点：

public class Point<T> {
	private T x;
	private T y;

	public Point() {
	}
	public Point(T x, T y) {
		super();
		this.x = x;
		this.y = y;
	}
	public T getX() {
		return x;
	}
	public void setX(T x) {
		this.x = x;
	}
	public T getY() {
		return y;
	}
	public void setY(T y) {
		this.y = y;
	}
	
	@Override
	public String toString() {
		return "Point [x=" + x + ", y=" + y + "]";
	}
}

public class PointTRun {

	public static void main(String[] args) {
		Point<Integer> p = new Point<Integer>();
		p.setX(new Integer(1));
		System.out.println(p.getX() + "  " + p.getY());

		System.out.println();
		
		Point<String> pStr = new Point<String>();
		pStr.setX("13com");
		pStr.setY("20cm");
		System.out.println(pStr.getX() + "  " + pStr.getY());
	}
}

二、demo2: 定义泛型接口

public interface Info<T>{//在接口上定义泛型
	public T getVar();//定义抽象方法，返回值是泛型类型
	public void setVar(T x);
}

实现接口：

/**
 * InfoImp1 不是一个泛型类，因为类名后无<T>
 * 一个非泛型类在实现泛型接口时，必须给出泛型的具体数据类型
 */
public class InfoImp1 implements Info<String> {

	private String var ;
	
	public InfoImp1(String var) {
		super();
		this.var = var;
	}

	@Override
	public String getVar() {
		return this.var;
	}

	@Override
	public void setVar(String x) {
		this.var = x;
	}
}

多泛型类型的类实现接口

public class InfoImp3<T,K,U> implements Info<T> {
	private T x;
	private U var;
	private K y;
	
	public InfoImp3(T var) {
		super();
		this.x = var;
	}
	@Override
	public T getVar() {
		return x;
	}
	@Override
	public void setVar(T x) {
		this.x = x;
	}
}

调用方法：

public static void main(String[] args) {
		InfoImp1 i = new InfoImp1("hq");
		System.out.println(i.getVar());
		System.out.println("==========================");
		
		InfoImp2<String> i2 = new InfoImp2<String>("huqing-->keep move on");
		System.out.println(i2.getVar());
		System.out.println("==========================");
		
		InfoImp3<String, Double, String> i3 = new InfoImp3<String, Double, String>("hq ---> more");
		System.out.println(i3.getVar());
	}

三、泛型数组：

public class FansArray {

	public static String[] fun2(String[] str) {//接收的数组参数只能是String类型的
		return str;
	}

	public static <T> T[] fun1(T... arg) { // 接收可变参数  类似于传了一个object类型的数组参数
		return arg; // 返回泛型数组
	}

	public static void main(String[] args) {

		Integer intArray[] = fun1(1, 2, 3, 4, 5, 6);
		Integer[] result = fun1(intArray);
		for (Integer in : result) {
			System.out.print(" " + in);
		}
		System.out.println();

		String a[] = fun1("a", "b", "c", "hello");
		String[] result1 = fun1(a);
		for (String in : result1) {
			System.out.print(" " + in);
		}
		System.out.println();
		
		//创建数组getStr
		String[] dataArray = { "自己", "定义的", "数组","测试" };
		String[] getStr = fun2(dataArray);
		
		for (String in : getStr) {
			System.out.print(" " + in);
		}
		System.out.println();
	}
}

四、泛型类型比较：自定义接口，实现该接口的类进行比较

接口：

public interface Comparable<T>{
	public boolean compareTo(T i);
}

实现类：给出比较方法

public class CompareStr implements Comparable<CompareStr> {

	private String mStr;
	
	public CompareStr(String mStr) {
		super();
		this.mStr = mStr;
	}
	
	public String getmStr() {
		return mStr;
	}

	@Override
	public boolean compareTo(CompareStr i) {
		if(mStr.length() > i.mStr.length()){
			return true;
		}
		return false;
	}
}

测试： 模拟数据进行比较，实现某个方法

public class BoundType {
	public static <T extends Comparable> T min(T ...a){
		T smallest = a[0];
		for(T item: a){
			if(smallest.compareTo(item)){
				smallest = item;
			}
		}
		return smallest;
	}
	
	public static void main(String[] args) {
		CompareStr result =
				min(new CompareStr("aa"),new CompareStr("ab"),new CompareStr("bbb"),new CompareStr("a"));
		System.out.println("min:"+ result.getmStr());
	}
}

结果：min:a