java泛型

一、泛型的概念

泛型是jdk5引入的类型机制，就是将类型参数化，它是早在1999年就制定的JSR14的实现。泛型作为一种安全机制而产生

public void pp(String str){} //str实际上是形参
public void pp(Integer str){}
调用时按照位置对应传入实际数据，实际数据叫做实参
pp("dddd")

泛型机制将类型转换时的类型检查从运行时提前到了编译时，使用泛型编写的代码比杂乱的使用object并在需要时再强制类型转换的机制具有更好的可读性和安全性。

泛型在本质上是指类型参数化。所谓类型参数化，是指用来声明数据的类型本身，也是可以改变的，它由实际参数来决定。在一般情况下，实际参数决定了形式参数的值。而类型参数化，则是实际参数的类型决定了形式参数的类型。

在声明阶段E是什么类型不确定，这里的E仅仅充当占位符的作用，在具体调用时类型才能确定，而E的所有位置将被指定的类型所替代

二、泛型的定义

public interface List<E> extends Collection<E> {
//这里的<>中的内容就是类型参数，一般建议使用T或者E之类的全大写
 E get(int index); //获取的元素类型就是定义时指定的类型
 void add(E element);
}

List<String> list=new ArrayList<String>();
//list.add(new Random()) 编译失败，语法报错，因为E现在是String类型，不是Random
list.add("ddd");
//就是将String传递给E，用于替代定义中的E 
String str=list.get(0); 
//不需要进行类型转换

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import warnings
warnings.filterwarnings('ignore')
import  ssl
ssl._create_default_https_context = ssl._create_unverified_context

List<Date> list=new ArrayList<>();//这里使用菱形语法，支持泛型推导
list.add("abc");//语法报错，编译时就会进行类型检查
list.add(123);//语法报错
list.add(new Date());
for(int i=0;i<list.size();i++){
 Date temp=list.get(i); //获取数据不需要类型转换
 System.out.println(temp.getYear()+20000);
} 

典型场景

获取两个整数中较大的整数，方法定义为Integer max(Integer a, Integer b){ return a>b?a:b; }

如果需要比较的不是Integer类型，而是Double或是Float类型，那么就需要另外再写max()方法。

引入泛型的目的实际上就是能够在编写max()方法时，不必确定参数a和b的数据类型，而等到调用的时候再来确定这两个参数的数据类型，那么只需要编写一个max()就可以了，这将大大降低程序员编程的工作量。

Comparable接口，Java中有一个系统预定义的接口

public interface Comparable<T> 用于实现规范类的可比较性
 int compareTo(T o); //当前类型比较时需要返回一个整数,当当前对象大于参数o时，
 //返回一个正数；如果等于时则返回0；如果小于时返回一个负数
}

泛型方法定义

public class MyTest {
 	public static <T extends Comparable<T>> T max(T t1, T t2) {//extends用于声明传入
 	//的T类型必须是Comparable类型的,必须直接或者间接的实现Comparable接口
 	return t1.compareTo(t2) > 0 ? t1 : t2;
 	} 
 }

在泛型出现之前，Java的程序员可以采用一种变通的办法：将参数的类型均声明为Object类型。由于Object类是所有类的父类，所以它可以指向任何类对象，但这样做不能保证类型安全。泛型则弥补了Object做法所缺乏的类型安全，也简化了过程，不必显示地在Object与实际操作的数据类型之间进行强制转换。

通过泛型，所有的强制类型转换都是自动和隐式的。因此，泛型扩展了重复使用代码的能力，而且既安全又简单。

泛型的好处
1、可读性，从字面上就可以判断集合中的内容类型；
2 、类型检查，避免插入非法类型。
3 、获取数据时不在需要强制类型转换。

泛型类

所谓泛型类generic class就是具有一个或多个类型参数的类

public class Generic<T>{
 private T name; //将T当做类型直接使用
}

声明一个泛型类Generic，使用泛型的语法为<名称>，在类中就可以通过名称直接使用这个类

public class Generic<T> {
 	private T name;
 	public T getName(){
 	return this.name;
 	}
 	public void setName(T name){
 	this.name=name;
 	}
}

具体使用

Generic<String> en=new Generic<>();//也就是说在en对象中所有的T被String所替换
en.setName(String name);
Generic<Integer> in=new Generic<>(); //也就是说在in对象中所有的T被Intger所替换
//in.setName("abc") 语法报错，因为"abc"不是Integer类型
 
en.setName("abc") //语法正确，因为en中的T是String类型
//JDK1.7引入菱形语法<>用于简化实现类上泛型的定义，系统支持泛型推导
Generic<String> en=new Generic<>();
en.setName("2233");
System.out.println(en.getName());

如果定义了泛型类，但是引用时不声明泛型值系统则识别泛型为Object类型

class Generic中T是类型参数的名称。在创建一个对象时，这个名称用作传递给Generic的实际类型的占位符。因此在Generic中，每当需要类型参数时，就会用到T。注意T是被括在<>中的。每个被声明的类型参数，都要放在尖括号中。由于Generic使用了类型参数，所以它是一个泛型类，也被称为参数化类型。

在Generic类中使用T定义了一个属性T ob。由于T只是一个占位符，所以ob的实际类型要由创建对象时的参数传递进来。

T事实是一个数据类型的说明，它可以用来说明任何实例方法中的局部变量、类的成员变量、方法的形式参数以及方法的返回值。但是类型参数T不能使用在静态方法中。

public class Generic<T> {
 private static T name;//语法报错
 public static T getName(){//语法报错
 return name;
 }
}

声明一个泛型实例时，传递给形参的实参必须是类类型，而不能使用int或char之类的简单类型。如果不传递类型，则系统默认类型为Object

如果引用多个类型，可以使用逗号分隔： <S, D>

使用泛型集合，可以将一个集合中的元素限定为一个特定类型，这样集合中就只能存储同一类型的对象，这样更安全；并且当从集合中获取一个对象时，编译器也知道这个对象的类型，不需要对对象进行强制类型转换，这样更方便。

有界类型

public class MyClass<T extends Number>{  }
//<T extends Number>表示允许传入给T的类型必须是Number类型的子类型或者Number类型

MyClass<Integer> mc=new MyClass<Integer>();   //语法正确，因为Integer是Number的子类型

//MyClass<String> mc=new MyClass<>();  语法错误，因为String不是Number类型

声明泛型可以给泛型添加约束
Java提供了有界类型bounded types。在指定一个类型参数时，可以指定一个上界，声明所有的实际类型都必须是这个超类的直接或间接子类。class classname