java泛型知识整理

一、泛型基本概念
1、什么是泛型
泛型就是参数化类型，使用广泛的类型；声明时使用泛型，使用时指定具体类型

2、泛型常见的字母及对应含义
T ：Type表示类型
K V：分别表示键值对中的key和value
E：表示Element元素类型
? ：表示不确定的类型

3、泛型的优点：省心、安全
（1）安全：在编译时检查类型安全
（2）省心：所有的强制转换都是自动和隐式的，同一套代码可以用于多种数据类型，提高代码的重用率

public class Student<T1,T2> {
	private T1 name;
	private T2 age;
	
	
	public T1 getName() {
		return name;
	}

	public void setName(T1 name) {
		this.name = name;
	}

	public T2 getAge() {
		return age;
	}

	public void setAge(T2 age) {
		this.age = age;
	}

	public static void main(String[] args) {
		//使用时指定类型
		Student<String,Integer> stu = new Student<String,Integer>();
		//安全：类型检查
		stu.setName("张三");
		//stu.setAge("20");  类型检查报错
		//省心：类型转换
		String str = stu.getName();
	}
	
}

4、泛型类
泛型类：定义类时使用泛型，使用时确定类型
注意事项：
1、泛型声明时不能使用在静态属性和静态方法上（因为静态方法属性在编译时确定类型）
2、泛型字母只能使用引用类型，不能使用基本类型

package cn.cjy.generics;
/**
 * 泛型类：定义类时使用泛型，使用时确定类型
 * 1、泛型声明时不能使用在静态属性和静态方法上（因为静态方法属性在编译时确定类型）
 * 2、泛型字母只能使用引用类型，不能使用基本类型
 */
public class Student<T1,T2> {
	private T1 name;
	private T2 age;
	
	
	public T1 getName() {
		return name;
	}

	public void setName(T1 name) {
		this.name = name;
	}

	public T2 getAge() {
		return age;
	}

	public void setAge(T2 age) {
		this.age = age;
	}


	public static void main(String[] args) {
		//使用时指定类型
		Student<String,Integer> stu = new Student<String,Integer>();
		//安全：类型检查
		stu.setName("张三");
		//stu.setAge("20");  类型检查报错
		//省心：类型转换
		String str = stu.getName();
	}
	
}

5、泛型接口
接口中，泛型字母只能使用在方法中，不能使用在全局常量中

/**
 * 泛型接口：接口中，泛型字母只能使用在方法中，不能使用在全局常量中
 *
 */
public interface Comparator<T> {
	void comparator(T t); 
}

6、泛型方法
泛型方法<>:定义在返回类型前面
1、只能访问对象信息，不能修改对象信息
2、extends <=：表示T只能是Closeable及其子类 （…表示可变参数）

package cn.cjy.generics;

import java.io.Closeable;
import java.io.IOException;

/**
 * 泛型方法<>:定义在返回类型前面
 * 1、只能访问对象信息，不能修改对象信息
 * 2、extends <=：表示T只能是Closeable及其子类  （...表示可变参数）
 * 
 */
public class MethodTest {
	public static void main(String[] args) {
		test("测试"); // T-->String
	}
	
	//泛型方法
	public static <T> void test(T t){
		System.out.println(t);
	}
	
	//extends <=：表示T只能是Closeable及其子类  （...表示可变参数）
	public static <T extends Closeable> void test(T... t){
		for(T temp:t){
			try {
				if(null!=temp){
					temp.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

}

二、泛型的使用
1、父类为泛型类的继承
（1）属性类型：在父类中属性类型随父类定，在子类中属性类型随子类定
（2）重写方法类型：随父类而定
（3）泛型擦除：要么子类、父类同时擦除，要么子类>=父类类型，不能子类擦除父类泛型
a、继承或实现不指定类型
b、使用时不指定类型，统一Object类型对待，但是不完全等同于Object，编译时不会类型检查

package cn.cjy.generics;
/**
 * 父类为泛型类
 * 1、属性
 * 2、方法
 *泛型擦除：要么子类、父类同时擦除，要么子类>=父类类型，不能子类擦除父类泛型
 *1、属性类型：在父类中属性类型随父类定，在子类中属性类型随子类定
 *2、重写方法类型：随父类而定
 */
public abstract class Father<T,T1> {
	T name;
	public abstract void test(T t);
}
/**
 * 子类声明时指定具体类型
 * 1、属性类型为具体类型
 * 2、方法类型为具体类型
 */
class child1 extends Father<String,Integer>{
	String str;
	@Override
	public void test(String t) {
		
	}
}

/**
 * 子类为泛型类,类型在使用时确定
 * 子类的泛型个数大于等于父类,父类有的子类都要要
 * 
 */
class child2<T,T1,T2> extends Father<T,T1>{
	T1 t1;
	@Override
	public void test(T t) {
	}
}

/**
 * 泛型的擦除：子类为泛型类,父类不指定类型，重写方法使用Object替换泛型
 * 
 */
class child3<T,T1> extends Father{
	T1 t1;
	@Override
	public void test(Object t) {		
	}
}

/**
 * 子类与父类泛型同时擦除：子类为泛型类,父类不指定类型，重写方法使用Object替换泛型
 * 
 */
class child4 extends Father{
	String name;
	@Override
	public void test(Object t) {		
	}
}

/**
 * 子类擦除,父类使用泛型：错误的使用
 * 
class child4 extends Father<T,T1>{
	String name;
	@Override
	public void test(Object t) {		
	}
}
 */

2、泛型接口的实现

package cn.cjy.generics;
/**
 * 泛型接口
 * 重写方法类型随父类而定
 *
 */
public interface Comparator01<T> {
	void compare(T t);
}
//声明子类指定具体类型
class test implements Comparator01<String>{

	@Override
	public void compare(String t) {		
	}
	
}

//父类子类同事擦除
class test1 implements Comparator01{

	@Override
	public void compare(Object t) {
		
	}	
}

//父类擦除，子类泛型
class test2<T> implements Comparator01{

	@Override
	public void compare(Object t) {
		
	}	
}

//子类泛型>=父类泛型
class test3<T,T1> implements Comparator01<T>{

	@Override
	public void compare(T t) {
		
	}	
}

3、泛型实现多态效果：使用通配符？

（1）多态，泛型没有多态！

package cn.cjy.generics;
/**
 * 多态
 * 1、形参多态
 * 3、返回类型多态
 *
 */
public class Fruit {
	
}

class Apple extends Fruit{
	
}

class Test{
	public static void main(String[] args) {
		Fruit f = new Apple();
	}
	//形参使用多态
	public static void test1(Fruit t){
		
	}
	
	//返回类型使用多态
	public static Fruit test2(){
		return new Apple();
	}
}

（2）泛型使用通配符？
a、类型不定，使用时确定类型
b、可以用在声明类型、声明方法参数上，不能用在声明类上或者使用时
c、可以接收泛型的任意类型，只能接收和输出，不能修改
d、？ extends 泛型上限 <= 指定类型为自身或子类
e、？ super 泛型下限 >= 指定类型为自身或父类

package cn.cjy.generics;
/**
 * 通配符?的使用:
 * 1、类型不定，使用时确定类型
 * 2、可以用在声明类型、声明方法参数上，不能用在声明类上或者使用时
 * 3、可以接收泛型的任意类型，只能接收和输出，不能修改
 * 4、？ extends 泛型上限  <=
 * 5、？ super 泛型下限   >=
 *
 */
public class StudentTest<T> {
	T score;
	
	public static void main(String[] args) {
		StudentTest<?> stu = new StudentTest<String>();
		test(new StudentTest<String>());
		test1(new StudentTest<Apple>());  //类似与多态的效果
		//test2(new StudentTest<Apple>());  报错，泛型没有多态
		test3(new StudentTest<Object>()); 
	}
	
	public static void test(StudentTest<?> stu){
		
	}
	
	public static void test1(StudentTest<? extends Fruit> stu){
		
	}
	
	public static void test2(StudentTest<Fruit> stu){
		
	}
	
	public static void test3(StudentTest<? super Fruit> stu){
		
	}
}

4、泛型嵌套

package cn.cjy.generics;
/**
 * 泛型嵌套 
 * 
 */
public class TestNest<T> {
	T stu;
	public static void main(String[] args) {
		//泛型的嵌套
		TestNest<StudentTest<String>> test = new TestNest<StudentTest<String>>();
		//从外到内拆封
		test.stu = new StudentTest<String>();
		StudentTest<String> stu = test.stu;
		String score = stu.score;
		System.out.println(score);
	}
}

三、注意事项
1、泛型没有多态
2、没有泛型数组，声明可以使用，不能创建泛型数组

四、instanceof用法总结
instanceof用于测试左边的对象是否是右边的类或其子类的实例，返回 boolean 的数据类型

package cn.cjy.generics;
/**
 * instanceof的用法
 */
import java.util.ArrayList;
import java.util.List;
import java.util.Vector;
 
public class TestInstanceof {
 
	public static void main(String[] args) {
		
	   List list = new ArrayList();
	   test(list);
	}
    public static void test(Object o) {
		if (o instanceof Vector){
			System.out.println("对象是 Vector类的实例");
		}
		else if (o instanceof ArrayList){
			System.out.println("对象是ArrayList类的实例");
		}
		else{
			System.out.println("对象是 " + o.getClass() + " 类的实例");
		}
    }
}