Overriding An instance method overrides all accessible instance methods with the same signature in superclasses, enabling dynamic dispatch; in other words, the VM chooses which overriding to invoke based on an instance’s run-time type. Overriding is fundamental to object-oriented programming and is the only form of name reuse that is not generally discouraged:
// Base Class class Base {
public void f()
{ } } // Derived Class class Derived extends Base {
// overrides Base.f() public void f()
{ } } |
Hiding A field, static method, or member type hides all accessible fields, static methods, or member types, respectively, with the same name (or, for methods, signature) in supertypes. Hiding a member prevents it from being inherited :
// Base class class Base {
public static void f()
{ }
} // Derived class class Derived extends Base {
// hides Base.f()
public static void f()
{ }
} |
Overloading Methods in a class overload one another if they have the same name and different signatures. The overloaded method designated by an invocation is selected at compile time:
// Base class class GeeksForGeeks {
// int overloading
public void f( int i)
{ }
// String overloading
public void f(String s)
{ }
} |
Shadowing A variable, method, or type shadows all variables, methods, or types, respectively, with the same name in a textually enclosing scope. If an entity is shadowed, you cannot refer to it by its simple name; depending on the entity, you cannot refer to it at all:
// Base class class GeeksForGeeks {
static String sentence = "I don’t know." ;
public static void main(String[] args) {
// shadows static field
String sentence = "I know!" ;
// prints local variable
System.out.println(sentence);
}
} |
Although shadowing is generally discouraged, one common idiom does involve shadowing. Constructors often reuse a field name from their class as a parameter name to pass the value of the named field. This idiom is not without risk, but most Java programmers have decided that the stylistic benefits outweigh the risks:
class Shirt {
private final int size;
// Parameter shadows Shirt.size
public Shirt( int size) {
this .size = size;
}
} |
Obscuring A variable obscures a type with the same name if both are in scope: If the name is used where variables and types are permitted, it refers to the variable. Similarly, a variable or a type can obscure a package. Obscuring is the only kind of name reuse where the two names are in different namespaces: variables, packages, methods, or types. If a type or a package is obscured, you cannot refer to it by its simple name except in a context where the syntax allows only a name from its namespace. Adhering to the naming conventions largely eliminates obscuring
public class Obscure {
// Obscures type java.lang.System
static String System;
public static void main(String[] args) {
// Next line won’t compile:
// System refers to static field
System.out.println( "hello, obscure world!" );
}
} |