这里是一个Pair<T>泛型类。
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 T getSecond(){return second;}
public void setFirst(T newValue)
{
first=newValue;
}
public void setSecond(T newValue)
{
second=newValue;
}
private T first;
private T second;}
大家知道以上的泛型类经过编译之后,由编译器提供一个原始类T将被翻译成Object
再看下面的类
class DateInterval extends Pair<Date>
{
public void setSecond(){
if (Second.compareTo(getFirst())>=0)
super.setSecond(second);
}
}
方法擦除后带来了复杂的问题。
令人感到器官的是,存在另一个从Pair继承的setSecond方法,即public void setSecond(Object second);
考虑下面的语句
Pair<Date> pair =new DateInterval();
pair.setSecond(new Date());调用的却是DateInterval.setSecond(Date date)方法为何???????
再看下面的代码(不要与上面混为一谈这事另一个测试):
import java.util.Date;public class PairT { public static void main(String[] args) {
superClass f=new subClass();
f.set(new B());
}}class A{
int i;
}
class B extends A{
int i;
}
class superClass{
public void set(A a){
System.out.println("father");
}
}
class subClass extends superClass{
public void set(B a){
System.out.println("son");
}
}
运行结果是
father.
这里调用的是父类的set()
谁能给我解释一下,这到底是怎么回事。
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 T getSecond(){return second;}
public void setFirst(T newValue)
{
first=newValue;
}
public void setSecond(T newValue)
{
second=newValue;
}
private T first;
private T second;}
大家知道以上的泛型类经过编译之后,由编译器提供一个原始类T将被翻译成Object
再看下面的类
class DateInterval extends Pair<Date>
{
public void setSecond(){
if (Second.compareTo(getFirst())>=0)
super.setSecond(second);
}
}
方法擦除后带来了复杂的问题。
令人感到器官的是,存在另一个从Pair继承的setSecond方法,即public void setSecond(Object second);
考虑下面的语句
Pair<Date> pair =new DateInterval();
pair.setSecond(new Date());调用的却是DateInterval.setSecond(Date date)方法为何???????
再看下面的代码(不要与上面混为一谈这事另一个测试):
import java.util.Date;public class PairT { public static void main(String[] args) {
superClass f=new subClass();
f.set(new B());
}}class A{
int i;
}
class B extends A{
int i;
}
class superClass{
public void set(A a){
System.out.println("father");
}
}
class subClass extends superClass{
public void set(B a){
System.out.println("son");
}
}
运行结果是
father.
这里调用的是父类的set()
谁能给我解释一下,这到底是怎么回事。
第二个中的subClass.set(B a)并不是superClass.set(A a)的重写,执行时仍以superClass的为准
ms好像是因为jdk1.6中才将这种情况也当作重写吧
查了资料,我自己的理解如下:请各位大侠批评指正在类DateInterval 中 应该由编译器生成一个桥方法
public void setSecond(Object date){
setSecond((Date)date);
}
我估计是为了造成一定的假象使
class DateInterval extends Pair <Date>
{
public void setSecond(Date date){
if (Second.compareTo(getFirst())>=0)
super.setSecond(second);
}
}
中的setSecond(Date date)方法看上去仍像覆盖,实际上由父类生成的原形 方法是void setSecond(Object date);
因为开发者之所以要这么写,我估计是为了实现多太,但是如果按平常的理论,只有方法签名相同的才能够叫作覆盖(父类与子类之间)。而Object 与 Date不同所以不能覆盖。为了实现泛型类的多态,便在子类中产生了桥方法,是这么个道理不?
第二题中superClass的set(A a)和subClass中的set(B a)是不同的,不是覆盖,
所以:
superClass f=new subClass();
f.set(new B());
f调用的是superClass中的set