Java基础 -- 泛型
概述:
泛型术语的意思就是“适用于许多许多的类型”,是某种不具体的类型即类型参数化,由于某些业务场景下继承类或者实现接口,同样会对程序的约束太强,而我们希望达到的目的是更通用的代码,
所有Java SE5以后增加了泛型。
用途:
创建集合类及结合java反射的通用方法
泛型类型分类:
1.泛型类
-- 泛型类的定义如下代码,粉色部分指明泛型,本例中使用 T 和 K,可以使用任意字母指定
-- 泛型类的使用,在实例化对象时指定泛型类型即new后面的类名后的部分number1,所以number3部分要和number2部分保持一致,number2部分即为确定后的类型,就和其他普通类型一样可以任意使用
//1.泛型类声明 public class Holder<T, K>{ private T a; private K b; public Holder(T a, K b){ this.a = a; this.b = b; } public T getA() { return a; } public void setA(T a) { this.a = a; } public K getB() { return b; } public void setB(K b) { this.b = b; } public static void main(String[] args){ //3.确定一具体的类型,就和普通类型一样使用 //2.指明泛型类型,传入上面的声明 Holder<String, Integer> h1 = new Holder<String, Integer>("test", 123); System.out.println(h1.getA()); System.out.println(h1.getB()); } }
2. 泛型接口
-- 泛型接口定义和泛型类定义类似,在实现类implements 接口时指定泛型类型 :public class A implements InterfaceB<String, Integer>
-- 实现类实现接口的方法
-- 具体例子参考Thinking in Java-泛型接口,书中列举了一个生成器 generator Iteratable Iterator的例子
3. 泛型方法
--泛型方法可以独立创建和所在的类是不是泛型类无关系,也就是说是否拥有泛型方法,与其所在的类是否是泛型类无关
--基本原则 如果使用泛型方法可以取代讲整个类泛型化,那么久应该只使用泛型方法,因为他可以使事情更加清楚明白--代码易读
--对于一个static方法无法访问泛型类的参数,所以,如果static方法需要使用泛型能力,就必须使其成为泛型方法
--对于一个非static成员方法,如果所在的类时泛型类,则没有必要再将该方法定义为泛型方法,因为,它已经有了泛型的功能
--泛型方法的定义及使用如以下代码,静态泛型方法定义及使用与以下相同
import java.util.HashMap; import java.util.Map; public class Holder2 { //1.定义泛型方法只需要在方法的返回类型前加上泛型类型<K, T> public <T,K> Map<T, K> addMapElement(T a, K b){ //实例化一个泛型类,只不过这个类的泛型类型是由泛型方法的泛型传入的 Map<T, K> map = new HashMap<T, K>(); map.put(a, b); return map; } public <T, K> Map<T, K> getMap(){ Map<T, K> map = new HashMap<T, K>(); return map; } public static void main(String[] args) { Holder2 a = new Holder2(); //2.隐式泛型类型调用 - jvm泛型类型自动推断 // -- 隐式的类型推断只能使用于最终方法返回结果用于赋值的情况(或者不处理返回结果),如果泛型方法的返回结果作为另一个方法的实参,则它被赋值给一个object类型,并不能推断为正确的类型 //2.1 隐式一 // -- 调用泛型方法时,没有指定泛型类型,jvm会根据实际传入的值得类型推断出类型 // -- 基本数据类型是无法作为泛型类型的,这里jvm隐式地做了Integer的类型包装 Map<String, Integer> map01 = a.addMapElement("test", 123); System.out.println("result: " + map01.get("test")); //2.2 隐式二 // -- 根据接收方法返回值的本地变量的类型自动推断 Map<String, Integer> map02 = a.getMap(); map02.put("test", 456); System.out.println("result: " + map02.get("test")); //3.显示泛型类型调用 // -- 在调用的泛型方法的名前面指明泛型类型 Map<String, Integer> map03 = a.<String, Integer>addMapElement("test", 789); System.out.println("result: " + map03.get("test")); } }
6.结合java反射实例:
import java.lang.reflect.Field; import java.lang.reflect.Method; public class Holder3 { private String name; private String age; Holder3(String name, String age){ this.name = name; this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getAge() { return age; } public void setAge(String age) { this.age = age; } public static <K> String toString(K a) throws Exception{ String str = ""; Field[] fields = a.getClass().getDeclaredFields(); for(Field field : fields){ String fieldName = field.getName(); str += fieldName + " : "; fieldName = fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1); Method m =a.getClass().getMethod("get" + fieldName); str += m.invoke(a) + "\n"; } return str; } public static void main(String[] args) throws Exception{ Holder3 h = new Holder3("lv", "30"); //以下两种调用方式都可以 //System.out.println("result:" + Holder3.<Holder3>toString(h)); System.out.println("result:" + Holder3.toString(h)); } }
7.边界
-- <T extends ParentClass & InterfaceA> 定义泛型类或者泛型接口,在之前的定义中,是无法调用泛型T对象的任何方法的,但是在设置边界后,可以调用父类对象或者接口里的方法
8. 通配符
-- ? : 表示可以是任意一种具体的泛型类型,使用形式为List<? ** **> 或者 MyClass<? ** **>,不可以出现在泛型类及泛型方法的直接定义中,就和其他普通类型一样使用
-- ?extends ClassA 成员方法,泛型方法
-- ? super ClassA 成员方法,泛型方法
-- ? extends T --用于泛型方法中
-- ? super T -- 用于泛型方法中
9.Class<?>,Class<T> 使用 MyClass.class, class传递给class变量,MyClass作为具体泛型类型
======以下为引用其他博客=====
通配符
在了解通配符之前,我们首先必须要澄清一个概念,还是借用我们上面定义的Box类,假设我们添加一个这样的方法:
1
|
public void boxTest(Box<Number> n) { /* ... */ }
|
那么现在Box<Number> n
允许接受什么类型的参数?我们是否能够传入Box<Integer>
或者Box<Double>
呢?答案是否定的,虽然Integer和Double是Number的子类,但是在泛型中Box<Integer>
或者Box<Double>
与Box<Number>
之间并没有任何的关系。这一点非常重要,接下来我们通过一个完整的例子来加深一下理解。
首先我们先定义几个简单的类,下面我们将用到它:
1
2
3
|
class Fruit {}
class Apple extends Fruit {}
class Orange extends Fruit {}
|
下面这个例子中,我们创建了一个泛型类Reader
,然后在f1()
中当我们尝试Fruit f = fruitReader.readExact(apples);
编译器会报错,因为List<Fruit>
与List<Apple>
之间并没有任何的关系。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
public class GenericReading {
static List<Apple> apples = Arrays.asList( new Apple());
static List<Fruit> fruit = Arrays.asList( new Fruit());
static class Reader<T> {
T readExact(List<T> list) {
return list.get( 0 );
}
}
static void f1() {
Reader<Fruit> fruitReader = new Reader<Fruit>();
// Errors: List<Fruit> cannot be applied to List<Apple>.
// Fruit f = fruitReader.readExact(apples);
}
public static void main(String[] args) {
f1();
}
} |
但是按照我们通常的思维习惯,Apple和Fruit之间肯定是存在联系,然而编译器却无法识别,那怎么在泛型代码中解决这个问题呢?我们可以通过使用通配符来解决这个问题:
1
2
3
4
5
6
7
8
9
10
11
12
13
|
static class CovariantReader<T> {
T readCovariant(List<? extends T> list) {
return list.get( 0 );
}
} static void f2() {
CovariantReader<Fruit> fruitReader = new CovariantReader<Fruit>();
Fruit f = fruitReader.readCovariant(fruit);
Fruit a = fruitReader.readCovariant(apples);
} public static void main(String[] args) {
f2();
} |
这样就相当与告诉编译器, fruitReader的readCovariant方法接受的参数只要是满足Fruit的子类就行(包括Fruit自身),这样子类和父类之间的关系也就关联上了。
PECS原则
上面我们看到了类似<? extends T>
的用法,利用它我们可以从list里面get元素,那么我们可不可以往list里面add元素呢?我们来尝试一下:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
public class GenericsAndCovariance {
public static void main(String[] args) {
// Wildcards allow covariance:
List<? extends Fruit> flist = new ArrayList<Apple>();
// Compile Error: can't add any type of object:
// flist.add(new Apple())
// flist.add(new Orange())
// flist.add(new Fruit())
// flist.add(new Object())
flist.add( null ); // Legal but uninteresting
// We Know that it returns at least Fruit:
Fruit f = flist.get( 0 );
}
} |
答案是否定,Java编译器不允许我们这样做,为什么呢?对于这个问题我们不妨从编译器的角度去考虑。因为List<? extends Fruit> flist
它自身可以有多种含义:
1
2
3
|
List<? extends Fruit> flist = new ArrayList<Fruit>();
List<? extends Fruit> flist = new ArrayList<Apple>();
List<? extends Fruit> flist = new ArrayList<Orange>();
|
- 当我们尝试add一个Apple的时候,flist可能指向
new ArrayList<Orange>()
; - 当我们尝试add一个Orange的时候,flist可能指向
new ArrayList<Apple>()
; - 当我们尝试add一个Fruit的时候,这个Fruit可以是任何类型的Fruit,而flist可能只想某种特定类型的Fruit,编译器无法识别所以会报错。
所以对于实现了<? extends T>
的集合类只能将它视为Producer向外提供(get)元素,而不能作为Consumer来对外获取(add)元素。
如果我们要add元素应该怎么做呢?可以使用<? super T>
:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
public class GenericWriting {
static List<Apple> apples = new ArrayList<Apple>();
static List<Fruit> fruit = new ArrayList<Fruit>();
static <T> void writeExact(List<T> list, T item) {
list.add(item);
}
static void f1() {
writeExact(apples, new Apple());
writeExact(fruit, new Apple());
}
static <T> void writeWithWildcard(List<? super T> list, T item) {
list.add(item)
}
static void f2() {
writeWithWildcard(apples, new Apple());
writeWithWildcard(fruit, new Apple());
}
public static void main(String[] args) {
f1(); f2();
}
} |
这样我们可以往容器里面添加元素了,但是使用super的坏处是以后不能get容器里面的元素了,原因很简单,我们继续从编译器的角度考虑这个问题,对于List<? super Apple> list
,它可以有下面几种含义:
1
2
3
|
List<? super Apple> list = new ArrayList<Apple>();
List<? super Apple> list = new ArrayList<Fruit>();
List<? super Apple> list = new ArrayList<Object>();
|
当我们尝试通过list来get一个Apple的时候,可能会get得到一个Fruit,这个Fruit可以是Orange等其他类型的Fruit。
根据上面的例子,我们可以总结出一条规律,”Producer Extends, Consumer Super”:
- “Producer Extends” – 如果你需要一个只读List,用它来produce T,那么使用
? extends T
。 - “Consumer Super” – 如果你需要一个只写List,用它来consume T,那么使用
? super T
。 - 如果需要同时读取以及写入,那么我们就不能使用通配符了。
如何阅读过一些Java集合类的源码,可以发现通常我们会将两者结合起来一起用,比如像下面这样:
1
2
3
4
5
6
|
public class Collections {
public static <T> void copy(List<? super T> dest, List<? extends T> src) {
for ( int i= 0 ; i<src.size(); i++)
dest.set(i, src.get(i));
}
} |
类型擦除
Java泛型中最令人苦恼的地方或许就是类型擦除了,特别是对于有C++经验的程序员。类型擦除就是说Java泛型只能用于在编译期间的静态类型检查,然后编译器生成的代码会擦除相应的类型信息,这样到了运行期间实际上JVM根本就知道泛型所代表的具体类型。这样做的目的是因为Java泛型是1.5之后才被引入的,为了保持向下的兼容性,所以只能做类型擦除来兼容以前的非泛型代码。对于这一点,如果阅读Java集合框架的源码,可以发现有些类其实并不支持泛型。
说了这么多,那么泛型擦除到底是什么意思呢?我们先来看一下下面这个简单的例子:
1
2
3
4
5
6
7
8
9
10
|
public class Node<T> {
private T data;
private Node<T> next;
public Node(T data, Node<T> next) {
this .data = data;
this .next = next;
}
public T getData() { return data; }
// ...
} |
编译器做完相应的类型检查之后,实际上到了运行期间上面这段代码实际上将转换成:
1
2
3
4
5
6
7
8
9
10
|
public class Node {
private Object data;
private Node next;
public Node(Object data, Node next) {
this .data = data;
this .next = next;
}
public Object getData() { return data; }
// ...
} |
这意味着不管我们声明Node<String>
还是Node<Integer>
,到了运行期间,JVM统统视为Node<Object>
。有没有什么办法可以解决这个问题呢?这就需要我们自己重新设置bounds了,将上面的代码修改成下面这样:
1
2
3
4
5
6
7
8
9
10
|
public class Node<T extends Comparable<T>> {
private T data;
private Node<T> next;
public Node(T data, Node<T> next) {
this .data = data;
this .next = next;
}
public T getData() { return data; }
// ...
} |
这样编译器就会将T
出现的地方替换成Comparable
而不再是默认的Object
了:
1
2
3
4
5
6
7
8
9
10
|
public class Node {
private Comparable data;
private Node next;
public Node(Comparable data, Node next) {
this .data = data;
this .next = next;
}
public Comparable getData() { return data; }
// ...
} |
上面的概念或许还是比较好理解,但其实泛型擦除带来的问题远远不止这些,接下来我们系统地来看一下类型擦除所带来的一些问题,有些问题在C++的泛型中可能不会遇见,但是在Java中却需要格外小心。
问题一
在Java中不允许创建泛型数组,类似下面这样的做法编译器会报错:
1
|
List<Integer>[] arrayOfLists = new List<Integer>[ 2 ]; // compile-time error
|
为什么编译器不支持上面这样的做法呢?继续使用逆向思维,我们站在编译器的角度来考虑这个问题。
我们先来看一下下面这个例子:
1
2
3
|
Object[] strings = new String[ 2 ];
strings[ 0 ] = "hi" ; // OK
strings[ 1 ] = 100 ; // An ArrayStoreException is thrown.
|
对于上面这段代码还是很好理解,字符串数组不能存放整型元素,而且这样的错误往往要等到代码运行的时候才能发现,编译器是无法识别的。接下来我们再来看一下假设Java支持泛型数组的创建会出现什么后果:
1
2
3
4
|
Object[] stringLists = new List<String>[]; // compiler error, but pretend it's allowed
stringLists[ 0 ] = new ArrayList<String>(); // OK
// An ArrayStoreException should be thrown, but the runtime can't detect it. stringLists[ 1 ] = new ArrayList<Integer>();
|
假设我们支持泛型数组的创建,由于运行时期类型信息已经被擦除,JVM实际上根本就不知道new ArrayList<String>()
和new ArrayList<Integer>()
的区别。类似这样的错误假如出现才实际的应用场景中,将非常难以察觉。
如果你对上面这一点还抱有怀疑的话,可以尝试运行下面这段代码:
1
2
3
4
5
6
7
|
public class ErasedTypeEquivalence {
public static void main(String[] args) {
Class c1 = new ArrayList<String>().getClass();
Class c2 = new ArrayList<Integer>().getClass();
System.out.println(c1 == c2); // true
}
} |
问题二
继续复用我们上面的Node
的类,对于泛型代码,Java编译器实际上还会偷偷帮我们实现一个Bridge method。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
public class Node<T> {
public T data;
public Node(T data) { this .data = data; }
public void setData(T data) {
System.out.println( "Node.setData" );
this .data = data;
}
} public class MyNode extends Node<Integer> {
public MyNode(Integer data) { super (data); }
public void setData(Integer data) {
System.out.println( "MyNode.setData" );
super .setData(data);
}
} |
看完上面的分析之后,你可能会认为在类型擦除后,编译器会将Node和MyNode变成下面这样:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
public class Node {
public Object data;
public Node(Object data) { this .data = data; }
public void setData(Object data) {
System.out.println( "Node.setData" );
this .data = data;
}
} public class MyNode extends Node {
public MyNode(Integer data) { super (data); }
public void setData(Integer data) {
System.out.println( "MyNode.setData" );
super .setData(data);
}
} |
实际上不是这样的,我们先来看一下下面这段代码,这段代码运行的时候会抛出ClassCastException
异常,提示String无法转换成Integer:
1
2
3
4
|
MyNode mn = new MyNode( 5 );
Node n = mn; // A raw type - compiler throws an unchecked warning
n.setData( "Hello" ); // Causes a ClassCastException to be thrown.
// Integer x = mn.data; |
如果按照我们上面生成的代码,运行到第3行的时候不应该报错(注意我注释掉了第4行),因为MyNode中不存在setData(String data)
方法,所以只能调用父类Node的setData(Object data)
方法,既然这样上面的第3行代码不应该报错,因为String当然可以转换成Object了,那ClassCastException
到底是怎么抛出的?
实际上Java编译器对上面代码自动还做了一个处理:
1
2
3
4
5
6
7
8
9
10
11
|
class MyNode extends Node {
// Bridge method generated by the compiler
public void setData(Object data) {
setData((Integer) data);
}
public void setData(Integer data) {
System.out.println( "MyNode.setData" );
super .setData(data);
}
// ...
} |
这也就是为什么上面会报错的原因了,setData((Integer) data);
的时候String无法转换成Integer。所以上面第2行编译器提示unchecked warning
的时候,我们不能选择忽略,不然要等到运行期间才能发现异常。如果我们一开始加上Node<Integer> n = mn
就好了,这样编译器就可以提前帮我们发现错误。
问题三
正如我们上面提到的,Java泛型很大程度上只能提供静态类型检查,然后类型的信息就会被擦除,所以像下面这样利用类型参数创建实例的做法编译器不会通过:
1
2
3
4
|
public static <E> void append(List<E> list) {
E elem = new E(); // compile-time error
list.add(elem);
} |
但是如果某些场景我们想要需要利用类型参数创建实例,我们应该怎么做呢?可以利用反射解决这个问题:
1
2
3
4
|
public static <E> void append(List<E> list, Class<E> cls) throws Exception {
E elem = cls.newInstance(); // OK
list.add(elem);
} |
我们可以像下面这样调用:
1
2
|
List<String> ls = new ArrayList<>();
append(ls, String. class );
|
实际上对于上面这个问题,还可以采用Factory和Template两种设计模式解决,感兴趣的朋友不妨去看一下Thinking in Java中第15章中关于Creating instance of types(英文版第664页)的讲解,这里我们就不深入了。
问题四
我们无法对泛型代码直接使用instanceof
关键字,因为Java编译器在生成代码的时候会擦除所有相关泛型的类型信息,正如我们上面验证过的JVM在运行时期无法识别出ArrayList<Integer>
和ArrayList<String>
的之间的区别:
1
2
3
4
5
6
|
public static <E> void rtti(List<E> list) {
if (list instanceof ArrayList<Integer>) { // compile-time error
// ...
}
} => { ArrayList<Integer>, ArrayList<String>, LinkedList<Character>, ... } |
和上面一样,我们可以使用通配符重新设置bounds来解决这个问题:
1
2
3
4
5
|
public static void rtti(List<?> list) {
if (list instanceof ArrayList<?>) { // OK; instanceof requires a reifiable type
// ...
}
|
参考自 Thinking In Java
相关推荐
java基础-泛型通配符
Java泛型是Java编程语言中的一种特性,它允许在数据结构(如集合)中存储特定类型的元素,从而提供了编译时的类型安全性和更清晰的代码。泛型引入的主要目标是...理解并熟练使用泛型是每个Java开发者的基础技能之一。
Java泛型是Java SE 5.0引入的一个重要特性,它极大地增强了代码的类型安全...在进行"关于Java基础的泛型的练习"时,可以尝试编写不同的泛型类、泛型方法,体验泛型带来的便利,并理解其背后的类型系统和类型擦除机制。
思维导图
【Java基础】泛型方法 - 右撇子 - 博客频道 - CSDN.NET
### Java基础 #### 1. Java概述 - **定义**:Java是一种面向对象的编程语言,由Sun Microsystems公司于1995年推出。 - **特点**: - 面向对象:支持封装、继承、多态等特性。 - 平台无关性:Java程序可以在任何...
在Java编程语言中,泛型和反射是两个非常重要的特性,它们在软件开发中有着广泛的应用。本篇文章将深入探讨这两个概念以及它们在实际开发中的小运用。 首先,我们来看泛型(Generics)。泛型是在Java SE 5.0引入的...
Java泛型是自JDK 1.5版本引入的一个重要特性,目的是为了提高代码的类型安全性和重用性。在Java中,泛型允许开发者在类、接口和方法中使用类型参数,使得代码能处理多种数据类型而无需重复编写相似的代码。然而,...
日常笔记-JAVA泛型
1. **泛型基础**: - 泛型引入了类型参数的概念,例如 `<T>`,其中 `T` 是一个占位符,代表任意类型。 - 使用泛型可以确保在编译时进行类型检查,避免运行时错误。 - 泛型方法允许我们在方法定义中使用类型参数,...
泛型基础: * 在定义泛型类或声明泛型类的变量时,使用尖括号来指定形式类型参数。 * 当声明或者实例化一个泛型的对象时,必须指定类型参数的值。 自定义简单泛型: * public class Gclass<T>{ private T a; ...
这个"java基础教程----精华版"显然是一份精心整理的资料,旨在帮助初学者快速掌握Java编程的基础知识。下面将详细介绍Java语言的核心概念和关键知识点。 1. **Java语法基础**: - **变量**:在Java中,变量是存储...
本笔记主要涵盖了数据基础和泛型编程两大主题,同时也涉及到类和对象、数据类型、类的初始化和加载以及单例模式等多个知识点。 1. **数据基础** - **形参实参的使用**:在函数调用时,形参是方法定义中的参数,而...
在Java中,泛型同样使用尖括号表示,但它的类型擦除特性使得编译后的字节码并不包含类型参数信息,而是使用Object或其他基础类型作为替代。这意味着Java的泛型不支持协变和逆变,但可以通过通配符(如?)来放宽类型...
### JAVA基础-集合类 #### 一、集合的概述与分类 ##### 1. 集合概述 集合是Java编程语言中一种重要的数据结构,它用于存储一系列的对象。与数组相比,集合提供了更加灵活的方式来处理数据。集合的一个显著特点是它...
这意味着在编译完成后,所有的泛型信息都会被擦除,替换为Object或者其他基础类型。因此,泛型在运行时并不存在,所有关于泛型的操作都在编译期间完成。 2. **边界通配符**:在处理泛型时,我们经常遇到边界通配符...
总的来说,Java泛型集合和集合框架提供了强大的数据存储和处理能力,而`Collection`接口作为基础,连接了各种集合类型。了解并熟练掌握这些概念和用法,对于提高Java编程效率和代码质量至关重要。
泛型是Java编程语言中用于减少类型转换错误和增强代码安全性的机制,它允许在定义类、接口和方法时使用类型参数。通过这种方式,可以在编译时期捕获那些只有在运行时期才会暴露的类型错误,提高了代码的健壮性。 ...