-
什么是泛型?
-
一个泛型类(generic class)就是有一个或多个类型变量的类。
-
又叫做参数化类型,将类型当做参数传递给一个类或者方法
-
为什么要使用泛型程序设计?
-
泛型程序设计意味着编写的代码可以被很多不同类型的对象所重用。泛型可以看作是普通的工厂
-
泛型类声明
原生态类型
/**
* 原生态类型
*/
public class Stack {
private Object[] elements;
private int size = 0;
private static final int DEFAULT_INITIAL_CAPACITY = 16;
public Stack() {
elements = new Object[DEFAULT_INITIAL_CAPACITY];
}
public void push(Object e) {
ensureCapacity();
elements[size++] = e;
}
public Object pop() {
if (size == 0) {
throw new EmptyStackException();
}
Object result = elements[size--];
elements[size] = null;
return result;
}
public boolean isEmpty() {
return size == 0;
}
private void ensureCapacity() {
if (elements.length == size) {
elements = Arrays.copyOf(elements, 2 * size + 1);
}
}
}
泛型类声明方式一
/**
* 原生态类型转泛型类型方式一(较常用)
*/
public class StackE1<E> {
private E[] elements;
private int size = 0;
private static final int DEFAULT_INITIAL_CAPACITY = 16;
@SuppressWarnings("unchecked")
public StackE1() {
// 创建Object 数组,并转换成泛型数组
elements = (E[]) new Object[DEFAULT_INITIAL_CAPACITY];
}
public void push(E e) {
ensureCapacity();
elements[size++] = e;
}
public E pop() {
if (size == 0) {
throw new EmptyStackException();
}
E result = elements[size--];
elements[size] = null;
return result;
}
public boolean isEmpty() {
return size == 0;
}
private void ensureCapacity() {
if (elements.length == size) {
elements = Arrays.copyOf(elements, 2 * size + 1);
}
}
}
泛型类声明二
/**
* 原生态类型转泛型类型方式二
*/
public class StackE2<E> {
private Object[] elements;
private int size = 0;
private static final int DEFAULT_INITIAL_CAPACITY = 16;
public StackE2() {
// 创建Object 数组,并转换成泛型数组
elements = new Object[DEFAULT_INITIAL_CAPACITY];
}
public void push(E e) {
ensureCapacity();
elements[size++] = e;
}
public E pop() {
if (size == 0) {
throw new EmptyStackException();
}
@SuppressWarnings("unchecked")
E result = (E) elements[--size];
elements[size] = null;
return result;
}
public boolean isEmpty() {
return size == 0;
}
private void ensureCapacity() {
if (elements.length == size) {
elements = Arrays.copyOf(elements, 2 * size + 1);
}
}
}
-
泛型方法
原始泛型方法
public class StackMethod {
public static Set union(Set s1,Set s2){
Set result = new HashSet(s1);
result.add(s2);
return result;
}
}
泛型方法声明
public class StackMethodM1 {
// 1.public static Set<E> 之间的<E> 代表什么意思?
// 它表示一个类型参数,能被用来声明返回值类型,并且能作为泛型方法得到的实际参数类型的占位符,这个过程称为类型推导
// 2.Set<E> s1, Set<E> s2 代表什么意思?
// 字母E是一个代号,被称为类型变量或类型参数,当然你也可以换成a,b,c...这么写更规范,通常有E(element)、T(type)、K、V、N(number)
// 注意类型参数只能代表引用型类型,不能是原始类型(像int,double,char...)
public static <E> Set<E> union(Set<E> s1, Set<E> s2) {
Set<E> result = new HashSet<E>(s1);
result.addAll(s2);
return result;
}
}
-
泛型单例工厂(类型推导的应用)
泛型静态工厂方法,目的是为了消除,Map<String,List<String>> map = new HashMap<String,List<String>>(),标记部分的冗余部分
public class HashMapUtil {
// 泛型静态工厂方法
public static <K, V> HashMap<K, V> newInstance() {
return new HashMap<K, V>();
}
}
客户端实例
public class HashMapInstance {
public static void main(String[] args) {
// 利用工具类创建HashMap 对象
Map<String, List<String>> map = HashMapUtil.newHashMap();
// 原始方法创建HashMap 对象
Map<String, List<String>> map1 = new HashMap<String, List<String>>();
}
}
-
递归类型限制
定义一个泛型接口,跟泛型类差不多
public interface IUnaryFun<T> {
T apply(T arg);
}
假设需要提供一个恒等函数,如果在每次需要的时候都重新创建一个,这样会很浪费,因为他是无状态的,如果泛型被具体化了,每个类型都需要一个恒等函数,但是他们被擦除以后,就只需要一个泛型单例。
/**
* 递归限制类型
*/
public class RecursiveType {
// 泛型单例工厂模式
private static IUnaryFun<Object> IDENTITY_FUN = new IUnaryFun<Object>() {
public Object apply(Object arg) {
return arg;
}
};
// 无状态的参数类型
@SuppressWarnings({ "unchecked" })
private static <T> IUnaryFun<T> identityFun() {
return (IUnaryFun<T>) IDENTITY_FUN;
}
public static void main(String[] args) {
String[] strings = { "bob", "lily", "lucy" };
IUnaryFun<String> sameString = identityFun();
for (String s : strings) {
System.out.println(sameString.apply(s));
}
Number[] numbers = { 1, 1.1d, 2.2f };
IUnaryFun<Number> sameNumber = identityFun();
for (Number n : numbers) {
System.out.println(sameNumber.apply(n));
}
}
}
-
通配符限制和PECS
在泛型类型声明一种添加的pushAll() 方法,如下
public void pushAll(Iterable<E> src) {
for (E e : src) {
push(e);
}
}
客户端如下图的错误信息,因为如前所述,参数化类型是不可变得,因此无法将Integer 类型的数据插入Number 类型的参数中,尽管Number 是Integer 的父类
Java 提供一种特许的参数化类型:有限制的通配符类型 来处理这种情况。pushAll 输入的参数不应为“E 的Iterable 接口”,而应该为“E 的某个子类型的Iterable 接口”,有一个通配符类型正符合此意:Iterable<? Extends E>,修改后的代码如下,StackE3 可以正确无误地编译,这个也叫上界通配符
public void pushAll(Iterable<? extends E> src) {
for (E e : src) {
push(e);
}
}
编写与pushAll 方法呼应的popAll方法,从堆栈中弹出每个元素,并将这些元素添加到指定集合中,在泛型类型声明一种添加的popAll() 方法,如下
public void popAll(Collection<E> dst) {
while (!isEmpty()) {
dst.add(pop());
}
}
客户端如下图错误信息,同样的,因为Collection<Object> 不是Collection<Number> 的子类型
popAll 的输入参数类型不应该为“E 的集合”,而应该为“E 的某种超类的集合”,通俗的讲,就是Number 类型的数据无法添加到Object 类型,他们之间一开始是没关系的,这时仍有一个通配符正符合此意:Collection<? super E>。这也叫下界通配符
public void popAll(Collection<? super E> dst) {
while (!isEmpty()) {
dst.add(pop());
}
}