java基础之泛型

摘要: 泛型是java三大高级特性之一，利用JVM的解释器功能，可以让代码的可复用性大大提供。很多成功的框架都是利用了泛型来写通用的处理逻辑，下面简单介绍泛型使用。

java基础之泛型

一.概述

1.1 简介

泛型是java三大高级特性之一，利用JVM的解释器功能，可以让我们的代码应用于多种类型的处理。其核心思想是在newInstance()实例的时候，告诉编译器想使用什么类型，然后编译器帮你处理一切细节。大量框架都是利用了泛型来写通用的处理逻辑，下面简单介绍泛型接口和方法上。

1.2 擦出特性

编译器对泛的型处理，java会使将具体的类型信息都擦出啊，你唯一知道的是在使用一个对象。当加入了边界信息<T extends 类>，编译器在编译的时候会将擦出掉类信息，然后将其编译为边界类。

1.3 总结

a）泛型相当于一个占位符，编译器自动帮你转化为一个 java.lang.object 的根类。

b）泛型边界可以让编译将泛型复活转换唯一个边界类型。

c）为了在泛型类通过反射中操作具体类的各种数据，我们可以使用class<T> t 来创建我们一个实例。这样就可以通过泛型来写通用的类处理框架。

二.实例

2.1 无边界的泛型使用

//接口
// T 相当于一个占位符，在编译器处理时候明确类型
public interface Generator<T> {
// 在create的时候，编译器知道是哪一个类
T next();

// 正确泛型方法，在使用这个方法的时候，编译器会从参数组中查询需要的类型
<S> S create(Class<S> resultObject);
// 错误泛型方法、在编译器并不知道M这个东西是什么
// M over();
}
// 类
public class TypeParam<T> implements Generator<T> {

private T t1;

@Override
public T next() {
return null;
}

@Override
public <S> S create(Class<S> resultObject) {
return null;
}

public T getT1() {
return t1;
}

public void setT1(T t1) {
this.t1 = t1;
}

public static void main(String[] args) {

}

}

使用 javap -c TypeParam.class

Compiled from "TypeParam.java"
public class typeParam.TypeParam<T> implements typeParam.Generator<T> {
public typeParam.TypeParam();
Code:
0: aload_0
1: invokespecial #10                 // Method java/lang/Object."<init>":()V
4: return

public T next();
Code:
0: aconst_null
1: areturn

public <S> S create(java.lang.Class<S>);                                //边界补偿，使用（class<?> xxx ）可以明确的在泛型方法中使用反射
Code:
0: aconst_null
1: areturn

public static void main(java.lang.String[]);
Code:
0: return
}
Compiled from "TypeParam.java"
public class typeParam.TypeParam<T> implements typeParam.Generator<T> {
public typeParam.TypeParam();
Code:
0: aload_0
1: invokespecial #14                 // Method java/lang/Object."<init>":()V
4: return

public T next();
Code:
0: aconst_null
1: areturn

public <S> S create(java.lang.Class<S>);
Code:
0: aconst_null
1: areturn

public T getT1();
Code:
0: aload_0
1: getfield      #32                 // Field t1:Ljava/lang/Object;        //无边界，将其编译为一个object类型
4: areturn

public void setT1(T);
Code:
0: aload_0
1: aload_1
2: putfield      #32                 // Field t1:Ljava/lang/Object;        //无边界，将其编译为一个object类型
5: return

public static void main(java.lang.String[]);
Code:
0: return
}

2.2 有边界的泛型使用

public class TypeExtends<Q extends String> {
private Q q;

Q delete() {
return q;
}

public Q getQ() {
return q;
}

public void setQ(Q q) {
this.q = q;
}

}

使用 javap -c TypeExtends.class

Compiled from "TypeExtends.java"
public class typeParam.TypeExtends<Q extends java.lang.String> {
public typeParam.TypeExtends();
Code:
0: aload_0
1: invokespecial #12                 // Method java/lang/Object."<init>":()V
4: return

Q delete();
Code:
0: aload_0
1: getfield      #23                 // Field q:Ljava/lang/String;            //有边界，将其编译为边界类型
4: areturn
}
Compiled from "TypeExtends.java"
public class typeParam.TypeExtends<Q extends java.lang.String> {
public typeParam.TypeExtends();
Code:
0: aload_0
1: invokespecial #12                 // Method java/lang/Object."<init>":()V
4: return

Q delete();
Code:
0: aload_0
1: getfield      #23                 // Field q:Ljava/lang/String;        //有边界，将其编译为边界类型
4: areturn

public Q getQ();
Code:
0: aload_0
1: getfield      #23                 // Field q:Ljava/lang/String;        //有边界，将其编译为边界类型
4: areturn

public void setQ(Q);
Code:
0: aload_0
1: aload_1
2: putfield      #23                 // Field q:Ljava/lang/String;        //有边界，将其编译为边界类型
5: return
}

2.3 反射使用

public class compansate<T> {
Class<T> mytypes;

public T getType() throws InstantiationException, IllegalAccessException {
return mytypes.newInstance();
}

@Test
public <S> S getType(Class<S> args) throws InstantiationException, IllegalAccessException {
return args.newInstance();
}

}

使用 javap -c compansata.class

Compiled from "compansate.java"
public class typeParam.compansate<T> {
java.lang.Class<T> mytypes;            //通过class来处理类信息

public typeParam.compansate();
Code:
0: aload_0
1: invokespecial #12                 // Method java/lang/Object."<init>":()V
4: return

public T getType() throws java.lang.InstantiationException, java.lang.IllegalAccessException;
Code:
0: aload_0
1: getfield      #28                 // Field mytypes:Ljava/lang/Class;
4: invokevirtual #30                 // Method java/lang/Class.newInstance:()Ljava/lang/Object;
7: areturn

public <S> S getType(java.lang.Class<S>) throws java.lang.InstantiationException, java.lang.IllegalAccessException;
Code:
0: aload_1
1: invokevirtual #30                 // Method java/lang/Class.newInstance:()Ljava/lang/Object;
4: areturn
}