Java泛型

泛型
定义：指代对象的类型，是一个模板、标签，用<>表示。
特点：放数据的时候很安全，取数据的时候很方便

import java.util.ArrayList;
import java.util.List;

public class test4 {
	public static void main(String[] args) {
		List<String>list=new ArrayList<>();//指定String类型
		list.add("abc");
		String str=list.get(0);//取得时候不需要强转为String
	}
}

注：泛型主要用于集合中，存放该类或子类

1.泛型引入
先看一个实例：定义一个C1类：里面有个Integer属性 给出构造方法 以及打印类型 和get set方法

public class C1 {
	private Integer a;

	public Integer getA() {
		return a;
	}

	public void setA(Integer a) {
		this.a = a;
	}

	public C1(Integer a) {
		super();
		this.a = a;
	}
	//打印a的类型
	public void print() {
		 System.out.println("a的类型是："+a.getClass().getName());
	}
}

类似的再定义一个C2类，里面定义一个String类型属性

public class C2 {
	private String a;

	public String getA() {
		return a;
	}

	public void setA(String a) {
		this.a = a;
	}

	public C2(String a) {
		super();
		this.a = a;
	}
	//打印a的类型
	public void print() {
		System.out.println("a的类型是："+a.getClass().getName());
	}
}

接着写个测试类

public class test5 {
	public static void main(String[] args) {
		//测试C1
		C1 c1=new C1(1);
		c1.print();
		int i=c1.getA();
		System.out.println("a="+i);
		
		//测试C2
		C2 c2=new C2("abc");
		c2.print();
		String str=c2.getA();
		System.out.println("a="+str);
	}
}

运行结果

假如有100个类型，类似的我们要写100个类似的类，很麻烦，这时候我们会想到多态，我们将代码改写下：
用一个类实现：因为所有类都继承自Object类，所以直接定义成Object类型的属性；

public class C12 {
	private Object object;

	public Object getObject() {
		return object;
	}

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

	public C12(Object object) {
		super();
		this.object = object;
	}
	//打印object的类型
	public void print() {
		 System.out.println("object的类型是："+object.getClass().getName());
	}
}

接着写下测试类

public class test6 {
	public static void main(String[] args) {
		C12 c1=new C12(1);// 向上转型
		c1.print();
		int i=(int) c1.getObject();// 向下转型
		System.out.println("a="+i);
		
		C12 c2=new C12("acb");// 向上转型
		c2.print();
		String str=(String) c2.getObject();// 向下转型
		System.out.println("str="+str);
	}
}

运行结果

我们发现测试类里需要转型，类简便了，但是测试类复杂了，有没有一种类简单，测试也简单的方式呢，这时候，泛型诞生了。

我们先定义一个泛型类

//定义泛型类
public class CC <T>{
	private T ob;//泛型+属性

	public T getOb() {
		return ob;
	}

	public void setOb(T ob) {
		this.ob = ob;
	}

	public CC(T ob) {
		super();
		this.ob = ob;
	}
	//打印T的类型
	public void print() {
		System.out.println("T的实际类型是："+ob.getClass().getName());
	}
}

用指代任意类型，当然也可以用其他字母，但是一般用T，Type的意思

接下来写个测试类

public class test7 {
	public static void main(String[] args) {
		CC<Integer> c=new CC<>(1);
		c.print();
		int i=c.getOb();// 不需要类型转型
		System.out.println("a="+i);
		
		CC<String> c1=new CC<>("abc");
		c1.print();
		String str=c1.getOb();// 不需要类型转型
		System.out.println("str="+str);
	}
}

运行结果：

注：
1.<>中通常是能见名知意的单个大写字母，如：
Type ---------> T
Key Value--------> K V
Element-------------> E
2.泛型用在属性前，但属性不能是静态属性和基本数据类型。

2.泛型上限
前面我们讲的泛型，可以是任意类型，但是我们有时候，需要限制类型，这样更加安全
泛型上限（<=）通过extends关键字来实现
下面通过一个实例来理解，新建一个Animal类，在定义两个子类Cat和Dog

public class Animal {
	public void print() {
		System.out.println("我是一只动物");
	}
}

public class Cat extends Animal{
	public void print() {
		System.out.println("我是一只猫");
	}
}

public class Dog extends Animal{
	public void print() {
		System.out.println("我是一只狗");
	}
}

然后我们定义一个泛型类

public class Demo <T extends Animal>{
	private T ob;

	public T getOb() {
		return ob;
	}

	public void setOb(T ob) {
		this.ob = ob;
	}

	public Demo(T ob) {
		super();
		this.ob = ob;
	}
	public void print() {
		System.out.println("T的类型是："+ob.getClass().getName());
	}
}

这里我们要求 类型只能是Animal类或者Animal类的子类
我们写个测试类

public class test8 {
	public static void main(String[] args) {
		Demo<Dog> d1=new Demo<>(new Dog());
		Dog dog=d1.getOb();
		dog.print();
		
		Demo<Cat> d2=new Demo<>(new Cat());
		Cat cat=d2.getOb();
	    cat.print();
	    
	    Demo<Animal> d3=new Demo<>(new Animal());
	    Animal animal=d3.getOb();
	    animal.print();
	}
}

运行结果

3.泛型下限
同理，泛型下线通过super关键字来实现

4.通配符泛型
通配符泛型用?来表示。

作用：当不知道类型时，用于声明变量或形参，不能用于创建对象、泛型类、泛型接口和泛型方法上

接着上诉的代码，我们写个测试类

public class test9 {
	public static void take(Demo<?>a) {
		a.print();
	}
	public static void main(String[] args) {
		Demo<Dog>dog=new Demo<>(new Dog());
		take(dog);
		
		Demo<Cat>cat=new Demo<>(new Cat());
		take(cat);
		
		Demo<Animal> animal=new Demo<>(new Animal());
	    take(animal);
	}
}

运行结果

5.自定义泛型
（1）泛型类

public class MyStudent <T>{
	private T ob;//泛型用在属性前，不能是静态属性和基本数据类型
}

（2）泛型接口

public interface Comparator <T>{
	int MAX_VALUE=1024;//不能用在常量前
	T compare(T t);//用在方法亲
}

（3）泛型方法

public class test10 {
	public static <T>void f(T t){//用在void前
		 System.out.println("T的类型是："+t.getClass().getName());
	}
	
	public static void main(String[] args) {
		f(" ");
		f(1);
		f(1.0f);
		f("acb");
	}
}

运行结果

6.泛型嵌套
泛型里面套泛型

School<Student<String>>s=new School<Student<String>>();//由外到内
Student<String> stu=new Student<String>();

注：
（1）泛型没有多态和数组
（2）

List <T>list=new ArrayList<T>();//后面的T可以省略不写