Java泛型基础及应用

泛型作用： 限制加入集合中元素的类型，将类型限制为同一种类型

泛型在编译期间生效，不允许加入其他类型

一.泛型的基本应用

public class Animal{
	public String name;
	public String color;
	public Animal(String name,String color)
	{
		super();
		this.name = name;
		this.color = color;
	}
	
	public String toString()
	{
		return "Animal [name=" + name + ", color=" + color + "]";
	}
	
	}
	
public class AnimalTest
{

	public static void main(String[] args)
	{
		List<Animal> list = new ArrayList<>();
		
		Animal cat = new Animal("cat","White");
		Animal dog = new Animal("dog","black");
		Animal rabbit = new Animal("rabbit","white");
		
		list.add(cat);
		list.add(dog);
		list.add(rabbit);
		
		for(Object o : list) {      //增强for循环，遍历list，遍历出的每一个对象都用Object类型的o接收
		System.out.println(o);   //相当于‘Object o=每个对象’，父类引用指向子类对象（Object为如何子类的父类），实则为多态
		}
		
	}

}

Output:

Animal [name=cat, color=White]
Animal [name=dog, color=black]
Animal [name=rabbit, color=white]

但是加了泛型之后的遍历

for(Animal a : list) {    //遍历list，遍历出的每一个对象都用Animal类型的a接收
			System.out.println(a);
		}

二.泛型的扩展

1.泛型类

定义泛型类的语法格式

类访问修饰符  class  泛型类名 <类型参数> {
			类体
	}

类型参数可以用任何单个大写字母表示，通常使用E来表示集合元素类型，用K与V分别表示键-值对中的键类型与值类型，用T、U、S表示任意类型

1.1 创建泛型类时，类型不确定，只有在创建对象时才确定

具体实例：

public class Animal <A> {                     //在此创建了<A>的泛型类
.....
}

class Test{
	public static void main(String[] args){
             Animal<Integer> a1 = new Animal<>();   //此时A的类型为Integer
             Animal<String>  a2 = new Animal<>();   //此时A的类型为String
             .....
	}
}

2.泛型方法

图中代码，第二个方法的参数类型为A，A即为public class GenericTest< A > 中的泛型A，由于GenericTest< Integer > gt = new GenericTest<>();中已经确定< A >的类型为Integer，所以
gt调用方法时，b方法确定为Integer。
c方法，由于方法的参数类型为B，B不是public class GenericTest< A > 中的泛型A，所以在方法体内加入< B >,否则会报错。由于B的加入,B为不确定类型，即任意类型都可。
因此，c方法帮我们解决了不同数据类型做参数的重载问题。通俗而言，如果想要传入不同类型的数据，不用写不同参数类型的方法，只需写public< B > void c(B b)即可实现。

注意：

如果在方法中加入static，则b方法报错，c方法可以。
原因是，static修饰的方法存在于对象之前，由于泛型A的类型在创建对象时确定，所以a方法报错。然而，c方法不受类型限制，因此static对此方法没有限制。

2.泛型接口

泛型接口的定义格式如下：

interface 	接口名<类型参数列表>
{
...
}

在实现接口时，也应当声明与接口相同的类型参数。格式如下：

class		类名<类型参数列表>		implements 接口名<类型参数列表>
{
...
}

具体实例如下：

在实现类classA中确定了泛型A为String类型。

注意: 实现类class B中的泛型是BB不是泛型A，BB类型为不确定型，因此会报错。应当改成:class B < BB>implements GenericInterface< BB>{}

三.泛型受限

1.泛型上限：？ extends A ：只要泛型为A或A的子类都可传入

2.泛型下限：? super A : 只要泛型为A或A的父类都可传入

public class Person{
	public String name;
	public int age;
	
	public Person(String name, int age)
	{
		super();
		this.name = name;
		this.age = age;
	}

	@Override
	public String toString()
	{
		return "Person [name=" + name + ", age=" + age + "]";
	}
}

public class Student extends Person{
	public int id;

	public Student(String name, int age, int id)
	{
		super(name, age);
		this.id = id;
	}

	@Override
	public String toString()
	{
		return "Student [id=" + id + "]";
	}
}

import java.util.ArrayList;

class Test{
	public static void main(String[] args) {
		ArrayList<Person> a1= new ArrayList<Person>();
		a1.add(new Person("nana",18));
		a1.add(new Person("haha",19));
		show(a1);
		
		ArrayList<Student> a2= new ArrayList<Student>();
		a2.add(new Student("yiyi",20,1));
		a2.add(new Student("bobo",21,2));
		show(a2);
		
	}
	
	public static void show(ArrayList<? extends Person> ab) {  //泛型上限
		for(Person a : ab) {
			System.out.println(a);
		}
	}
}

Output:

Person [name=nana, age=18]
Person [name=haha, age=19]
Student [id=1]
Student [id=2]

更多精彩尽在Blog主页