Hycz's Blog

Life is a game. Why so serious?

Wildcard Type学习笔记

有三种关于wildcard的用法

  • ? extends Employee
  • ? super Manager
  • ?

一、测试背景

有一个泛型Pair<T>

package genericProgramming;

public class Pair<T> {
	public Pair(){
		first = null;
		second = null;
	}

	public Pair(T first, T second){
		this.first=first;
		this.second=second;
	}

	public T getFirst() {
		return first;
	}

	public void setFirst(T first) {
		this.first = first;
	}

	public T getSecond() {
		return second;
	}

	public void setSecond(T second) {
		this.second = second;
	}

	private T first;
	private T second;
}

两个有继承关系的类Employee和Manager,这里Manager extends Employee,Employee extends Object

package genericProgramming;

import java.util.*;

public class Employee {
	private String name;
	private double salary;
	private Date hireDay;

	public Employee(String n, double s, int year, int month, int day){
		name =n;
		salary =s;
		GregorianCalendar calendar = new GregorianCalendar(year, month-1, day);
		hireDay= calendar.getTime();
	}

	public String getName() {
		return name;
	}

	public double getSalary() {
		return salary;
	}

	public Date getHireDay() {
		return hireDay;
	}

	public void raiseSalary(double byPercent){
		double raise=salary * byPercent/100;
		salary+=raise;
	}
}
package genericProgramming;

public class Manager extends Employee {
	private double bonus;

	public Manager(String n, double s, int year, int month, int day){
		super(n,s,year,month,day);
		bonus=0;
	}

	public double getSalary(){
		double baseSalary=super.getSalary();
		return baseSalary+bonus;
	}

	public void setBonus(double b){
		bonus=b;
	}

	public double getBonus(){
		return bonus;
	}
}

二、关于三种wildcard的用法

关于 ? extends Employee :

  • 当如此定义时,调用时填入的必须是Employee本身或其子类,例如可以填入Employee,或者Manager,但是不能是Object。如下图所示:
  • Pair<? extends Employee>是Pair<Employee>和Pair<Manager>的super class
  • ? extends Employee getFirst() //合法
    void setFirst(? extends Employee) //不合法
    关于以上两行,更直观的是看使用过程中到底发生了什么

    先看看在get方法中发生了什么,如同 ? extends Employee getFirst() 定义的方法,如上图所示,显然是合法的,问题就是到底返回值究竟能赋给什么类型,实验的三种类型,Manager,Employee,Object,只有后两个能成功,所以,能接受 ? extends xxx 类型返回值的,是xxx以及其所有super class

    然后看看set方法中发生了什么,如上图所示,当尝试用 ? extends Employee 作为参数的类型时,编译器所认为的参数类型却是null,编译器无法确定究竟应该用什么类型去匹配参数,虽然看上去应该填入一个Employee的sub class。当然填入null是合法的,但是程序却无法正确进行下去了。
    实际上,从实际使用中考虑,这也是合理的。? extends Employee 是替代泛型<T>中的T的,显然在定义中,如果有两个变量a和b,他们都是T类型,那么a和b是可以相互赋值的,比如a=b,但是当T由? extends Employee替换之后,调用时,用来替换? extends Employee的可能是Employee的sub class A,或者B,将一个class A的变量和一个class B的变量相互赋值,显然是有问题的。
    所以,对于 ? extends xxx ,get方法可用,set方法不可用

关于 ? super Manager :

  • 当如此定义时,调用时填入的必须是Manager本身或其超类,例如可以填入Manager,Employee,Object,具体如下图:

  • Pair<? super Manager>是Pair<Manager>,Pair<Employee>和Pair<Object>的super class
  • ? super Manager getFirst()
    void setFirst(? super Manager)
    与上面的相反,? super Manager的缺陷是在get方法上,如下图:

    get方法虽然可以用,但是返回的类型是Object,之所以还能用的原因是Manager的super class是可数的,有终点的,于是那个终点Object就作为了返回类型,这样做是安全的。相比之下,满足? extends Employee的class数量是不确定的。
    关于set方法,如下图:

    这里很有趣,我曾以为能够填入的参数类型是Manager本身或其super class,然而实际上恰巧相反,对于set方法参数中的 ? super xxx,应该填入的类型是xxx本身或其sub class。仔细想一下,从起始的泛型到最后的调用,顺序应该是这样的:Pair<T>,Pair<? super Manager>,Pair<Manager>,Pair<Employee>或Pair<Object>,最后是setFirst(val),可见,val的类型必须同时满足使用? super Manager可能产生的所有情况,在这里,也就是Manager,Employee和Object,所以val的类型只能是Manager或其子类了

关于 ? :

  • Pair<?>似乎与Pair<T>很相像,但是Pair<?>继承了上述的诸多限制,而且是最坏的限制,比如get方法只能返回Object,set方法非法

三、泛型(generic)和通配符(wildcard)

我的理解是,泛型就像c里面的宏,用法像是直接无条件地将类型参数用给定的类名在源代码中替换掉,通配符的使用则是有条件地将类型参数用给定的类名在源代码中替换掉,然后再产生了一系列的使用限制(如上所说)

Advertisements

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

%d bloggers like this: