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（贴一个 下载地址吧）。