JAVA泛型

泛型是为了指在定义类的时候不指定数据的类型，在使用的时候指定数据类型。

class Person <T>{
	private T name;
	private T age;
	public T getName() {
		return name;
	}
	public void setName(T name) {
		this.name = name;
	}
	public T getAge() {
		return age;
	}
	public void setAge(T age) {
		this.age = age;
	}
}
Person <String> p = new Person<String>();
		p.setAge("10");
		p.setName("小明");

通配符：？ 表示可以接受任意类型的数据类型，即方法中参数的类型不确定，但是希望能接受所有类型，与设置参数类型为Object不同

class Person <T>{
	private T name ;
	public void setName(T string) {
		this.name = string;
	}
	public T getName() {
		return this.name;
	}
}
public class Hello {
	public static void main(String[] args) {
		Person <Integer> p1 = new Person<Integer>();
		p1.setName(123);
		Person <String> p2 = new Person<String>();
		p2.setName("小明");
		Hello h = new Hello();
		h.changeName(p1);
		h.changeName(p2);
	}
	public void changeName(Person<?> p) {
		System.out.println(p.getName());
	}
}

输出的是：123

                  小明

如果在changeName方法里面加一个setName(123);会报错，因为不能确定p的数据类型是不是123

在上面如果不加通配符<?>,那么即默认的p接受的是Object类型，如果在changeName方法里面加一个setName(123)不会报错，因为123是Integer类型属于Object类型

即会输出：123

     123

泛型上限：？extends 类型，只能接受类型或者类型的子类，可以用在方法或者类型的声明上

class Person <T extends Number>{
	private T name ;
	public void setName(T name) {
		this.name = name;
	}
	public T getName() {
		return this.name;
	}
}
public class Hello {
	public static void main(String[] args) {
		Person <Integer> p1 = new Person<Integer>();
		p1.setName(123);
		Person <Double> p2 = new Person<Double>();
		p2.setName(456.23);
		Hello h = new Hello();
		h.changeName(p1);
		h.changeName(p2);
	}
	public void changeName(Person<?> p) {
		System.out.println(p.getName());
	}
}

泛型下限：？super类型，只能接受类型或者类型的父类，只能用在参数上

class Person <T>{
	private T name ;
	public void setName(T name) {
		this.name = name;
	}
	public T getName() {
		return this.name;
	}
}
public class Hello {
	public static void main(String[] args) {
		Person <Integer> p1 = new Person<Integer>();
		p1.setName(123);
		Person <Object> p2 = new Person<Object>();
		p2.setName("小明");
		Hello h = new Hello();
		h.changeName(p1);
		h.changeName(p2);
	}
	public void changeName(Person<? super Integer> p) {
		System.out.println(p.getName());
	}
}	

泛型接口

1.在使用时给出具体的类型

interface Person<T>{
	public void print(T t);
}
class Student<T> implements Person<T>{
	public void print(T t) {
		System.out.println(t);	
	}
}
public class Hello {
	public static void main(String[] args) {
		Person <String>p = new Student<String>();
		p.print("学生");
	}
}

2.在类定义时给出具体的类型

interface Person<T>{
	public void print(T t);
}
class Student implements Person<String>{
	public void print(String t) {
		System.out.println(t);	
	}
}
public class Hello {
	public static void main(String[] args) {
		Person<String> p = new Student();
		p.print("学生");
	}
}

泛型方法：

public class Hello {
	public static void main(String[] args) {
		System.out.println(Hello.print(123));
		System.out.println(Hello.print("name"));
	}
	public static <T>T print(T name) {       //<T>是声明了T是泛型
		return name;
	}
}