Diferentes técnicas de reutilización de nombres en Java

Anulación Un método de instancia anula todos los métodos de instancia accesibles con la misma firma en las superclases, lo que permite el envío dinámico; en otras palabras, la máquina virtual elige qué anulación invocar en función del tipo de tiempo de ejecución de una instancia. La anulación es fundamental para la programación orientada a objetos y es la única forma de reutilización de nombres que generalmente no se desaconseja:

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

Ocultar un campo, método estático o tipo de miembro oculta todos los campos accesibles, métodos estáticos o tipos de miembro, respectivamente, con el mismo nombre (o, para métodos, firma) en supertipos. Ocultar un miembro evita que se herede: 

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

Sobrecarga Los métodos en una clase se sobrecargan entre sí si tienen el mismo nombre y firmas diferentes. El método sobrecargado designado por una invocación se selecciona en tiempo de compilación: 

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

Sombreado Una variable, método o tipo sombrea todas las variables, métodos o tipos, respectivamente, con el mismo nombre en un ámbito textualmente envolvente. Si una entidad está sombreada, no puede referirse a ella por su nombre simple; dependiendo de la entidad, no puede referirse a ella en absoluto: 

// 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);
  }
}

Aunque generalmente se desaconseja el sombreado, un idioma común implica el sombreado. Los constructores suelen reutilizar un nombre de campo de su clase como nombre de parámetro para pasar el valor del campo con nombre. Esta expresión no está exenta de riesgos, pero la mayoría de los programadores de Java han decidido que los beneficios estilísticos superan los riesgos:

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

Obscuring Una variable oscurece un tipo con el mismo nombre si ambos están en el alcance: si el nombre se usa donde se permiten variables y tipos, se refiere a la variable. De manera similar, una variable o un tipo pueden ocultar un paquete. El oscurecimiento es el único tipo de reutilización de nombres donde los dos nombres están en diferentes espacios de nombres: variables, paquetes, métodos o tipos. Si un tipo o paquete está oculto, no puede referirse a él por su nombre simple excepto en un contexto donde la sintaxis solo permite un nombre de su espacio de nombres. Cumplir con las convenciones de nomenclatura elimina en gran medida el oscurecimiento 

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!");
  }
}