总结泛型类、泛型方法和泛型接口的用法以及泛型擦除的内容

泛型：在类定义的时候并不会设置类中的属性或方法中的参数的具体类型，而是在类使用时再具体定义

JDK引入泛型的目的:

1.用于检测编译器参数类型设置问题：只有传入参数与使用时定义类型一致才可设置

2.取消向下转型所带来的隐患。

泛型的基本语法：

class MyClass<T>{
	T value;
}

尖括号 < >中的T被称作是类型参数，用于指代任何类型，实际上T可以任意写，也可以是A，出于规范，建议用单个的大写字母来代替类型参数。如：

：T代表一般的类

：E代表Element,或者Exception异常的意思

：K代表key

：V代表Value,通常和K一起配合使用。

：S代表Subtype

如果一个类被<T>的形式定义，那么它就被称为是泛型类。使用泛型类

class MyClass<T>{
	T value;
}
class MyClass1<T>{
	T value;
}
public class Test3 {
	public static void main(String[] args) {
		MyClass<String> myClass=new MyClass<>();
		MyClass1<Integer> myClass1=new MyClass1<>();
	}
}

泛型类引用多个类型参数及使用

class MyClass<T,E>{
	T value;
	E value2;
}
public class Test3 {
	public static void main(String[] args) {
		MyClass<String,Integer> myClass=new MyClass<>();
	}
}

使用泛型定义point类

class Point<T>{
	private T x;
	private T y;
	public T getX() {
		return x;
	}
	public void setX(T x) {
		this.x = x;
	}
	public T getY() {
		return y;
	}
	public void setY(T y) {
		this.y = y;
	}
}
public class Test3 {
	public static void main(String[] args) {
		Point<String> point=new Point<>();
		point.setX("东经80度");
		point.setY("北纬80度");
		String x=point.getX();
		String y=point.getY();
		System.out.println("x :"+x+"y:"+y);
	}
}

 泛型方法：

class Point<T>{
	public <T> void testMethod(T t) {
		System.out.println(t);
	}
}

下面代码中，Myclass<T>是泛型类，testMethod1是泛型类中的普通方法，而testMethod2是泛型方法，泛型类中的类型参数与泛型方法中的类型参数是没有相应联系的，泛型方法始终以自己定义的参数类型为准。

泛型类的实际类型参数为string，泛型方法中的实际类型参数为Interger，两者互不相干。 

class MyClass<T>{
	public void testMethod(T t) {
		System.out.println(t);
	}
	public <T> T testMethod2(T t) {
		return t;
	}
}
public class Test3 {
	public static void main(String[] args) {
		MyClass<String> myClass=new MyClass<>();
		myClass.testMethod("hello");
		Integer i=myClass.testMethod2(100);
		System.out.println(i);
	}
}

 但是为了避免混淆，如果一个泛型类中存在泛型方法，那么两者的类型参数最好不要同名。

将代码改为下面的样子：

T：代表String 型

E：代表Integer型

class MyClass<T>{
	public void testMethod(T t) {
		System.out.println(t);
	}
	public <E> E testMethod2(E e) {
		return e;
	}
}
public class Test3 {
	public static void main(String[] args) {
		MyClass<String> myClass=new MyClass<>();
		myClass.testMethod("hello");
		Integer i=myClass.testMethod2(100);
		System.out.println(i);
	}
}

 通配符：（重点）

？（用于方法参数）：指代任意类型。

fun(MyClass<?> myclass):表示可以接收任意类型的MyClass对象。

只能取得数值，而不能修改数值。

tmp.setName(99);     //   无法从原来设置的55修改成99
因为此时通配符"？"描述的是它可以接收任意类型，99 是Integer型，任意类型！=Integer型，所以无法修改

class MyClass<T>{
	private T name;
	public T getName() {
		return name;
	}
	public void setName(T name) {
		this.name = name;
	}
}
public class Test3 {
	public static void main(String[] args) {
		MyClass<Integer> myClass=new MyClass<>();
		myClass.setName(55);
		fun(myClass);
	}
	public static void fun(MyClass<?> tmp) {
		//tmp.setName(99);无法修改原来设置的55，
		//因为此时通配符"？"描述的是它可以接收任意类型，99 是Integer型，任意类型！=Integer型，所以无法修改
		System.out.println(tmp.getName());
	}
}

子通配符：

？extends 类：设置泛型上限（可用于类或者方法参数）

？extends Number：只能够表示 Number或者其子类。例如：Integer、Double 等；

用于方法参数时，无法改变值，只能取得值。

 

？super 类：设置泛型下限（只用于方法参数）

？super String:表示只能设置String或者其父类（Object）

用于方法参数时，可以修改值。

下面代码是设置泛型下限时，super String :String 型的下限就是String,方法参数与主方法中的一致，所以可以修改。

class MyClass<T>{
	private T name;
	public T getName() {
		return name;
	}
	public void setName(T name) {
		this.name = name;
	}
}
public class Test3 {
	public static void main(String[] args) {
		MyClass<String> myClass=new MyClass<>();
		myClass.setName("bit");
		fun(myClass);
	}
	public static void fun(MyClass<? super String> tmp) {
		tmp.setName("微风带我轻抚你的脸");
		System.out.println(tmp.getName());
	}
}

泛型接口（掌握）：

泛型接口<T>   ：接口定义上使用<T>表示泛型接口

子类实现接口有两种情况：

1.继续保留泛型

class MessageImpl<T> implements Imessage<T>

interface IMessage<T>{
	public void print(T t);
}
class MessageImpl<T> implements IMessage<T>{
	public void print(T t) {
		System.out.println(t);
	}
}
public class Test3 {
	public static void main(String[] args) {
		IMessage<String> messageImpl=new MessageImpl<>();
		messageImpl.print("微风");
	}
}

2.声明泛型类型

class MessageImpl  implements Imessage<String>

interface IMessage<T>{
	public void print(T t);
}
class MessageImpl implements IMessage<String>{
	public void print(String t) {
		System.out.println(t);
	}
}
public class Test3 {
	public static void main(String[] args) {
		IMessage<String> messageImpl=new MessageImpl();
		messageImpl.print("微风");
	}
}

 类型擦除：

泛型信息只存在于代码编译阶段，进入JVM之前，与泛型相关的信息都会被擦除掉。（类型擦除）

class Message<T>{
	private T msg;
	public T getMsg() {
		return msg;
	}
	public void setMsg(T msg) {
		this.msg = msg;
	}
}
public class Test3 {
	public static void main(String[] args) {
		Message <String> message=new Message<>();
		Message <Integer> message2=new Message<>();
		System.out.println(message.getClass()==message2.getClass());
	}
}

上面打印的结果为true,是因为Message<String>和Message<Integer>在JVM中的class都是Message.class

 

泛型时的语法糖（自动拆装箱）

语法糖：方便开发者开发，在运行阶段无卵用

Integer a=55;                               方便开发者开发

Integer a=new Integer(55);          运行阶段是这样

在泛型类型被擦除时，之前泛型类的类型参数如果没有指定上限，<T> -> Object   会被转译成普通的Object类型

如果指定了上限如<T extends String>则参数类型会被替换为类型上限