一:什么是泛型
1.1泛型的本质是泛型的参数化 是jdk5 中引入的一种新特性
泛型是提供了编译时类型安全监测机制,该机制允许我们在编译时监测到非法的类型数
据结构。泛型的本质就是参数化类型,也就是所操作的数据类型被指定为一个参数。
1.2泛型 带来的好处
1)类型的安全
2)消除了强制类型的转换(因为我们创建的时候已经指定了数据类型)
3)代码健壮
二:泛型类、接口
2.1泛型类定义语法
class类名称<泛型标识,泛型标识,...>}
private 泛型标识 变量名:
...
}
2.2常用的泛型标识:T 、E 、K、 V
2.3定义一个泛型类
package Four;
/**泛型类的定义
* @author Administrator
* @param <T> 泛型标识--类型形参
* T创建对象的时候里指定具体的数据类型。
*/
class BigTest<T> {
//T是由外部指定的类的时候固定的。
private T key;
public T getKey() {
return key;
}
public void setKey(T key) {
this.key = key;
}
public BigTest() {
}
public BigTest(T key) {
this.key = key;
}
@Override
public String toString() {
return "BigTest{" +
"key=" + key +
'}';
}
}
2.4使用方法
使用语法
类名<具体的数据类型> 对象名 = new 类名<集体的数据类型>();
Java1.7版本之后,后面的<>中具体的数据类型可以不用写了;
类名<具体的数据类型> 对象名 = new 类名<>();
泛型类注意事项
1)泛型类,如果没有指定的数据类型,返回的是Object类型;
2)泛型的类型参数只是类类型,不能是基本数据行;
3)泛型类型在逻辑上可以看成是多个不同的类型,但实际上是相同的类型 ,占用的空间相同。
默认情况下的泛型
泛型参数只能是类类型 不能是参数类型
同一泛型不同的数据类型,占用的空间大小相同
2.5泛型类的继承情况
从泛型类派生子类
1.子类也是泛型类,子类和父类的泛型类型要一致
class ChildGeneric<T> extends Generic<T>
2.子类不是泛型类 ,父类要明确泛型的数据类型
class ChildGeneric extends Generic <String>
创建一个父类
package Four;
/**
* @author Administrator
*/
public class Parent<E> {
private E value;
public void setValue(E value) {
this.value = value;
}
public E getValue(){
return value;
}
}
写一个类继承父类
package Four;
/**
* @author Administrator
* 1.泛型类派生子类。子类也是泛型类,那么子类的泛型标识要和父类一致
*/
public class ChildFirst<T> extends Parent <T>{
@Override
public T getValue() {
return super.getValue();
}
@Override
public void setValue(T value) {
super.setValue(value);
}
}
2.52在写一个没有指定类型的子类
package Four;
/**
* @author Administrator
* 泛型类派生紫烈,如果子类不是泛型类,那么要明确数据类型
*/
public class ChildSecond extends Parent<Integer>{
@Override
public void setValue(Integer value) {
super.setValue(value);
}
@Override
public Integer getValue() {
return super.getValue();
}
}
在main里面测试
2.6泛型接口
2.61泛型接口的使用
1)实现列不是泛型类,接口要明确数据类型
2)实现类也是泛型类,实现类和接口的泛型类型要一致
代码 定义一个泛型接口 然后实现泛型接口的例子
第二种实现泛型接口 还是实现上图的接口(提高了泛型接口的灵活性)
三泛型方法
1)泛型类实在实例化类的时候指定说明泛型的具体数据类型
2)泛型方法,实在调用方法的时候指明泛型的具体类型
3.1语法结构
修饰符<T ,E...>返回值类型 方法名 (形参列表)
{
形参列表
}
3.2常用泛型定义形式
package Demo;
/**
* 定义一个泛型接口
* @author Administrator
* 定义公共的方法
*/
public interface Generator <T> {
T getKey();
}
package Demo;
/**
* @author Administrator
* 在这里可以重写接口公共的方法 和一些自己特定的方法
*/
public class Im implements Generator{
@Override
public Object getKey() {
return null;
}
public Object AddAge() {
return null;
}
}
package Demo;
/**
* @author Administrator
* 在这里具体调用实现
*/
public class Ex extends Im {
public static void main(String[] args) {
Im im = new Im();
im.AddAge();
im.getKey();
}
}
首先定义一个泛型接口 ,然后在各自的类里面去定义各自特有的方法,最后实现,各自的具体方法。
四:泛型通配符;
什么是类型通配符;
1)类型通配符一般使用?号 代替具体的类型实参;
2) 类型通配符是实行参数,而不是类型形参;
定义一个泛型类
package Demo;
/**定义一单行类
* @author Administrator
*/
public class Box<T> {
private T number;
public T getNumber() {
return number;
}
public void setNumber(T number) {
this.number = number;
}
}
package Demo;
/**
* @author Administrator
*/
public class BoxTest {
public static void showBox(Box<?> box){
Object number = box.getNumber();
System.out.println(number);
}
// public static void showBox(Box<String> box){
//
// }
public static void main(String[] args) {
Box <Integer> box = new Box<>();
box.setNumber(100);
showBox(box);
Box<String> box1 = new Box<>();
box1.setNumber("十五");
showBox(box1);
}
}
4.2:通配符的上限问题 建立三个类 分别是 爷爷 父亲 孙子的 类
package Demo;
/**
* 爷爷辈分的类
* @author Administrator
*/
public class GrandDad {
}
package Demo;
/**父亲辈分的类
* @author Administrator
*/
public class Father extends GrandDad{
}
package Demo;
import java.util.ArrayList;
/**孙子辈分的类
* @author Administrator
*/
public class Son extends Father {
public static void main(String[] args) {
ArrayList<GrandDad> arrayList = new ArrayList<>();
ArrayList<Father> arrayList1 = new ArrayList<>();
ArrayList<Son> arrayList2 = new ArrayList<>();
AddPerson(arrayList);
AddPerson(arrayList1);
AddPerson(arrayList2);
}
public static void AddPerson(ArrayList<? extends Father> list){
}
}
上限的问题 可以理解为 我和我extends的那一层 ;换言之,extends 后面的(类)的 所有子类 都能使用该方法;
4.3通配符的下限问题 ,下限问题使用super来实现(同样是上面那些类)
五:类型的擦除
泛型是java1.5版本才引进的概念,在之前是没有泛型的,但是,泛型代码能够很好地和之前版本的代码兼容。那是因为,泛型信息只存在于代码编译阶段,在进入jvm之前,与泛型相关的信息会被擦除掉,我们称之为--类型擦除