¿Podemos sobrecargar o anular métodos estáticos en Java?

Primero definamos sobrecarga y anulación.
Anulación : la anulación es una característica de los lenguajes OOP como Java que está relacionada con el polimorfismo en tiempo de ejecución. Una subclase (o clase derivada) proporciona una implementación específica de un método en la superclase (o clase base). 
La implementación a ejecutar se decide en tiempo de ejecución y se toma una decisión de acuerdo con el objeto utilizado para la llamada. Tenga en cuenta que las firmas de ambos métodos deben ser las mismas. Consulte Anulación en Java para obtener más información.
Sobrecarga: La sobrecarga también es una característica de los lenguajes OOP como Java que está relacionada con el polimorfismo en tiempo de compilación (o estático). Esta característica permite que diferentes métodos tengan el mismo nombre, pero diferentes firmas, especialmente la cantidad de parámetros de entrada y el tipo de parámetros de entrada. Tenga en cuenta que tanto en C++ como en Java, los métodos no se pueden sobrecargar según el tipo de valor devuelto.
¿Podemos sobrecargar los métodos estáticos?  
La respuesta es sí’. Podemos tener dos o más métodos estáticos con el mismo nombre, pero diferencias en los parámetros de entrada. Por ejemplo, considere el siguiente programa Java. 
 

// filename Test.java
public class Test {
    public static void foo() {
        System.out.println("Test.foo() called ");
    }
    public static void foo(int a) {
        System.out.println("Test.foo(int) called ");
    }
    public static void main(String args[])
    {
        Test.foo();
        Test.foo(10);
    }
}

Test.foo() called 
Test.foo(int) called 

¿Podemos sobrecargar métodos que difieren solo por palabra clave estática?  
No podemos sobrecargar dos métodos en Java si difieren solo por una palabra clave estática (la cantidad de parámetros y los tipos de parámetros son los mismos). Consulte el siguiente programa Java, por ejemplo. Este comportamiento es el mismo en C++ (Ver punto 2 de este ). 
 

// filename Test.java
public class Test {
    public static void foo() {
        System.out.println("Test.foo() called ");
    }
    public void foo() { // Compiler Error: cannot redefine foo()
        System.out.println("Test.foo(int) called ");
    }
    public static void main(String args[]) {
        Test.foo();
    }
}

Producción:

Compiler Error, cannot redefine foo()

¿Podemos anular los métodos estáticos en Java?  
Podemos declarar métodos estáticos con la misma firma en la subclase, pero no se considera anulado ya que no habrá ningún polimorfismo en tiempo de ejecución. Por lo tanto, la respuesta es ‘No’. 
Si una clase derivada define un método estático con la misma firma que un método estático en la clase base, el método en la clase derivada está oculto por el método en la clase base. 
 

/* Java program to show that if static method is redefined by
   a derived class, then it is not overriding. */
 
// Superclass
class Base {
     
    // Static method in base class which will be hidden in subclass
    public static void display() {
        System.out.println("Static or class method from Base");
    }
     
     // Non-static method which will be overridden in derived class
     public void print()  {
         System.out.println("Non-static or Instance method from Base");
    }
}
 
// Subclass
class Derived extends Base {
     
    // This method is hidden by display() in Base
    public static void display() {
         System.out.println("Static or class method from Derived");
    }
     
    // This method overrides print() in Base
    public void print() {
         System.out.println("Non-static or Instance method from Derived");
   }
}
 
// Driver class
public class Test {
    public static void main(String args[ ])  {
       Base obj1 = new Derived();
        
       // As per overriding rules this should call to class Derive's static
       // overridden method. Since static method can not be overridden, it
       // calls Base's display()
       obj1.display(); 
        
       // Here overriding works and Derive's print() is called
       obj1.print();    
    }
}

Static or class method from Base
Non-static or Instance method from Derived

Los siguientes son algunos puntos importantes para la anulación de métodos y métodos estáticos en Java. 
1) Para los métodos de clase (o estáticos), se llama al método según el tipo de referencia, no según el objeto al que se hace referencia, lo que significa que la llamada al método se decide en tiempo de compilación.
2) Para los métodos de ejemplo (o no estáticos), el método se llama según el tipo de objeto al que se hace referencia, no según el tipo de referencia, lo que significa que las llamadas al método se deciden en tiempo de ejecución.
3) Un método de instancia no puede anular un método estático y un método estático no puede ocultar un método de instancia. Por ejemplo, el siguiente programa tiene dos errores de compilación. 
 

/* Java program to show that if static methods are redefined by
   a derived class, then it is not overriding but hidding. */
 
// Superclass
class Base {
     
    // Static method in base class which will be hidden in subclass
    public static void display() {
        System.out.println("Static or class method from Base");
    }
     
     // Non-static method which will be overridden in derived class
     public void print()  {
         System.out.println("Non-static or Instance method from Base");
    }
}
 
// Subclass
class Derived extends Base {
     
    // Static is removed here (Causes Compiler Error)
    public void display() {
        System.out.println("Non-static method from Derived");
    }
     
    // Static is added here (Causes Compiler Error)
    public static void print() {
        System.out.println("Static method from Derived");
   }
}

4) En una subclase (o Clase Derivada), podemos sobrecargar los métodos heredados de la superclase. Estos métodos sobrecargados no ocultan ni anulan los métodos de la superclase: son métodos nuevos, exclusivos de la subclase.

Referencias:  
http://docs.oracle.com/javase/tutorial/java/IandI/override.html Chandra Prakash
contribuye con este artículo . Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.