因为集合的中存放的数据类型不固定，在往集合中存放元素时容易因为数据类型不一致的问题导致安全隐患，于是 Java 推出了泛型用于规范集合的数据类型。

定义泛型类

  • 在定义带类型参数的类时，在紧跟类名之后 <> 内，指定一个或多个类型参数的名字，同时也可以对类型参数的取值范围进行限定，多个类型参数之间用逗号分隔。
  • 定义完类型参数后，可以在定义位置之后的几乎任意地方（静态块， 静态属性，静态方法除外）使用类型参数，就像使用普通的类型一样。
  • 注意， 父类定义的类型参数不能被子类继承。

普通定义类：

public class Demo {
	
	private Object object;
	
	public Demo(Object object) {
		this.object = object;
	}

	public Object getObject() {
		return object;
	}

	public void setObject(Object object) {
		this.object = object;
	}
	
}

 定义泛型类：

public class Demo<T> {
	
	private T object;
	
	public Demo(T object) {
		this.object = object;
	}

	public T getObject() {
		return object;
	}

	public void setObject(T object) {
		this.object = object;
	}
	
}

使用泛型类：

public static void main(String[] args) {
	Demo<Integer> demo = new Demo<Integer>(233);
	Demo<String> demo2 = new Demo<String>("诶嘿~");
	Demo<Double> demo3 = new Demo<Double>(13.14);
	System.out.println(demo.getObject());
	System.out.println(demo2.getObject());
	System.out.println(demo3.getObject());
}

结果：

233
诶嘿~
13.14

定义泛型方法

  • 在定义带类型参数的方法时，紧跟可见范围修饰（例如 public ）之后的 <> 内，指定一个或多类型参数的名字， 同时也可以对类型参数的取值范围进行限定，多个类型参数之间用逗号分隔。

 定义普通方法：

public static void print(Object[] objects) {
	for(Object object: objects) {
		System.out.print(object);
	}
}

定义泛型方法：

public static <T> void print(T[] ts) {
	for(T t: ts) {
		System.out.print(t);
	}
}

使用泛型方法：

public static void main(String[] args) {
	Integer[] nums = new Integer[]{1, 1, 4, 5, 1, 4};
	print(nums);
	String[] strings = new String[]{"诶", "嘿", "哈哈哈哈"};
	print(strings);
}

结果：

114514诶嘿哈哈哈哈

定义泛型接口：

  • 在定义带类型参数的接口时，在紧跟接口名之后 <> 内，指定一个或多个类型参数的名字，同时也可以对类型参数的取值范围进行限定，多个类型参数之间用逗号分隔。
  • 接口中不能使用泛型来定义成员属性。

定义普通接口：

interface Animal{
	
	public Object call();
	
	public Object eat(Object food);
	
}

定义泛型接口：

interface Animal<T>{
	
	public T call();
	
	public T eat(T food);
	
}

使用泛型接口：

public class Demo {
	
	public static void main(String[] args) {
		Cat cat = new Cat();
		System.out.println(cat.call());
		System.out.println(cat.eat("鱼"));
		
		Dog dog = new Dog();
		System.out.println(dog.call());
		System.out.println(dog.eat(111));
	}
}

class Cat implements Animal<String>{

	@Override
	public String call() {
		return "喵喵喵喵喵喵";
	}

	@Override
	public String eat(String food) {
		return food;
	}
}

class Dog implements Animal<Integer>{

	@Override
	public Integer call() {
		return 555555;
	}

	@Override
	public Integer eat(Integer food) {
		return food;
	}
}

结果：

喵喵喵喵喵喵
鱼
555555
111