¿Puedo anular y sobrecargar métodos estáticos en Java?

Me gustaría saber:

  1. ¿Por qué los métodos estáticos no pueden anularse en Java?
  2. ¿Pueden los métodos estáticos estar sobrecargados en Java?

Los métodos estáticos no pueden anularse en el sentido exacto de la palabra, pero pueden ocultar los métodos estáticos primarios

En la práctica, esto significa que el comstackdor que decidirá qué método ejecutar en tiempo de comstackción, y no en tiempo de ejecución, como lo hace con los métodos de instancia anulados.

Para un buen ejemplo, eche un vistazo aquí .

Y esta es la documentación de Java que explica la diferencia entre reemplazar los métodos de instancia y ocultar los métodos de clase (estáticos).

Sobreescritura: Anulación en Java simplemente significa que el método particular se invocará en función del tipo de tiempo de ejecución del objeto y no del tipo de tiempo de comstackción del mismo (que es el caso con los métodos estáticos sustituidos)

Ocultación: los métodos de clase primaria que son estáticos no son parte de una clase secundaria (aunque son accesibles), por lo que no hay posibilidad de anularla. Incluso si agrega otro método estático en una subclase, idéntico al de su clase principal, este método estático de subclase es único y distinto del método estático en su clase principal.

Los métodos estáticos no pueden anularse porque no hay nada que anular, ya que serían dos métodos diferentes. Por ejemplo

static class Class1 { public static int Method1(){ return 0; } } static class Class2 extends Class1 { public static int Method1(){ return 1; } } public static class Main { public static void main(String[] args){ //Must explicitly chose Method1 from Class1 or Class2 Class1.Method1(); Class2.Method1(); } } 

Y sí, los métodos estáticos pueden sobrecargarse como cualquier otro método.

¿Podemos sobrecargar los métodos estáticos?

La respuesta es . 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 progtwig 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() called printed Test.foo(10); //Test.foo(int) called printed } } 

¿Podemos sobrecargar los métodos que difieren solo por palabra clave estática?

No podemos sobrecargar dos métodos en Java si difieren solo por palabra clave estática (el número de parámetros y tipos de parámetros es el mismo). Ver el siguiente progtwig Java, por ejemplo. Este comportamiento es el mismo en C ++.

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

¿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 anulación ya que no habrá ningún polymorphism 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 oculta el método en la clase base. si el método estático es redefinido por una clase derivada, entonces no está anulando.

 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"); } } class Derived extends Base { // This method hides 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"); } } 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(); //output -> Static or class method from Base // Here overriding works and Derive's print() is called obj1.print(); //output-> Non-static or Instance method from Derived } } 

Los métodos estáticos no pueden anularse porque no se envían en la instancia del objeto en tiempo de ejecución. El comstackdor decide qué método se llama.

Es por eso que obtienes una advertencia de comstackción cuando escribes

  MyClass myObject = new MyClass(); myObject.myStaticMethod(); // should be written as MyClass.myStaticMethod() // because it is not dispatched on myObject myObject = new MySubClass(); myObject.myStaticMethod(); // still calls the static method in MyClass, NOT in MySubClass 

Los métodos estáticos pueden sobrecargarse (lo que significa que puede tener el mismo nombre de método para varios métodos, siempre que tengan diferentes tipos de parámetros).

  Integer.parseInt("10"); Integer.parseInt("AA", 16); 

Los métodos de clase primaria que son estáticos no son parte de una clase secundaria (aunque son accesibles), por lo que no hay posibilidad de anularla. Incluso si agrega otro método estático en una subclase, idéntico al de su clase principal, este método estático de subclase es único y distinto del método estático en su clase principal.

Los métodos estáticos no pueden anularse porque no son parte del estado del objeto. Por el contrario, pertenecen a la clase (es decir, son métodos de clase). Está bien sobrecargar los métodos estáticos (y finales).

Si estoy llamando al método usando el nombre de la Subclase MysubClass, entonces el método de la subclase muestra lo que significa que el método estático puede ser anulado o no

 class MyClass { static void myStaticMethod() { System.out.println("Im in sta1"); } } class MySubClass extends MyClass { static void myStaticMethod() { System.out.println("Im in sta123"); } } public class My { public static void main(String arg[]) { MyClass myObject = new MyClass(); myObject.myStaticMethod(); // should be written as MyClass.myStaticMethod(); // calling from subclass name MySubClass.myStaticMethod(); myObject = new MySubClass(); myObject.myStaticMethod(); // still calls the static method in MyClass, NOT in MySubClass } } 

No, los métodos estáticos no pueden anularse ya que es parte de una clase en lugar de un objeto. Pero uno puede sobrecargar el método estático.

Los métodos estáticos es un método cuya copia única es compartida por todos los objetos de la clase. El método estático pertenece a la clase en lugar de a los objetos. Como los métodos estáticos no dependen de los objetos, el comstackdor Java no necesita esperar hasta la creación de los objetos. Para llamar al método estático, usamos la syntax como ClassName.method ();

En caso de sobrecarga de métodos, los métodos deben estar en la misma clase para sobrecargarlos. Aunque se declaren como estáticos, es posible sobrecargarlos como,

  Class Sample { static int calculate(int a,int b,int c) { int res = a+b+c; return res; } static int calculate(int a,int b) { int res = a*b; return res; } } class Test { public static void main(String []args) { int res = Sample.calculate(10,20,30); } } 

Pero en el caso de anulación de método, el método en la superclase y el método en la clase secundaria actúan como método diferente. la superclase tendrá su propia copia y la subclase tendrá su propia copia, por lo que no quedará anulada por el método.

 class SuperType { public static void classMethod(){ System.out.println("Super type class method"); } public void instancemethod(){ System.out.println("Super Type instance method"); } } public class SubType extends SuperType{ public static void classMethod(){ System.out.println("Sub type class method"); } public void instancemethod(){ System.out.println("Sub Type instance method"); } public static void main(String args[]){ SubType s=new SubType(); SuperType su=s; SuperType.classMethod();// Prints.....Super type class method su.classMethod(); //Prints.....Super type class method SubType.classMethod(); //Prints.....Sub type class method } } 

Este ejemplo para la eliminación de métodos estáticos

Nota: si llamamos a un método estático con referencia de objeto, entonces se llamará al método estático de referencia (clase), no al método estático de clase de objeto.

El método estático pertenece solo a la clase.

¿ Por qué Java no permite reemplazar los métodos estáticos?

Anulación depende de tener una instancia de una clase. El punto del polymorphism es que puede subclasificar una clase y los objetos que implementan esas subclases tendrán diferentes comportamientos para los mismos métodos definidos en la superclase (y anulados en las subclases). Un método estático no está asociado con ninguna instancia de una clase, por lo que el concepto no es aplicable.

Hubo dos consideraciones que impulsaron el diseño de Java que impactaron esto. Uno era una preocupación con el rendimiento: se habían criticado a Smalltalk por ser demasiado lento (la recolección de basura y las llamadas polimórficas formaban parte de eso) y los creadores de Java estaban decididos a evitar eso. Otra fue la decisión de que el público objective para Java eran los desarrolladores de C ++. Hacer que los métodos estáticos funcionen de la manera que tienen el beneficio de la familiaridad para los progtwigdores de C ++ y también fueron muy rápidos porque no hay necesidad de esperar hasta el tiempo de ejecución para descubrir qué método utilizar.

static métodos static son métodos de nivel de class .

El concepto de ocultación se usa para métodos static .

Ver: http://www.coderanch.com/how-to/java/OverridingVsHiding

El único propósito de usar el método estático es acceder al método de una clase sin crear una instancia para ella. No tendrá sentido si reemplazamos ese método, ya que se accederá mediante classname.method ()

No, no puedes anular un método estático. La estática se resuelve en contra de la clase, no de la instancia.

 public class Parent { public static String getCName() { return "I am the parent"; } } public class Child extends Parent { public static String getCName() { return "I am the child"; } } 

Cada clase tiene un método estático getCName (). Cuando llama al nombre de la Clase, se comporta como cabría esperar y cada uno devuelve el valor esperado.

 @Test public void testGetCNameOnClass() { assertThat(Parent.getCName(), is("I am the parent")); assertThat(Child.getCName(), is("I am the child")); } 

Sin sorpresas en esta prueba unitaria. Pero esto no es primordial. Esto declara algo que tiene un nombre de colisión.

Si tratamos de llegar a la estática de una instancia de la clase (no es una buena práctica), entonces realmente muestra:

 private Parent cp = new Child(); `enter code here` assertThat(cp.getCName(), is("I am the parent")); 

Aunque cp es un elemento secundario, la estática se resuelve mediante el tipo declarado, principal, en lugar del tipo real del objeto. Para los no-estáticos, esto se resuelve correctamente porque un método no estático puede anular un método de su padre.

Puede sobrecargar un método estático pero no puede anular un método estático. En realidad, puede reescribir un método estático en subclases, pero esto no se llama anulación porque la anulación debe estar relacionada con el polymorphism y el enlace dynamic. El método estático pertenece a la clase, por lo que no tiene nada que ver con esos conceptos. La reescritura del método estático es más como un sombreado.

Diseño un código de anulación de método estático. Creo que es anulado fácilmente. Por favor aclare cómo es que no puede anular los miembros estáticos. Aquí está mi código:

 class Class1 { public static int Method1(){ System.out.println("true"); return 0; } } class Class2 extends Class1 { public static int Method1(){ System.out.println("false"); return 1; } } public class Mai { public static void main(String[] args){ Class2 c=new Class2(); //Must explicitly chose Method1 from Class1 or Class2 //Class1.Method1(); c.Method1(); } } 

En realidad, es bastante simple de entender: todo lo que está marcado como estático pertenece solo a la clase, por ejemplo, el método estático no se puede heredar en la subclase porque pertenecen a la clase en la que se han declarado. Referir palabra clave estática

La mejor respuesta que encontré de esta pregunta es:

http://www.geeksforgeeks.org/can-we-overload-or-override-static-methods-in-java/

¿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 progtwig 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); } } 

Salida:

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

¿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 anulación ya que no habrá ningún polymorphism 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 oculta 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 hides 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(); } } 

Salida:

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

Como cualquier método estático es parte de la clase, no instancia, por lo que no es posible anular el método estático

La sobrecarga también se denomina enlace estático, por lo que tan pronto como se utiliza la palabra estática significa que un método estático no puede mostrar el polymorphism en tiempo de ejecución .

No podemos anular un método estático sino la presencia de diferentes implementaciones del mismo método estático en una superclase y su subclase es válida. Es solo que la clase derivada ocultará las implementaciones de la clase base.

Para los métodos estáticos, la llamada al método depende del tipo de referencia y no a qué objeto se refiere, es decir, el método estático pertenece solo a una clase y no a sus instancias, por lo que la llamada al método se decide en el momento de la comstackción.

Mientras que en caso de sobrecarga de métodos, los métodos estáticos pueden sobrecargarse si tienen un número de diferencias o tipos de parámetros. Si dos métodos tienen el mismo nombre y la misma lista de parámetros, entonces no se pueden definir de otra manera solo mediante la palabra clave “estática”.