Java系列之泛型
自从 JDK 1.5 提供了泛型概念，泛型使得开发者能够定义较为安全的类型，不至于强制类型转化时出现类型转化异常，在没有检讨以前，能够经过 Object 来完成不一样类型数据之间的操做，可是强制类型转换（向下转型）在不肯定具体类型的状况下会出错，泛型机制的引入就是解决数据类型不明确 的问题。java
定义泛型类
定义一个泛型类，语法以下:数组
//定义泛型类
class 类名<T>{
}
复制代码
其中，T 表示一个类型的名称，T 能够表示成其余名称，通常习惯写成 T，<> 里面的类型能够有多个，中间以逗号隔开，下面是一个泛型类，具体以下：安全
/** * 定义泛型类 * @author jzman * @param <T> */
public class GenercityClass<T1,T2> {
private T1 score;
private T2 desc;
public GenercityClass() {}
public GenercityClass(T1 score, T2 desc) {
this.score = score;
this.desc = desc;
}
public T1 getScore() {
return score;
}
public void setScore(T1 score) {
this.score = score;
}
public T2 getDesc() {
return desc;
}
public void setDesc(T2 desc) {
this.desc = desc;
}
public static void main(String[] args) {
//使用时指定具体类型，具体类型只能是引用类型，不能时基本类型，如 int
GenercityClass<Integer, String> genercity = new GenercityClass<>(90,"A");
int score = genercity.getScore();
String desc = genercity.getDesc();
System.out.println("score="+score+",desc="+desc);
}
}
复制代码
显然，使用泛型定义的类能够在使用时根据不一样的需求指定 <T1,T2> 所表明的真实类型，这样就不会有类型转换操做，将不会出现 ClassCastException 异常，编译器会提早检查类型是否匹配，下面这样会出错，具体以下：微信
GenercityClass<Integer, String> genercityClass = new GenercityClass<>();
//符合指定的具体类型
genercityClass.setScore(80);
//不能将String的值赋值给Integer类型的变量
genercityClass.setScore("A");
复制代码
定义泛型接口
定义泛型接口，语法具体以下：ide
//定义泛型接口
interface 接口名<T>{
方法返回值类型 方法名<T t>;
}
复制代码
下面是一个泛型接口的定义，具体以下：学习
/** * 泛型接口：只能在方法中使用指定泛型 * @author jzman */
public interface GenercityInterface<T> {
//泛型不能在静态属性前面使用
// T a;
//方法中使用泛型
void start(T t);
}
复制代码
在接口中使用泛型，只能在接口的方法中使用泛型，不能在接口的属性上使用泛型，由于 Java 接口中的属性是用 public static final 修饰的，而泛型所表明的具体类型是在使用时肯定的，编译时还不知道泛型所表示的具体类型。this
定义泛型方法
定义泛型方法，语法具体以下：spa
//定义泛型方法
修饰符 <T> 返回值类型 方法名{
}
复制代码
建立一个类，具体以下：code
package com.manu.genericity;
public class PersonBean {
private String name;
private int age;
//省略 Getter、Setter等方法
//...
}
复制代码
下面是一个泛型方法的定义，具体以下：cdn
/** * 泛型方法 * @author jzman */
public class GenercityMethod {
public static void main(String[] args) {
PersonBean bean = new PersonBean("tom",10);
printA("string");
printA(bean);
printB(bean);
}
//泛型不指定其超类，因为类型没法肯定，只能访问其信息
public static <T> void printA(T t) {
System.out.println(t);
}
//泛型指定超类，能够修改其泛型表示的实体信息
public static <T extends PersonBean> void printB(T t) {
t.setName("haha");
System.out.println(t);
}
}
复制代码
输出结果以下：
string
PersonBean [name=tom, age=10]
PersonBean [name=haha, age=10]
复制代码
因为泛型方法 printA 具体类型不肯定，不能修改其泛型信息，printB 指定了其超类，必定程度上能够修改泛型表示的具体类型的信息。泛型能够定义在方法中，是否有泛型方法，与其所在的类是否有泛型没有关系。
泛型继承
子类继承父类的时候，泛型又该如何处理呢，下面的子类继承带泛型父类的几种状况，具体以下：
/** * 泛型父类 * @author jzman */
public abstract class GenercityEClass<T> {
T name;
public abstract void print(T t);
}
/** * 子类为泛型类，类型在使用时肯定 * @author jzman * @param <T> */
class Child1<T> extends GenercityEClass<T>{
T t; //子类的属性由子类决定
@Override
public void print(T t) {
//父类的属性随父类决定
T name = this.name;
}
}
/** * 子类指定具体类型 * @author jzman */
class Child2 extends GenercityEClass<String>{
Integer t; //子类的属性由子类决定
@Override
public void print(String t) {
//父类的属性随父类决定
String name = this.name;
}
}
/** * 父类泛型的擦除 * 子类是泛型类，父类不指定类型，泛型擦除是使用Object来代替 * @author jzman * @param <T> */
class Child3<T/*,T1*/> extends GenercityEClass{
T t;
String t1; //子类的属性由子类决定
@Override
public void print(Object t) {
//父类的属性随父类决定
Object obj = this.name;
}
}
/** * 子类和父类同时泛型擦除 * @author jzman */
class Child4 extends GenercityEClass{
//只能使用具体类型
String str; //子类的属性由子类决定
@Override
public void print(Object t) {
//父类的属性随父类决定
Object obj = this.name;
}
}
复制代码
能够获得一些结论：父类中的属性随父类而定，子类中的属性随子类而定，子类继承父类时的方法重写，其相关的类型随父类而定，这种带有泛型的操做在继承时涉及到泛型擦除，将在下文中说明。
泛型擦除
在泛型继承小节中涉及到泛型的擦除，感受比较重要，故单独记录一下，泛型擦除两种状况，具体以下：
- 继承或实现（接口）时泛型擦除；
- 具体使用时的泛型擦除。
子类继承父类时，泛型的擦除有两种状况，具体以下：
- 子类泛型，父类泛型擦除
- 子类和父类同时泛型擦除
下面是部分代码，具体以下：
/** * 父类泛型的擦除 * 子类是泛型类，父类不指定类型，泛型擦除是使用Object来代替 * @author jzman * @param <T> */
class Child3<T/*,T1*/> extends GenercityEClass{
T t;
String t1; //子类的属性由子类决定
@Override
public void print(Object t) {
//父类的属性随父类决定
Object obj = this.name;
}
}
/** * 子类和父类同时泛型擦除 * @author jzman */
class Child4 extends GenercityEClass{
//只能使用具体类型
String str; //子类的属性由子类决定
@Override
public void print(Object t) {
//父类的属性随父类决定
Object obj = this.name;
}
}
/** * 子类擦除，父类使用泛型（错误） * @author jzman * class Child5 extends GenercityEClass<T>{ @Override public void print(T t) { } } */
复制代码
注意一点，不能父类泛型，子类泛型擦除，只能子类泛型在大于等于父类泛型个数的状况下才能进行泛型擦除。类实现泛型接口与类之间的继承相似，再也不赘述。
下面是具体使用时的泛型擦除，具体以下：
class Child1<T> extends GenercityEClass<T>{
T t; //子类的属性由子类决定
@Override
public void print(T t) {
//父类的属性随父类决定
T name = this.name;
}
public static void main(String[] args) {
//1.使用时泛型擦除
Child1 child1 = new Child1();
Object obj = child1.name;//属性name为擦除后的类型Object
//2.使用时指定类型
Child1<String> child2 = new Child1();
String name = child2.name;//属性name为指定的类型 String
}
}
复制代码
关于泛型擦除就聊到这。
泛型的高级用法
泛型的高级用法具体以下：
- 限制泛型可用类型
- 使用类型通配字符
1. 限制泛型可用类型
默承认以使用任何类型来实例化一个泛型类对象，也能够对泛型类实例的类型进行限制，语法具体以下：
//限制泛型可用类型
class <T extends AnyClass>{
}
复制代码
上面的 AnyClass 能够是一个类也能够是一个接口，也就是说泛型的类型必须继承 AnyClass 类或实现 AnyClass 接口，不管是类仍是接口，进行类型限制时都是用 extends 关键字。下面是案例，具体以下：
/** * 泛型可用类型限制 * @author jzman */
public class LimitGenercityClass<T extends List> {
public static void main(String[] args) {
// T extends：<上限,T能够是上限的子类或其自己
LimitGenercityClass<ArrayList<String>> limitClass1 = new LimitGenercityClass<>();
LimitGenercityClass<LinkedList<String>> limitClass2 = new LimitGenercityClass<>();
//HashMap没有实现List接口，故HashMap不能对泛型类实例的类型实例化
// LimitGenercityClass<HashMap<String,String>> limitClass3 = new LimitGenercityClass<>();
}
}
复制代码
上述代码中对泛型 T 进行了限制，具体的泛型类型必须实现 List 接口，ArrayList 和 LinkedList 实现了 List 接口，而 HashMap 没有实现 List 接口，因此 HashMap 不能实例化对应泛型的具体类型。
使用类型通配符
在泛型机制中提供了类型通配符，主要做用是建立一个泛型类对象时限制这个泛型类的类型继承或实现某个类或接口，可使用 ？ 通配符来实现，同时也可使用 extends、super 关键字对泛型进行限制，使用类型通配符语法具体以下：
//使用类型通配符
泛型类名称<? extends AnyClass> a ;
复制代码
下面是类型通配符的使用，具体以下：
/** * 使用通配符 * ？ extends AnyClass:限制泛型的具体类型只能是AnyClass的子类 * ？ super AnyClass:限制泛型的具体类型只能是AnyClass的超类 * @author jzman */
public class CommonCharGenercityClass<T> {
public static void main(String[] args) {
//1.通配符用在类型声明上
CommonCharGenercityClass<? extends List> commA = null;
//通配符中使用extends关键字限制了泛型只能是List的子类
commA = new CommonCharGenercityClass<ArrayList<String>>();
commA = new CommonCharGenercityClass<LinkedList<String>>();
// commA = new CommonCharGenercityClass<HashMap<String>>();
CommonCharGenercityClass<? super List> commB = null;
//出错，通配符中使用super关键字限制了泛型只能是 List 的超类才能够，好比Object
// commB = new CommonCharGenercityClass<ArrayList<String>>();
commB = new CommonCharGenercityClass<Object>();
List<String> listA = new ArrayList<>();
listA.add("tom");
List<?> listB = listA;
//使用了通配符时，因为不肯定具体类型，只能获取和删除数据，不能添加数据，不能被调用
// listB.add("new");
listB.remove(0);
System.out.println(listB);
}
//2.通配符用在方法参数上
public static void test(CommonCharGenercityClass<? extends List> list) {
//...
}
}
复制代码
类型通配符 ？ 能够结合关键字 extends 和 super 来实现对泛型具体类型的限制，extends 限制泛型的具体类型应该是目标类型的子类，super 限制泛型的具体类型应该是目标类型的超类，此外，类型通配符不能用在声明类上。
泛型做用
- 编译的时候检查类型安全，提早发现错误
- 泛型中的类型强制转换都是自动和隐式的，提升了代码的重用率。
总结：泛型的类型必须是引用类型，不能是基本类型，泛型的个数能够有多个，可使用 ？对建立对象时的泛型类型以及方法参数类型进行限制，如使用关键字 extends 和 super 对泛型的具体类型进行向下限制或向上限制，最后一点，能够声明泛型数组，可是不能建立泛型数组的实例。
能够选择关注微信公众号：jzman-blog 获取最新更新，一块儿交流学习!
- 1. Java系列之泛型
- 2. 《重学Java系列》之 泛型（下）
- 3. JAVA系列： Object 、泛型T、？
- 4. Java总结篇系列：Java泛型
- 5. Java基础系列二：Java泛型
- 6. Java 之 泛型
- 7. JAVA系列：泛型的作用（自定义泛型例子）
- 8. java中的泛型系列五：自定义泛型
- 9. Java入门系列-19-泛型集合
- 10. java技术系列(四) 泛型
- 更多相关文章...
- • C# 泛型（Generic） - C#教程
- • Swift 泛型 - Swift 教程
- • Kotlin学习（二）基本类型
- • Docker容器实战(七) - 容器眼光下的文件系统
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. No provider available from registry 127.0.0.1:2181 for service com.ddbuy.ser 解决方法
- 2. Qt5.7以上调用虚拟键盘(支持中文)，以及源码修改(可拖动，水平缩放)
- 3. 软件测试面试- 购物车功能测试用例设计
- 4. ElasticSearch（概念篇）：你知道的, 为了搜索…
- 5. redux理解
- 6. gitee创建第一个项目
- 7. 支持向量机之硬间隔（一步步推导，通俗易懂）
- 8. Mysql 异步复制延迟的原因及解决方案
- 9. 如何在运行SEPM配置向导时将不可认的复杂数据库密码改为简单密码
- 10. windows系统下tftp服务器使用
- 1. Java系列之泛型
- 2. 《重学Java系列》之 泛型（下）
- 3. JAVA系列： Object 、泛型T、？
- 4. Java总结篇系列：Java泛型
- 5. Java基础系列二：Java泛型
- 6. Java 之 泛型
- 7. JAVA系列：泛型的作用（自定义泛型例子）
- 8. java中的泛型系列五：自定义泛型
- 9. Java入门系列-19-泛型集合
- 10. java技术系列(四) 泛型