public final class VirtualMethod<C> extends Object
Before the replacement method can be made abstract, the old method must kept deprecated. If somebody still overrides the deprecated method in a non-final class, you must keep track, of this and maybe delegate to the old method in the subclass. The cost of reflection is minimized by the following usage of this class:
Define static final fields in the base class (BaseClass
),
where the old and new method are declared:
static final VirtualMethod<BaseClass> newMethod = new VirtualMethod<BaseClass>(BaseClass.class, "newName", parameters...); static final VirtualMethod<BaseClass> oldMethod = new VirtualMethod<BaseClass>(BaseClass.class, "oldName", parameters...);
This enforces the singleton status of these objects, as the maintenance of the cache would be too costly else.
If you try to create a second instance of for the same method/baseClass
combination, an exception is thrown.
To detect if e.g. the old method was overridden by a more far subclass on the inheritance path to the current instance's class, use a non-static field:
final boolean isDeprecatedMethodOverridden = oldMethod.getImplementationDistance(this.getClass()) > newMethod.getImplementationDistance(this.getClass()); // alternatively (more readable): final boolean isDeprecatedMethodOverridden = VirtualMethod.compareImplementationDistance(this.getClass(), oldMethod, newMethod) > 0
getImplementationDistance(java.lang.Class<? extends C>)
returns the distance of the subclass that overrides this method.
The one with the larger distance should be used preferable.
This way also more complicated method rename scenarios can be handled
(think of 2.9 TokenStream
deprecations).
Constructor and Description |
---|
VirtualMethod(Class<C> baseClass,
String method,
Class<?>... parameters)
Creates a new instance for the given
baseClass and method declaration. |
Modifier and Type | Method and Description |
---|---|
static <C> int |
compareImplementationDistance(Class<? extends C> clazz,
VirtualMethod<C> m1,
VirtualMethod<C> m2)
Utility method that compares the implementation/override distance of two methods.
|
int |
getImplementationDistance(Class<? extends C> subclazz)
Returns the distance from the
baseClass in which this method is overridden/implemented
in the inheritance path between baseClass and the given subclass subclazz . |
boolean |
isOverriddenAsOf(Class<? extends C> subclazz)
Returns, if this method is overridden/implemented in the inheritance path between
baseClass and the given subclass subclazz . |
public VirtualMethod(Class<C> baseClass, String method, Class<?>... parameters)
baseClass
and method declaration.UnsupportedOperationException
- if you create a second instance of the same
baseClass
and method declaration combination. This enforces the singleton status.IllegalArgumentException
- if baseClass
does not declare the given method.public int getImplementationDistance(Class<? extends C> subclazz)
baseClass
in which this method is overridden/implemented
in the inheritance path between baseClass
and the given subclass subclazz
.public boolean isOverriddenAsOf(Class<? extends C> subclazz)
baseClass
and the given subclass subclazz
.
You can use this method to detect if a method that should normally be final was overridden by the given instance's class.
false
iff not overriddenpublic static <C> int compareImplementationDistance(Class<? extends C> clazz, VirtualMethod<C> m1, VirtualMethod<C> m2)
m1
is overridden/implemented in a subclass of the class overriding/declaring m2
m2
is overridden in a subclass of the class overriding/declaring m1
Copyright © 2000-2014 Apache Software Foundation. All Rights Reserved.