¿Por qué la clase interna puede anular el método final privado?

Question

Me preguntaba si tiene sentido declarar un método privado como definitivo, y pensé que no tenía sentido. Pero imaginé que hay una situación exclusiva y escribí el código para resolverlo:

public class Boom { 

    private void touchMe() { 
     System.out.println("super::I am not overridable!"); 
    } 

    private class Inner extends Boom { 

     private void touchMe() { 
      super.touchMe(); 
      System.out.println("sub::You suck! I overrided you!"); 
     } 
    } 

    public static void main(String... args) { 
     Boom boom = new Boom(); 
     Boom.Inner inner = boom.new Inner(); 
     inner.touchMe(); 
    } 
} 

Se compiló y funcionó. "Debería hacer TouchMe() final" pensé y lo hizo:

public class Boom { 

    private final void touchMe() { 
     System.out.println("super::I am not overridable!"); 
    } 

    private class Inner extends Boom { 

     private void touchMe() { 
      super.touchMe(); 
      System.out.println("sub::You suck! I overrided you!"); 
     } 
    } 

    public static void main(String... args) { 
     Boom boom = new Boom(); 
     Boom.Inner inner = boom.new Inner(); 
     inner.touchMe(); 
    } 
} 

y también funciona y me

chicout@chicout-linlap:~$ java Boom 
super::I am not overridable! 
sub::You suck! I overrided you! 

qué dice?

Answer 1

Los métodos privados no se pueden anular (¡los métodos privados no se heredan!) De hecho, no importa si se declara o no un método privado.

Los dos métodos que se declare, con Boom.touchMe y Boom.Inner.touchMe son dos métodos completamente separadas, que acaba de pasar a compartir el mismo identificador. El hecho de que super.touchMe se refiera a un método diferente de touchMe, es simplemente porque Boom.Inner.touchMesombrasBoom.touchMe (y no porque lo anule).

Esto se puede demostrar en un número de maneras:

• Como usted descubrió a sí mismo, si cambia los métodos a ser público, el compilador se quejará porque está repente intentando anular una final método.

• Si mantiene los métodos privados y agrega la anotación @Override, el compilador se quejará.

• Como alpian señala, si lanzas el objeto Boom.Inner a un objeto Boom (((Boom) inner).touchMe()) la Boom.touchMe se llama (si de hecho fue anulada, el elenco no importaría).

pregunta relacionada:

• Make private methods final?

Answer 2

puede invalidar el método porque es private a cada clase.

Answer 3

Los métodos privados son invisibles para las subclases o, de hecho, para cualquier otra clase, por lo que pueden tener el mismo nombre, pero no se superan entre sí.

Intenta agregar la anotación @Override - obtendrás un error de compilación.

Answer 4

creo que el hecho de que en realidad hay dos métodos separados que aquí está muy bien demostrado cambiando principal de la siguiente manera:

public static void main(String... args) { 
    Boom boom = new Boom(); 
    Boom.Inner inner = boom.new Inner(); 
    inner.touchMe(); 
    System.out.println("And now cast it..."); 
    ((Boom)(inner)).touchMe(); 
} 

esto ahora impresiones:

super::I am not overridable! 
sub::You suck! I overrided you! 
And now cast it... 
super::I am not overridable! 

y la razón de que la llamada para super funciona en Inner es porque está buscando un método llamado touchMe en su superclase (Boom) que de hecho existe y es visible para Inner ya que está en la misma c muchacha.

Answer 5

Acaba de declarar otro método con el mismo nombre. Puede llamar a un miembro privado de la clase porque la clase interna es en sí misma miembro de la clase. Espero que esta modificación lo explique en detalles.

public class Boom { 

    private final void touchMe() { 
     System.out.println("super [touchMe] ::I am not overridable!"); 
    } 

    public void overrideMe(){ 
     System.out.println("super [overrideMe]::I am overridable!"); 
    } 

    private class Inner extends Boom { 

     private void touchMe() { 
      super.touchMe(); 
      System.out.println("sub [touchMe]::You suck! I overrided you!"); 
     } 

     public void overrideMe(){ 
      System.out.println("sub [overrideMe] ::I overrided you!"); 
     } 
    } 

    public static void main(String... args) { 
     Boom boom = new Boom(); 
     Boom.Inner inner = boom.new Inner(); 

     inner.touchMe(); 

     Boom newBoom = inner; 
     newBoom.touchMe(); 
     newBoom.overrideMe(); 
    } 
} 



super [touchMe] ::I am not overridable! 
sub [touchMe]::You suck! I overrided you! 
super [touchMe] ::I am not overridable! 
sub [overrideMe] ::I overrided you!