博客

在java面向对象编程中，我们最常遇到的两个场景是覆盖和重载。这两种情形是因为方法名相同的不同展现形式。

方法覆盖是表现在父类和子类之间。

方法重载发生在一个类的内部。

在面向对象编程中，我们还可能出现下面几种场景：

隐藏：在父类中定义了静态方法，在子类中，定义了同名的静态方法。

package com.xxx.oop;
public class HideExample {

    public static void main(String[] args) {
        Dog dog = new Dog();
        Dog basenji = new Basenji();
        //Basenji basenji = new Basenji();
        dog.bark();
        basenji.bark();
        System.out.println(dog.name);
        System.out.println(basenji.name);
    }

}
class Dog{
    protected String name = "dog";

    public static void bark(){
        System.out.println("woof");
    }
}

class Basenji extends Dog{
    protected String name = "basenji";
    public static void bark(){
        System.out.println("miao");
    }
}

程序运行的结果：

woof
woof
dog
dog

我们修改Dog basenji = new Basenji() 为 Basenji basenji = new Basenji();

这个时候，才可能打印我们期望的结果：

woof
miao
dog
basenji

遮蔽：在类内部，我们定义了一个全局变量，在方法体内，我们又定义了一个同名的变量。

package com.xxx.oop;
public class ShadowExample {
    static final String sentence = "i don't know.";

    public static void main(String[] args) {
        String sentence = "i know.";
        System.out.println(sentence);
    }

}

这种情况，在其他语言里面也类似，最终程序运行，读取变量采取就近原则。在java里面这种情形就是遮蔽shadow。

遮掩：在类内部，我们定义了一个变量，但是这个变量是已经有命名空间的关键字名字。

package com.xxx.oop;
public class ObscureExample {
    static final String System = "hello.";
    public static void main(String[] args) {
        System.out.println("hello,obscure.");
    }
}

这种情况在编译阶段就会报错，这里本来想读取java.lang命名空间下的System类，但是因为我们定义了局部变量System，java.lang.System就不能通过简单的包名访问了。