1 泛型接口
1.1 接口定义
interface 接口名称<泛型标识>{}
1
2
3
4
5
|
// 在接口上定义泛型
interface Info<T>{
// 定义抽象方法，抽象方法的返回泛型类型的值
public T getVar() ;
}
|
1.2 接口实现
1.2.1 在子类的定义上也声明泛型类型
1
2
3
4
5
6
7
8
9
10
11
12
13
|
interface Info<T>{
public T getVar() ;
}
// 定义泛型接口的子类
class InfoImpl<T> implements Info<T>{
private T var ;
public InfoImpl(T var){
}
public T getVar(){
return this.var ;
}
}
|
1.2.2 实现接口直接指定具体的操作类型
1
2
3
4
5
6
7
8
9
10
11
12
13
|
interface Info<T>{
public T getVar() ;
}
// 定义泛型接口的子类
class InfoImpl implements Info<String>{
private T var ;
public InfoImpl(T var){
}
public T getVar(){
return this.var ;
}
}
|
2 泛型方法
2.1 定义
[访问权限] <泛型标识> 泛型标识 方法名([泛型标识 参数名]){}
1
2
3
4
5
6
|
class GenericMethod{
// 可以接收任意类型的数据
public <T> T methodA(T t){
return t ;
}
}
|
2.2 示例
通过泛型方法返回泛型类的实例
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
|
// 指定上限，只能是数字类型
class Info<T extends Number>{
private T var ;
public T getVar(){
return this.var ;
}
public void setVar(T var){
this.var = var ;
}
}
class GenericMain {
public static void main(String args[]) {
Info<Integer> i = fun(30);
System.out.println(i.getVar());
Info<Integer> i1 = new Info<Integer>() ;
i1.setVar(1);
Info<Integer> i2 = new Info<Integer>() ;
i2.setVar(2);
add(i1,i2);
}
public static <T extends Number> Info<T> fun(T param) {
// 实例化Info
Info<T> temp = new Info<T>();
temp.setVar(param);
return temp;
}
public static <T extends Number> void add(Info<T > i1,Info<T> i2){
System.out.println(i1.getVar() + " + " + i2.getVar()) ;
}
}
|
3 泛型数组
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
class GenericArray{
public static void main(String args[]){
Integer i[] = fun(1,2,3,4) ;
print(i) ;
}
// 接收可变参数
public static <T> T[] fun(T...arg){
return arg ;
}
public static <T> void print(T param[]){
for(T t:param){
System.out.print(t + "、") ;
}
}
}
|
4 泛型继承
4.1 子类的泛型参数和父类的参数一致
最常用的继承
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
class Father<T> {
T data;
public Father(T data) {
this.data = data;
}
@Override
public String toString() {
return "Father data = "+ data;
}
}
class Son<T> extends Father<T> {
public Son(T data) {
super(data);
}
@Override
public String toString() {
return "Son1 data=" + data;
}
}
|
4.2 子类增加了一个泛型参数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
class Father<T> {
T data;
public Father(T data) {
this.data = data;
}
@Override
public String toString() {
return "Father data = "+ data;
}
}
class Son<E, T> extends Father<T> {
E other;
public Son(T data, E other) {
super(data);
this.other = other;
}
@Override
public String toString() {
return "Son otherData=" + other + ", data=" + data;
}
}
|
4.3 继承时指定父类的泛型参数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
class Father<T> {
T data;
public Father(T data) {
this.data = data;
}
@Override
public String toString() {
return "Father data = "+ data;
}
}
class Son extends Father<Integer> {
public Son4(Integer data) {
super(data);
}
@Override
public String toString() {
return "Son data=" + data;
}
}
|
4.4指定父类的泛型,子类又增加了自己的泛型
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
class Father<T> {
T data;
public Father(T data) {
this.data = data;
}
@Override
public String toString() {
return "Father data = "+ data;
}
}
class Son<T> extends Father<Integer> {
T other;
public Son(Integer data, T other) {
super(data);
this.other = other;
}
@Override
public String toString() {
return "Son other=" + other + ", data=" + data;
}
}
|
4.5 接口继续，接口实现
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
//用户基础接口
public interface UserBaseService<T extends UserBase> {
void save(T user);
void common(T user);
}
//用户接口
public interface UserService<T extends UserBase> extends UserBaseService<T>{
void userSelfMethod();
}
//基础接口实现类
public abstract class UserBaseServiceImpl<T extends UserBase> implements UserBaseService<T> {
void common(T user){
save(user);
}
}
//用户基础基础接口实现，实现用户接口
public class UserServiceImpl extends UserBaseServiceImpl<User> implements UserService<User>{
void save(User user){
}
void userSelfMethod(){
}
}
|
4.6 通配符
- <? extends T>是指 “上界通配符（Upper Bounds Wildcards）“
元素类型都是T的子类(包含本身),禁止做插入操作，只做读取
- <? super T>：是指 “下界通配符（Lower Bounds Wildcards）”
元素都是T的父类(包含本身),只能对这个泛型做插入操作，而无法读
本文为学习记录，因能力有限，如有错误请赐教……如需转载，请注明出处！