Cómo determinar rápidamente si un método se reemplaza en Java

Question

Existe una posible optimización que podría aplicar a uno de mis métodos, si puedo determinar que otro método en la misma clase no se reemplaza. Es solo una ligera optimización, por lo que la reflexión está fuera de cuestión. ¿Debo simplemente hacer un método protegido que devuelva si el método en cuestión está anulado, de modo que una subclase puede hacer que devuelva verdadero?

Answer 1

No haria esto. Viola la encapsulación y cambia el contrato de lo que su clase debe hacer sin que los implementadores lo sepan.

Si debe hacerlo, sin embargo, la mejor manera es invocar

class.getMethod("myMethod").getDeclaringClass(); 

Si la clase que se devuelve es su propia, entonces no es anulado; si es otra cosa, esa subclase lo ha anulado. Sí, esto es reflejo, pero sigue siendo bastante barato.

Aunque me gusta su enfoque de método protegido. Eso sería algo como esto:

public class ExpensiveStrategy { 
    public void expensiveMethod() { 
    // ... 
    if (employOptimization()) { 
     // take a shortcut 
    } 
    } 

    protected boolean employOptimization() { 
    return false; 
    } 
} 

public class TargetedStrategy extends ExpensiveStrategy { 
    @Override 
    protected boolean employOptimization() { 
    return true; // Now we can shortcut ExpensiveStrategy. 
    } 
} 

Answer 2

¿Cuántas veces espera que se llame a la función durante la vida útil del programa? La reflexión sobre un único método específico no debería ser tan malo. Si no vale tanto tiempo durante la vida útil del programa, mi recomendación es mantenerlo simple y no incluir la pequeña optimización.

Jacob

Answer 3

La reflexión se puede utilizar para determinar si un método se reemplaza. El código es un poco complicado. Por ejemplo, debe tener en cuenta que tiene una clase de tiempo de ejecución que es una subclase de la clase que anula el método.

Vas a ver las mismas clases de tiempo de ejecución una y otra vez. Para que pueda guardar los resultados del cheque en un WeakHashMap ingresado en el Class.

Vea mi código en java.awt.Component que trata con coalesceEvents para un ejemplo.

Answer 4

Anotar subclases que anulan el método particular. @OverridesMethodX.

Realice el trabajo reflector necesario en la carga de clase (es decir, en un bloque static) para que publique la información a través de un indicador booleano final. Luego, consulta la bandera donde y cuando la necesites.

Answer 5

Bueno, mi optimización es un rendimiento pequeño caso por caso, y solo acelera mucho las cosas porque se llama cientos de veces por segundo.

Es posible que desee ver lo que el optimizador de Java puede hacer. Su optimización codificada a mano puede no ser necesaria.

Si decide que la optimización codificada a mano es necesaria, el método de método protegido que describió no es una buena idea porque expone los detalles de su implementación.

Answer 6

quizás haya una manera más clara de hacerlo a través del Strategy Pattern, aunque no sé cómo se modelan el resto de la aplicación y los datos, pero parece que podría encajar.

Me hizo de todos modos cuando me enfrentaba con un problema similar.Podría tener una heurística que decida qué estrategia utilizar dependiendo de los datos que se procesarán.

De nuevo, no tengo suficiente información sobre su uso específico para ver si esto es excesivo o no. Sin embargo, me abstendría de cambiar la firma de clase para dicha optimización específica. Por lo general, cuando siento la necesidad de ir en contra de la corriente, interpreto que no había imaginado un caso de esquina cuando diseñé el producto y que debería refactorizarlo para obtener una solución más completa y más limpia.

Sin embargo, tenga en cuenta que tal refactorización cuando se realiza únicamente en terrenos de optimización casi inevitablemente conduce a un desastre. Si este es el caso, tomaría el enfoque reflexivo sugerido anteriormente. No altera el contrato de herencia, y cuando se hace correctamente debe hacerse una sola vez por subclase que lo requiere para la vida útil de la aplicación.

Answer 7

Sé que esto es una pregunta un poco viejo, pero por el bien de otros empleados de Google:

me ocurrió una solución diferente utilizando interfaces.

class FastSub extends Super {} 
class SlowSub extends Super implements Super.LetMeHandleThis { 
    void doSomethingSlow() { 
     //not optimized 
    } 
} 
class Super { 
    static interface LetMeHandleThis { 
     void doSomethingSlow(); 
    } 
    void doSomething() { 
     if (this instanceof LetMeHandleThis) 
      ((LetMeHandleThis) this).doSomethingSlow(); 
     else 
      doSomethingFast(); 
    } 
    private final void doSomethingFast() { 
     //optimized 
    } 
} 

o al revés:

class FastSub extends Super implements Super.OptimizeMe {} 
class SlowSub extends Super { 
    void doSomethingSlow() { 
     //not optimized 
    } 
} 
class Super { 
    static interface OptimizeMe {} 
    void doSomething() { 
     if (this instanceof OptimizeMe) 
      doSomethingFast(); 
     else 
      doSomethingSlow(); 
    } 
    private final void doSomethingFast() { 
     //optimized 
    } 
    void doSomethingSlow(){} 
} 

Answer 8

private static boolean isMethodImplemented(Object obj, String name) 
{ 
    try 
    { 
     Class<? extends Object> clazz = obj.getClass(); 

     return clazz.getMethod(name).getDeclaringClass().equals(clazz); 
    } 
    catch (SecurityException e) 
    { 
     log.error("{}", e); 
    } 
    catch (NoSuchMethodException e) 
    { 
     log.error("{}", e); 
    } 

    return false; 
}