java中的几个术语(覆写override，隐藏hiding，重载overload，遮蔽shadowing，遮盖obscuring)

今天看完《Java Puzzlers》的第八章，里面各种name reuse,章节最后做了一个非常细致的总结!

Overriding(覆写)

一个实例方法可以override它的父类中可以访问的具有相同签名的所有实例方法。

class Base {
public void f() { }
}
class Derived extends Base {
public void f() { } // overrrides Base.f()
}

Hiding（隐藏）

一个域，静态方法，成员类型都会隐藏他的父类中可以访问的具有相同名字的域。静态方法和成员类型

class Base {
public static void f() { }
}
class Derived extends Base {
public static void f() { } // hides Base.f()
}

我想到了《java puzzlers》的48题

class Dog {
public static void bark() {
System.out.print("dog ");
}
}
class Basenji extends Dog {
public static void bark() { System.out.print("Basenji");}
}
public class Bark {
public static void main(String args[]) {
Dog woofer = new Dog();
Dog nipper = new Basenji();
woofer.bark();
nipper.bark();
}

如果按照上面所说的，这里面Basenji中的bark()隐藏了Dog的bark（）方法，输出应该是dog和Basenji，但是正确的输出结果是dog和dog，理由如下：

1. 静态方法的调用一般不是这么调用的，一般都是类名加上方法名进行调用

2. 静态方法不是动态分配的，是在编译的时候进行分配的，因为woofer和nipper都是Dog所以调用的都是Dog的bark()方法。

Overloading (重载)

类中的方法可以重载类中的其他的方法，只要他们具有相同的名字和不同的签名(参数个数不同，参数，类型不同，如果仅仅是返回值不同的话，编译报错)

class CircuitBreaker {
public void f(int i){ } // int overloading
public void f(String s) { } // String overloading
}

Shadowing(遮蔽)

当前作用域一个变量，方法或者类型可以遮蔽其他其他作用域的具有相同名字的变量，方法和类型

class WhoKnows {
static String sentence = "I don't know.";
}
public static void main(String[] args) {
String sentence = "I know!";// shadows static field
System.out.println(sentence);// prints local variable
}

class Belt {
private final int size;
public Belt(int size) { // Parameter shadows Belt.size
this.size = size;
}

Obscuring（遮盖）

在同一个作用范围中，如果出现了具有相同名字的变量，类型(方法，类，接口等)，包名，变量会遮盖类型和包，类型回遮盖包，其实只用遵守java的命名规范就可以消除产生遮盖的可能性

public class Obscure {
static String System; // Obscures type java.lang.System
}
public static void main(String[] args) {
// Next line won't compile: System refers to static field
System.out.println("hello, obscure world!");
}

在贴一个例子《java puzzlers》第68题

public class ShadesOfGray {
public static void main(String[] args) {
System.out.println(X.Y.Z);

//the null reference can cast to the class X.Y
//so we can access the Z field
System.out.println(((X.Y)null).Z);
}
}

/**
*
*  When a variable and a type have the same name and both are in scope,
*   the variable name takes precedence [JLS 6.5.2].
*   The variable name is said to obscure the type name [JLS 6.3.2].
*    Similarly,variable and type names can obscure package names.
*
*/
class X {
static class Y {
//variable > type > package
static String Z = "Black";
}

static C Y = new C();
}

class C {
String Z = "White";
}

根据上面所说的，当要访问X。Y。Z的时候访问的是变量Y中Z，所以输出结果是White.
((X.Y)null).Z, 因为null是一个引用，将其转换成X.Y的时候编译器会自动匹配static class Y（static C Y中Y是一个变量，是不能将null转换成该变量），所以输出是Black

再次感慨《java puzzlers》是一本好书，里面讲了不少java里面的一些容易忽视的pitfalls和traps（贴一个下载地址吧）。