Order of searching for an identifier (JPL pg 113 and JLS §6.5)

• when a name (identifier) is used; the meaning, or scope, of it's name is searched for based on where it appears in the code starting with:

1. if used in a code block, for-loop, or in a catch clause, search is for a local variable within the enclosing construct
2. if in a method or constructor, searches for a matching parameter
3. search continues for a class or interface member, including inherited members
4. if its a nested type, searches enclosing block or class. If its a static type, only static members of enclosing blocks or classes are searched.
5. explicitly named imported types
6. other types declared in the same package
7. implicitly named imported types
8. packages on the host system

Shadowing (JLS §6.3.1)

• Because of the way identifiers are looked up; shadowing declarations can occur
• For example, a field declaration can be shadowed by a local variable declaration

class TestShadowing {
  static int x = 1;           // field variable
  
  public static void main(String[] args) {
      int x = 0;              // local variable
      System.out.println("x = " + x);
      System.out.println("TestShadowing.x = " + TestShadowing.x)
  }
}

Output:
    x = 0
    TestShadowing.x = 1

• because the identifier x is used within a code block main() a search is made for a declaration of x within the body of main(). As one is found, int x = 0, the simple identifier name x is assumed to be within scope as a local variable
• to access the field variable x, you must use its fully-qualified name TestShadowing.x

Hiding

• Shadowing is not the same as hiding
• hiding applies to members that would normally be inherited but are not because of a declaration of the same identifier in a subclass (JLS § 6.1.3)

class SuperA {
    int x = 10;
}

class SubA extends SuperA {
    int x = 20;           // hides x in superclass
}

• a method can hide a method in the superclass by overriding it
  

class SuperA {
    static void method2() {
    }
}

class SubA extends SuperA() {
    void method2() {
        // declaration causes a compile-error
    }
    
    static void method2() {
        // compiles ok
    }
}

class SuperA {
    void method1() {
    }
}

class SubA extends SuperA() {

    static void method1() {
        // compile-error
    }
}

• a hidden method can be accessed by using super(), casting to the superclass or using the methods fully qualified name (JLS §8.4.6.2)

    ((SuperA)y).method2();  // cast to access hidden method    

• instance variables can hide static and non-static variables in the superclass (JLS §8.4.6.1)

Obscuring (JLS §6.3.2)

• there may be times when a simple name could be interpreted as a variable, a type or a package
• based on the rules, a variable will be chosen before a type, and a type before a package
• in such situations a declaration is said to be obscured
• following naming conventions helps to avoid obscuring (see Naming conventions).

Also See

Tech Tip on Sun Site re: Shadowing, hiding, etc