使用泛型
class ArrayList<T>
{
private T[] array;
private int size;
public void add(T e)
{}
}
使用泛型
ArrayList list = new ArrayList(); //不定义泛型时,相当于是Object
List<Number> list1 = new ArrayList<Number>();
//泛型接口
interface Comparable<T>
{
int compareTo(T o);
}
class Person implements Comparable<Person>
{
String name;
int score;
Person(String name, int score)
{
this.name = name;
this.score = score;
}
public int compareTo(Person person)
{
return this.name.compareTo(person.name);
}
}
class ArrayList<T> implements List<T>
{
private T[] array;
private int size;
@Override
public int size() {
return 0;
}
@Override
public boolean isEmpty() {
return false;
}
@Override
public boolean contains(Object o) {
return false;
}
@Override
public Iterator<T> iterator() {
return null;
}
@Override
public Object[] toArray() {
return new Object[0];
}
@Override
public <T1> T1[] toArray(T1[] a) {
return null;
}
public boolean add(T e)
{
return false;
}
@Override
public boolean remove(Object o) {
return false;
}
@Override
public boolean containsAll(Collection<?> c) {
return false;
}
@Override
public boolean addAll(Collection<? extends T> c) {
return false;
}
@Override
public boolean addAll(int index, Collection<? extends T> c) {
return false;
}
@Override
public boolean removeAll(Collection<?> c) {
return false;
}
@Override
public boolean retainAll(Collection<?> c) {
return false;
}
@Override
public void clear() {
}
@Override
public T get(int index) {
return null;
}
@Override
public T set(int index, T element) {
return null;
}
@Override
public void add(int index, T element) {
}
@Override
public T remove(int index) {
return null;
}
@Override
public int indexOf(Object o) {
return 0;
}
@Override
public int lastIndexOf(Object o) {
return 0;
}
@Override
public ListIterator<T> listIterator() {
return null;
}
@Override
public ListIterator<T> listIterator(int index) {
return null;
}
@Override
public List<T> subList(int fromIndex, int toIndex) {
return null;
}
}
编写泛型
//多个泛型类型
class Map<T,K>
{
private T first;
private K second;
}
class Pair<T>
{
private T first;
private T second;
public Pair(T first, T second)
{
this.first = first;
this.second = second;
}
public T getFirst()
{
return first;
}
public <K> void getSecond()
{
//return second;
}
//静态泛型
//静态方法不能引用泛型类型<T>,必须定义其他类型(例如<K>)来实现静态泛型方法;
public static <K> Pair<K> create(K first, K last)
{
return new Pair<K>(first, last);
}
}
泛型方法
//泛型方法
class Demo
{
public <T> void show(T t)
{
}
public <Q> void print(Q q)
{
}
}
擦拭法
//所谓擦拭法是指,虚拟机对泛型其实一无所知,所有的工作都是编译器做的
Pair<String> p1 = new Pair<String>("1", "2");
Pair<Integer> p2 = new Pair<Integer>(1,2);
Class c1 = p1.getClass();
Class c2 = p2.getClass();
//c1 && c2 是同一个Class, 都是Object的Class
class Pai3<T> {
private T first;
private T last;
public Pai3(Class<T> cls) throws IllegalAccessException, InstantiationException {
// Compile error:
// first = new T();
// last = new T();
// 在擦拭后变成了
// first = new Object();
// last = new Object();
first = cls.newInstance();
}
}
class Pai<T> {
private T first;
private T last;
public Pai(T first, T last) {
this.first = first;
this.last = last;
}
public T getFirst() {
return first;
}
public T getLast() {
return last;
}
}
//经过编译器后:
// 编译器把类型<T>视为Object,编译器根据<T>实现安全的强制转型,
// 虚拟机执行的上述代码:
class Pai1 {
private Object first;
private Object last;
public Pai1(Object first, Object last) {
this.first = first;
this.last = last;
}
public Object getFirst() {
return first;
}
public Object getLast() {
return last;
}
}
// 所以泛型不能处理不是继承Object的基本类型
//e.g.pair<int> error
泛型继承
//泛型继承
class intPair extends Pair<Integer>
{
public intPair(Integer first, Integer second)
{
super(first, second);
}
}
Class<intPair> cls = intPair.class;
Type t = cls.getGenericSuperclass();
if (t instanceof ParameterizedType) {
ParameterizedType pt = (ParameterizedType) t;
Type[] types = pt.getActualTypeArguments(); // 可能有多个泛型类型
Type firstType = types[0]; // 取第一个泛型类型
Class<?> typeClass = (Class<?>) firstType;
System.out.println(typeClass); // Integer
}