一、定义
泛型是一种未知的数据类型，即当我们不知道该使用哪种数据类型的时候，可以使用泛型。
泛型的本质是为了 参数化 类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型）。也就是说在泛型使用过程中，操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。
在定义类或者方法或者接口的时候，是无法指定需要的参数类型的。这时候，我们需要将参数类型设置为一个参数。这就是所谓的参数化类型。
二、基本使用
1.存在泛型参数的类
注：含有泛型的类只有在创建对象的时候，才能确定泛型的数据类型。
（1）定义
修饰符 class genericClass<E>{
修饰符 genericClass(){ //不带参构造函数
}
修饰符 genericClass(E e){ //带参构造函数
}
}
（2）创建泛型类对象
genericClass<E> obj = new genericClass<>(); //无参构造函数创建对象
或
E e = new E();
genericClass<E> obj = new genericClass<>(e); //带参构造函数创建对象
2.含有泛型的方法
注：只有在调用方法的时候，才能确定泛型的数据类型。
（1）定义
修饰符 <E> 返回值类型 方法名（E或者普通参数）｛
｝
（2）代码：
泛型类：
package com.lanyue.day12;
public class genericLearn{
public <E> String getName(E e){
if(e instanceof Stu){
return ((Stu) e).getName();
}else{
return "数据类型转换错误";
}
}
}泛型类测试需要的类：
package com.lanyue.day12;
public class Stu {
private int age;
private String name;
public Stu(int age, String name) {
this.age = age;
this.name = name;
}
public int getAge() {
return age;
}
public String getName() {
return name;
}
}
运行代码：
package com.lanyue.day12;
public class Demo {
public static void main(String[] args) {
Stu stu = new Stu(20,"胡海");
genericLearn stuOne = new genericLearn();
System.out.println(stuOne.getName(stu));
}
}
3.含有泛型的接口
（1）定义含有泛型的接口
修饰符nterface<E>{
}
（2）定义实现泛型接口的实现类
方法①：指定实现类接受参数类型
修饰符 class 类名 implements 接口<指定数据类型>{
}
方法②：让实现类接受的参数类型继续为泛型
修饰符 class 类名<泛型> implements 接口<泛型>｛
｝
（3）代码：
USB接口代码：
package com.lanyue.day13;
public interface Usb<E> {
public abstract void inPut(E e);
public abstract void outPut(E e);
}
USB接口实现类一：
package com.lanyue.day13;
public class UsbImpl implements Usb<String>{
@Override
public void inPut(String info) {
System.out.println("正在往优盘传输数据" + info);
}
@Override
public void outPut(String info) {
System.out.println("正在从优盘拷贝数据" + info);
}
}
USB接口实现类二：
package com.lanyue.day13;
public class UsbImplTwo<E> implements Usb<E> {
@Override
public void inPut(E e) {
if(e instanceof Stu){
System.out.println("正在拷贝" + ((Stu) e).getName() + "同学的信息到优盘");
}else{
System.out.println("数据解析失败");
}
}
@Override
public void outPut(E e) {
if(e instanceof Stu){
System.out.println("正在从优盘拷贝" + ((Stu) e).getName() + "同学的信息");
}else{
System.out.println("数据解析失败");
}
}
}
中间自定义类：
package com.lanyue.day13;
public class Stu {
public String name;
public Stu(String name) {
this.name = name;
}
public String getName() {
return name;
}
}
运行类：
package com.lanyue.day13;
public class Demo {
public static void main(String[] args) {
UsbImpl usbOne = new UsbImpl();
usbOne.inPut("Java");
usbOne.outPut("C++");
Stu stu = new Stu("蓝月");
UsbImplTwo usbTwo = new UsbImplTwo();
usbTwo.inPut(stu);
usbTwo.outPut(stu);
usbTwo.inPut("蓝月");
usbTwo.outPut("蓝月");
}
}
4.泛型通配符
当使用泛型类或者泛型接口时，传递的数据中，泛型类型不确定。可以通过通配符<?>表示。但是一旦使用泛型通配符之后，只能使用Object类中的共性方法。集合中元素的特有方法无法使用。且只能接受数据，而不能往该集合中存储数据。
（1）注意
① 被泛型通配符修饰的类或接口的实现类 不能创建对象使用，只能作为方法的参数使用。
② 泛型是没有继承概念的。
③ 受限泛型
1）.泛型的上限：只能接受该类型和其子类
定义格式：
类名 <? extends 类> 对象名称
2）泛型的下限：只能接受该类型和其父类
定义格式：
类名 <? super 类> 对象名称
3）代码：
整体框架简介：
为了测试泛型通配符的用法，我们需要一个父类Person，两个子类Stu和Worker分别继承了父类。在Usb接口的实现类UsbImpl中，我们完成了对泛型通配符的利用。
Person类：
package com.lanyue.day14;
public class Person {
public static int ID = 1;
public String name;
public Person(){
ID++;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
}
Stu类：
package com.lanyue.day14;
public class Stu extends Person{
public String workPlace = "石家庄职业技术学院";
public String getWorkPlace(){
return workPlace;
}
}
Worker类：
package com.lanyue.day14;
public class Worker extends Person{
public String workPlace = "富士康";
public String getSP() {
return workPlace;
}
public String getWorkPlace() {
return workPlace;
}
}
Usb接口：
package com.lanyue.day14;
import java.util.ArrayList;
public interface UsbInt {
public abstract void getInfo(ArrayList<? extends Person> list);
}
Usb接口实现类——UsbImpl类:
package com.lanyue.day14;
import java.util.ArrayList;
import java.util.Iterator;
public class UsbImpl implements UsbInt {
@Override
public void getInfo(ArrayList<? extends Person> list) {
Iterator<? extends Person> iterator = list.iterator();
while(iterator.hasNext()){
Person person = iterator.next();
System.out.println("已在数据库中查找到 " + person.getName() + " 同学");
}
}
}
运行代码：
package com.lanyue.day14;
import java.util.ArrayList;
public class Demo {
public static void main(String[] args) {
Stu one = new Stu();
one.setName("蓝月");
Worker two = new Worker();
two.setName("天行");
Person three = new Person();
three.setName("逍遥");
UsbImpl usb = new UsbImpl();
ArrayList<Stu> stus = new ArrayList<>();
stus.add(one);
ArrayList<Worker> works = new ArrayList<>();
works.add(two);
ArrayList<Person> persons = new ArrayList<>();
persons.add(three);
usb.getInfo(stus);
usb.getInfo(works);
usb.getInfo(persons);
}
}
