¿Cómo sobrescribir/extender una clase interna desde una subclase?

Question

Quiero cambiar la forma en que se ejecuta un método de una clase sin anular el método, y solo se anula (o se extiende idealmente) la clase interna. Supongamos que no puedo cambiar el hecho de que tengo que hacer esto (estoy modificando una base de código fuente abierto existente y habría fricción al sacar clases o lo que sea).

public class A { 
    static class Thing { 
    public int value() { return 10+value2(); } 
    public int value2() { return 10; } 
    } 

    public String toString() { 
    Thing t = new Thing(); 
    return Integer.toString(t.value()); 
    } 
} 

public class B extends A { 
    static class Thing { 
    public int value2() { return 20; } 
    } 
} 

Mi objetivo es, cambiando lo único, consiguiendo toString de B() para volver "30", en donde actualmente se volverá "20". Lo ideal sería cambiar solo el método value2 (dejando así cualquier otro método sin modificar), pero no sé si esto es posible.

Gracias

Answer 1

Creo que necesita un método de fábrica para esto. Considere el ejemplo siguiente (derivado de su fragmento de):

static class A { 
    static class Thing { 
     public int value() { 
      return 10 + value2(); 
     } 
     public int value2() { 
      return 10; 
     } 
    } 
    protected Thing createThing() { 
     return new Thing(); 
    } 
    public String toString() { 
     return Integer.toString(createThing().value()); 
    } 
} 

static class B extends A { 
    static class Thing extends A.Thing { 
     public int value2() { 
      return 20; 
     } 
    } 
    @Override 
    protected Thing createThing() { 
     return new Thing(); // creates B.Thing 
    } 
} 

public static void main(String[] args) { 
    System.out.println(new B()); 
} 

Salida:

30 

Answer 2

No es posible solo cambiando el valor2. El problema es que las llamadas 'nuevas' no se distribuyen dinámicamente: la 'nueva' en toString siempre creará A :: Thing. Se podría solucionar este problema creando una fábrica: algo como esto:

public class A { 
    static class Thing { 
    public int value() { return 10+value2(); } 
    public int value2() { return 10; } 
    } 

    private Thing makeThing() { return new Thing(); } 


    public String toString() { 
    Thing t = new Thing(); 
    return Integer.toString(t.value()); 
    } 
} 

public class B extends A { 
    static class Thing extends A.Thing { 
    public int value2() { return 20; } 
    } 

    private Thing makeThing() { return new Thing(); } 

} 

Answer 3

Usted debe ser capaz de extender simplemente la clase interna con la cosa se extiende A.Thing. Mientras sea visible en su alcance, no debería ser un problema.