标签：val each this add rri bsp log 不同 父类
1、什么是泛型
泛型就是 参数类型化 ，简单说就是在定义类 接口 方法时时不支持具体的参数类型的。只有在实际使用时才确定。
2、为何用泛型
我觉得有两点好处
a. 明确类型 避免类型转换
如，没有泛型前，从List中取数据都是Object类型的 需要强制转换为确定的类型
public static void main(String[] args) {
List myList = new ArrayList();
myList.add(new Integer(1));
Integer value = (Integer)(myList.get(0));
System.out.println("value=" + value);
}
b. 提高代码复用
如有Father类 每个父亲可能有不同的职业 有点的教师 有点的医生...
如何表示呢，搞多个类表示不同的职业？ 可以 但不友好！
使用泛型 如下：把职业类型化
使用:
Father<Teacher> fatherTeacher = new Father<>(new Teacher());
Father<Doctor> fatherDoctor = new Father<>(new Doctor());
public class Father<T> {
private T job;
public Father(T job){
this.job = job;
}
public void work(){
System.out.println("my job is "+ job);
}
}
3、如何使用泛型
泛型可以使用在类(泛型类)、 接口（泛型接口、 方法（泛型方法）中。
泛型类： 如上述的例子
泛型接口：
样例
public interface Work<T> { public void work(T t); } 继承泛型接口 public class Father<T> implements Work<T>{ private T job; public Father(T job){ this.job = job; } @Override public void work(T t) { System.out.println("my job is "+ t); } }
泛型方法：方法的参数调用时才确定
例如下 ：在泛型类中定义了一个泛型方法 （E是一种类型，跟类中的T 可能一样可能不一样)
泛型方法必须使用<> 表示类型
public class Father<T> implements Work<T>{
private T job;
public Father(T job){
this.job = job;
}
@Override
public void work(T t) {
System.out.println("my job is "+ t);
}
public <E> void printWork(E e){
System.out.println("my job is "+ e);
}
}
调用：
public static void main(String[] args) { Father<Teacher> fatherTeacher = new Father<>(new Teacher()); fatherTeacher.printWork(new Teacher()); }
输出：my job is com.yangfei.test.fanxing.Teacher@13221655
4、泛型擦除
泛型只在编译时有效 运行时是没有泛型的，称之为泛型擦除。
如下的示例 输出结果为true (java中一个类只会加载一次 生成Class类型对象)
说明两个类是没有泛型的区别的（编译后都被转成了Object）。
Class list_int = new ArrayList<Integer>().getClass(); Class list_string = new ArrayList<String>().getClass(); System.out.println(list_int==list_string);
泛型擦除的目的： 就是为了运行时不会创建过多的类 避免因泛型的区别导致加载的类泛滥。
泛型擦除非真正擦除： 否则运行时如何转换成实际的类型呢
如
List<String> sd = new ArrayList<String>();
sd.add("yangfei");
String str = list.get(0)
但取值的时候怎么知道要转成String类型的呢？
擦除并非真正的完全擦除，泛型信息还是会保存在class字节码的常量池中，
在使用了泛型的代码调用处会生成一个signature签名字段，signature指明了这个常量在常量池的地址，调用时强制转换
这样我们就找到了参数化类型。
参考： https://www.jianshu.com/p/2ded3ffaa9c8
5、协变
数组是协变的 什么意思
如果class A extends B 那么B[] array = new A[] 也是成立的，这是协变。
而泛型是不支持协变的
即 List<A>是不可以赋给List<B>的
6、 ？和T的区别
T表示一个类型 在使用时确定。
?时通配符 表示任意类型。
使用场景不一样
a. 在泛型类定义是使用T
b.在使用泛型时 可用?
如：
Father<?> fatherTeacher = new Father<Teacher>(new Teacher());
有啥好处，我们知道泛型不支持协变的，有了通配符后，可以有如下表示
父子类：class Son extends Mather; 则如下写法也是合法的
List<? extends Mather> lists = new ArrayList<Son>();
其实List<?> 相当于List<? extends Object>
7、PECS原则
PECS原则的全拼 : "Producer Extends Consumer Super"
表示<? extends T> 一般用于生产者，生产数据。外部只从中读数据；< ? super T> 一般用于消费者，需要消费数据，外部需要往其中写数据。
7.1 <? extends T> 表示可能是T或者T的子类 （上边界通配符）
这种情况一般只能取 不能存非null之外的任何类型
如下class Son extends Mather; class Daughter extends Mather;
public static void main(String[] args) {
Mather[] matherArr = new Mather[]{new Daughter(),new Son()};
List<? extends Mather> lists = Arrays.asList(matherArr);
lists.add(null); //因为任何类型都可以用null表示
lists.add(new Daughter()); //此处会编译报错
Mather mather = lists.get(0);
}
存非null值会报错 ，因为不知道具体是什么类型，Mather的子类和子类间并没有直接关系 没法赋值，所以没法存
取出来的值 只能是父类型（所有子类都可以转为父类）
7.2 <? super T> 表示可能是T或者T的父类 (下边界通配符)
这种情况一般只用于存数据 ，可以存T或T的子类，因为T的子类可以转换为T类型，而T类型也可以自动向上转为任何父类
取出的数据向上转换只能是object类型
public static void main(String[] args) {
Mather[] matherArr = new Mather[]{new Daughter(),new Son()};
List<? super Mather> lists = Arrays.asList(matherArr);
lists.add(null);
lists.add(new Daughter());
Object mather = (Object)lists.get(0);
}
8、不支持泛型数组
Java是不支持泛型数组的，如下编译会报错
List<String>[] array = new ArrayList<String>[5];
为何不支持：数组支持协变，泛型运行时类型擦除，这样容易引起误解
如下： List<Integer>类型数组 因为类型参数，可以把List<String>也放入数组中，导致内容错误。
ArrayList<Integer>[] intArr = new ArrayList<Integer>[10];
Object[] obj = intArr;
ArrayList<String> listStr = new ArrayList<String>();
listStr.add("yangfei")
obj[0] = listStr;
ArrayList<Integer> listInt = intArr[0];
Integer i = listInt.get(0);//想要获取Integer，但却是String
参考： https://www.cnblogs.com/hapjin/p/5371950.html
9、静态方法与类的泛型
一个泛型类只有在初始化时才能明确其类型 ； 而静态方法不属于实例。所以静态方法不能使用类的泛型
如下：标红会编译报错
public class Father<T> implements Work<T>{
private T job;
public Father(T job){
this.job = job;
}
@Override
public void work(T t) {
System.out.println("my job is "+ t);
}
public static void printWork(T e){
System.out.println("my job is "+ e);
}
}
解决方法：可使用泛型方法
标签：val each this add rri bsp log 不同 父类
原文地址：https://www.cnblogs.com/yangfei629/p/11403304.html
