JAVA重载(overload)和覆盖(override)中的陷阱

大家都知道重载是指在同一个类中,定义了有相同名称但是有不同参数类型的方法时,到底调用那一个方法会根据参数类型来选择.我们来看下面这个例子:

class ParentClass { 
 
} 
class ChildClass extends ParentClass{ 
 
} 
public class Test { 
    public void testOverLoad(ParentClass cls){ 
        System.out.println("It's ParentClass"); 
    } 
    public void testOverLoad(ChildClass cls){ 
        System.out.println("It's ChildClass"); 
    } 
    public static void main(String[] args) { 
        Test test = new Test(); 
        ParentClass parentCls = new ParentClass(); 
        ParentClass childCls = new ChildClass(); 
         
        test.testOverLoad(parentCls); 
        test.testOverLoad(childCls); 
    } 
} 

大家想想输出的结果应该是什么呢,答案是:
It's ParentClass
It's ParentClass
原因是决定方法重载是在编译的时候发生,而不是在运行的时候.

覆盖是指在父类和子类有相同名称参数的方法,子类的方法覆盖父类的方法.来看下面的例子:

public class ParentClass { 
    public String str1 = "Parent1"; 
    public String str2 = ""; 
    public  ParentClass(){ 
        str2="Parent2"; 
    } 
    public void func(){ 
        System.out.println("ParentClass.func"); 
    } 
    public String getStr2() { 
        return str2; 
    } 
} 
public class ChildClass extends ParentClass{ 
    public String str1 = "Child1"; 
    public String str2 = "";     
    public  ChildClass(){ 
        str2="Child2"; 
    } 
     
    public void func(){ 
        System.out.println("ChildClass.func"); 
    } 
 
    public String getStr2() { 
        return str2; 
    } 
 
} 
public class Test  
    public static void main(String[] args) { 
        ParentClass childCls = new ChildClass(); 
 
        System.out.println(childCls.str1); 
        System.out.println(childCls.str2); 
        System.out.println(childCls.getStr2()); 
        childCls.func(); 
    } 
} 

输出的结果应该是什么呢,答案是:
Parent1
Parent2
Child2
ChildClass.func
原因是对于方法的覆盖发生在运行时,所以子类的方法被调用.而对于变量的覆盖是在编译的时候决定的,childCls在编译的时候类型是ParentClass,所以对变量的直接访问得到的是ParentClass中定义的值.对于成员变量,编译器会对父类和子类的所有成员变量都保存一份拷贝，所以这才有了方法的多态，并没有变量的多态。