泛型

泛型

当将一个对象放入集合中，集合不会记住此对象的类型，当再次从集合中取出此对象时，改对象的编译类型变成了Object类型，但其运行时类型任然为其本身类型。

List list=new ArrayList();
list.add(new Random());
list.add("asd"); //list并没有识别"abc"是字符串类型，而是当作Object进行处理
String str=list.get(0);//语法错误，需要编程实现类型转换

注意：问题1进行数据的强制类型转换之前必须进行类型判断，ClassCastException

List list=new ArrayList();
list.add(new Random());
list.add("asd");
Object str=list.get(0);
if(str!=null && str instanceof String){
 String ss=(String) str; //简单写法为String ss=str.toString()
}

因此取出集合元素时需要人为的强制类型转化到具体的目标类型，但是很容易出现ClassCastException异常

那么有没有什么办法可以使集合能够记住集合内元素各类型，且能够达到只要编译时不出现问题，运行时就不会出现java.lang.ClassCastException异常呢？

答案就是使用泛型，可以将运行时的类型检查搬到编译期实现

List<String> list=new ArrayList<>(); //<String>用于声明list中只能存放String类型的数据，如果类型不匹配则会编译失败
//list.add(new Random()) 语法报错，编译失败
list.add("abc");
String ss=list.get(0); //语法正确，不需要进行强制类型转换(窄化操作)

什么是泛型

泛型是jdk5引入的类型机制，就是将类型参数化，泛型作为一种安全机制而产生

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

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); 不需要进行类型转换

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()+1900);
}

典型场景

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

如果需要比较的不是Integer类型，而是Double或是Float类型，那么就需要另外再写max()方法。引入泛型的目的实际上就是能够在编写max()方法时，不必确定参数a和b的数据类型，而等到调用的时候再来确定这两个参数的数据类型，那么只需要编写一个max()就可以了。

使用泛型的好处

1、可读性，从字面上就可以判断集合中的内容类型；

2、获取数据时不在需要强制类型转换。

3 、类型检查，避免插入非法类型。

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

泛型类

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

public class 类型名<泛型名称列表>{ }

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

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

public class Generic<T> {
 private T id;
 public T getid(){
 return this.name;
 }
 public void setid(T id){
 this.name=name;
 }
}

具体使用

Generic<String> en=new Generic<>();//也就是说在en对象中所有的T被String所替换
en.setid(String id);
Generic<Integer> in=new Generic<>(); //也就是说在in对象中所有的T被Intger所替换
in.setid("asd") //语法报错，因为"asd"不是Integer类型
 
en.setid("abc") //语法正确，因为en中的T是String类型

    
Generic<String> en=new Generic<>();
en.setName("deborah");
System.out.println(en.getName());

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

Generic en=new Generic();//没有<>语法，则系统识别T是Object所替换
en.setName("abc"); //“abc”是Object类型
en.setName(123);//123会执行自动装箱操作，转换为Integer类型，同时Integer也是Object类型

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

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

带两个类型参数的泛型类

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

类型参数名可以使用任意字符串，建议使用有代表意义的单个字符，以便于和普通类型名区分，如：T代表type,有原数据和目的数据就用S/D，子元素类型用E等。

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

Listlist=new ArrayList<>(); 第2个类型可以不写

list.add(“456”)); 正确 list.add(456); 错误，类型不合法 .

集合类中定义范型

范型只能使用引用类型，而不能使用基本类型，即：List是错误的

有界类型

public class MyClass{ }

表示允许传入给T的类型必须是Number类型的子类型或者Number类型

*声明泛型可以给泛型添加约束

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

• 接口和类都可以用来做上界。

类充当上界public class Oper

接口充当上界class Stats这里需要注意：针对上界接口使用的关键字仍然是extends而非implements

/要求传入T的类型必须实现了Comparable接口
public class Oper<T extends Comparable<T>> {
	public void sort(List<T> list) {
		if(list!=null && list.size()>1) {
			for(int i=1;i<list.size()-1;i++) {
				for(int k=0;k<list.size()-i;k++) {
					T c1=list.get(k);
					T c2=list.get(k+1);
					if(c1.compareTo(c2)>0) {  //因为要求T必须实现了Comparable接口，所以T中就有Comparable接口中的方法实现
						list.set(k, c2);
						list.set(k+1, c1);
					}
				}
			}
		}
	}
}

通配符参数

使用一般用于接收参数

void doSomething(Stats<?> ob) 表示这个参数ob可以是任意的Stats类型。其中？表示一个不确定的类型，它的值会在调用时确定下来。 List<?> list = new ArrayL

ist(); 通配符参数的语法使用

<? extends E>上限通配符，用来限制类型的上限 ```java List<?> list = new ArrayList();

System.out.println(list.size());//正确，因为使用时和元素的类型无关
list.add(“Deborah”);//语法错误，因为编译时List的类型不确定

<? super E>下限通配符，用来限制类型的下限

public class B<T>{

  public void pp(List<? super T> list){}//表示list中元素的类型必须是T类型或者T类父类或者T接口的实现类或者T的父接口实现类



### **泛型类的继承**

泛型类也是可以继承的，任何一个泛型类都可以作为父类或子类

不过泛型类与非泛型类在继承时的主要区别在于：泛型类的子类必须将泛型父类所需要的类型参数，沿着继承链向上传递。这与构造方法参数必须沿着继承链向上传递的方式类似。

### **泛型的局限性**

不能使用基本类型

不能使用泛型类异常

不能使用泛型数组