【Java】泛型

目录

泛型

通配符

泛型接口

泛型方法

---

泛型

class Test <T> {
	private T x;
	private T 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;
	}
}

public class Point {

	public static void main(String[] args) {
		Test<String> t = new Test<>();
		t.setX("东京");
		t.setY("巴黎");
		String x = t.getX();
		String y = t.getY();
		System.out.println("x=" + x + ",y="+y);
	}

}

通配符

class Test <T> {
	private T x;
	private T 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;
	}
}

public class Point {
	public static void main(String[] args) {
		Test<String> t = new Test<>();
		t.setX("东京");
		t.setY("巴黎");
		fun(t);
	}
	
	//如果没有设置类型，默认类型就是Object
	public static void fun(Test t) {
		t.setX(90);
		System.out.println("t=" + t.getX());
	}
}

输出结果为"t=90"，内容“东京”被随意修改了。

在类型不确定的时候，但是又希望方法能接收所有类型，所以使用通配符”?“。通配符”?”能接收一切，但是不能修改。

class Test <T> {
	private T x;
	private T 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;
	}
}

public class Point {

	public static void main(String[] args) {
		Test<String> t = new Test<>();
		t.setX("东京");
		t.setY("巴黎");
		fun(t);
	}
	
	//此时使用的通配符“?”描述的是它可以接收任意类型，但是由于不确定类型，所以无法修改
	public static void fun(Test<?> t) {
		System.out.println("t=" + t.getX());
	}
}

输出结果为”t=东京“。

通配符”？“的两个子通配符：

• ？ extends  类：设置泛型上限

       例：?   extends Number：表示只能够设置Number或其子类，例如: Integer、Double等；

• ？ super 类：设置泛型下限

       例： ？ super String：表示只能够设置String或其父类：Object

范例：设置泛型上限

class Test <T extends Number> { //设置泛型上限
	private T x;
	private T 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;
	}
}

public class Point {

	public static void main(String[] args) {
		Test<Integer> t = new Test<>();
		t.setX(1);
		t.setY(2);
		fun(t);
	}
	
	//此时使用的通配符“?”描述的是它可以接收任意类型，但是由于不确定类型，所以无法修改
	public static void fun(Test<? extends Number> t) {
		System.out.println("t=" + t.getX());
	}
}

输出结果：t=1。

范例：设置泛型下限

class Test <T> { 
	private T x;
	private T 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;
	}
}

public class Point {

	public static void main(String[] args) {
		Test<String> t = new Test<String>();
		t.setX("Hello World!");
		fun(t);
	}
	
	//此时使用的通配符“?”描述的是它可以接收任意类型，但是由于不确定类型，所以无法修改
	public static void fun(Test<? super String> t) { //设置泛型下限
		System.out.println("t=" + t.getX());
	}
}

输出结果为：t=Hello World!

泛型接口

泛型既可以定义在类中，也可以定义在接口里，这种情况称为泛型接口。

interface IMessage<T> { //在接口上定义了泛型
	public void print(T t);
}

该接口的实现子类有两种：

• 子类定义时继续使用泛型

class MessageImpl<T> implements IMessage<T> {

	@Override
	public void print(T t) {
		// TODO Auto-generated method stub
		
	}
}

调用该方法：

interface IMessage<T> { //在接口上定义了泛型
	public void print(T t);
}


class MessageImpl<T> implements IMessage<T> {

	@Override
	public void print(T t) {
		System.out.println(t);
	}
}

public class TestDemo {

	public static void main(String[] args) {
		IMessage<String> msg = new MessageImpl<String>();
		msg.print("Hello World!");
	}
}

输出结果为：Hello World!

• 子类实现接口时明确给出具体类型

class MessageImpl implements IMessage<String> {

	@Override
	public void print(String t) { //此处的参数自动被转换为String
		// TODO Auto-generated method stub
		
	}
}

调用该方法：

interface IMessage<T> { //在接口上定义了泛型
	public void print(T t);
}


class MessageImpl implements IMessage<String> {

	@Override
	public void print(String t) {
		System.out.println(t);
		
	}
}

public class TestDemo {

	public static void main(String[] args) {
		IMessage<String> msg = new MessageImpl();
		msg.print("Hello World!");
	}
}

输出结果：Hello World！

泛型方法

public class TestDemo {
	public static void main(String[] args) {
		Integer data[] = fun(1,2,3,4);
		for(int temp: data) {//迭代和自动拆箱
			System.out.println(temp);
		}
	}
	
    //T描述的是泛型标记的声明
    public static <T> T[] fun(T ... args) {
		return args;
	}
}