为什么要用泛型

有这么一个需求

希望可以输出一个点的坐标，做为一个点的坐标，可以使用整型(1,2)也可以使用float型(1.0,2.0)

当然也可以使用字符串型(北纬30度，东经120度)

/*
 * 可以根据转入参数的内型不同
 * 重载getPoint()方法
 * 
 */
public class Point {
	
	public String getPoint(int x , int y ){
		return "x的坐标：" + String.valueOf(x) + "; y的坐标: " + String.valueOf(y);
	}
	public String getPoint(float x , float y ){
		return "x的坐标：" + String.valueOf(x) + "; y的坐标: " + String.valueOf(y);
	}
	public String getPoint(String x , String y ){
		return "x的坐标：" + String.valueOf(x) + "; y的坐标: " + String.valueOf(y);
	}
	
	public static void main(String[] args) {
		Point p = new Point();
		System.out.println(p.getPoint(1, 2));
		System.out.println(p.getPoint(1.0f, 2.0f));
		System.out.println(p.getPoint("北纬30度", "东经120度"));
	}
}

但是这样的设计又不是很好，通常我们都会在构造函数里面就进行了初使化的赋值

此类可以修改成这样

package com.ryan;
/*
 *为了保证可以接收任何传入的参数
 *使用Object类来接收
 */
public class Point {
	
	private Object x;
	private Object y;
	
	public Object getX() {
		return x;
	}

	public Object getY() {
		return y;
	}
	
	public Point(Object x , Object y) {
		this.x = x;
		this.y = y;
	}
	public String getInfo() throws Exception {
		if(x instanceof Integer && y instanceof Integer) {
			int x = (Integer) this.getX();//  将Object转为Integer可以完成自动拆箱
			int y = (Integer) this.getY();
			return "x的坐标为：" + x + "; y的坐标为" + y;
		}else if(x instanceof Float && y instanceof Float) {
			float x = (Float) this.getX();
			float y = (Float) this.getY();
			return "x的坐标为：" + x + "; y的坐标为" + y;
		}else if(x instanceof String && y instanceof String) {
			String x = (String) this.getX();
			String y = (String) this.getY();
			return "x的坐标为：" + x + "; y的坐标为" + y;
		}
		throw new Exception();
	}
	public static void main(String[] args) {
		try {
			Point p1 = new Point(1,2); // 自动装箱将int --->Integer---->Object
			Point p2 = new Point(1.0f,2.0f);
			Point p3 = new Point("北纬30度","东经120度");
			System.out.println(p1.getInfo());
			System.out.println(p2.getInfo());
			System.out.println(p3.getInfo());
		} catch (Exception e) {
			System.out.println("传入的参数有问题");
			e.printStackTrace();
		}
	}
}

上述方法虽然整体设计好了一些，但是还是不能控制外部传入的参数的类型

都是需要依靠类的内部来判断外部转入的内类，并且要进行对象

之前不断的转换，只有在运行时才能发现错误。

如果利用的是泛型，这个设计可以改成这样

/*
 *使用泛型将参数控制权交给用户
 *你需要什么样的类型，就new出什么
 *类型，可以完全控制参数的类型
 *代码表的简洁易懂多了
 */
public class Point<T> {
	
	private T x;
	private T y;
	
	public T getX() {
		return x;
	}

	public T getY() {
		return y;
	}
	
	public Point(T x , T y) {
		this.x = x;
		this.y = y;
	}
	
	public String getInfo(){
		return "x的坐标为：" +this.getX() + "; y的坐标为：" + this.getY();
	}

	public static void main(String[] args) {
		Point<Integer> p1 = new Point<Integer>(1,2);
		Point<Float> p2 = new Point<Float>(1.0f,2.0f);
		Point<String> p3 = new Point<String>("北纬30度","东经120度");
		System.out.println(p1.getInfo());
		System.out.println(p2.getInfo());
		System.out.println(p3.getInfo());
	}
}