如何在不使用抽象的情况下强制实现子类中的方法? [英] How to force implementation of a method in subclass without using abstract?
问题描述
我想强制子类实现我的父类的已实现方法. 我看这 Java-强制实施已实现方法,但我可以不会将我的母班转换成抽象班.
I want to force subclass to implement an implemented method of my mother class. I look this Java - Force implementation of an implemented method but i can't convert my mother class to an abstract class.
public class myMotherClass {
myMethod {
...some code ..
}
}
public class myClass extends myMotherClass {
myMethod {
... other code ...
}
}
因此,在这个示例中,我想强制myClass实现myMethod.
So, in this exemple, I want to force myClass implement myMethod.
对不起,我的英语...
Sorry for my english...
推荐答案
您不能强制子类重写方法.您只能通过使其抽象来强制其实现方法.
You can not force a subclass to override a method. You can only force it to implement a method by making it abstract.
因此,如果不能使myMotherClass抽象,则只能引入另一个扩展myMotherClass并将其委托给必须实现的方法的超类:
So if you can not make myMotherClass abstract you can only introduce another superclass that extends myMotherClass and delegates to the method that must be implemented:
public abstract class EnforceImplementation extends myMotherClass {
public final void myMethod(){
implementMyMethod();
}
public abstract void implementMyMethod();
}
编辑
我在 hemcrest
api中找到了解决该问题的另一种方法.由模仿者使用.
I found another interessting way of solving the problem in the hemcrest
api that is e.g. used by mockito.
public interface Matcher<T> extends SelfDescribing {
/**
* Evaluates the matcher for argument <var>item</var>.
* <p/>
* This method matches against Object, instead of the generic type T. This is
* because the caller of the Matcher does not know at runtime what the type is
* (because of type erasure with Java generics). It is down to the implementations
* to check the correct type.
*
* @param item the object against which the matcher is evaluated.
* @return <code>true</code> if <var>item</var> matches, otherwise <code>false</code>.
*
* @see BaseMatcher
*/
boolean matches(Object item);
/**
* This method simply acts a friendly reminder not to implement Matcher directly and
* instead extend BaseMatcher. It's easy to ignore JavaDoc, but a bit harder to ignore
* compile errors .
*
* @see Matcher for reasons why.
* @see BaseMatcher
*/
void _dont_implement_Matcher___instead_extend_BaseMatcher_();
}
接口指定方法_dont_implement_Matcher___instead_extend_BaseMatcher_
.当然,它不会阻止其他人实现Matcher
接口,但是它会引导开发人员朝着正确的方向前进.
The interface specifies a method _dont_implement_Matcher___instead_extend_BaseMatcher_
. Of course it does not prevent others from implementing the Matcher
interface, but it guides the developer in the right direction.
和 BaseMatcher
类将_dont_implement_Matcher___instead_extend_BaseMatcher_
方法实现为final
And the BaseMatcher
class implements the _dont_implement_Matcher___instead_extend_BaseMatcher_
method as final
public final void _dont_implement_Matcher___instead_extend_BaseMatcher_() {
// See Matcher interface for an explanation of this method.
}
最后我认为这是一个设计问题,因为BaseMatcher
强制实现了每个 Matcher
一个抽象类,并使用模板方法.
Finally I think that this is a design problem, because the BaseMatcher
obviouosly implements logic that every Matcher
should implement. Thus it would have been better to make the Matcher
an abstract class and use a template method.
但是我想他们这样做是因为这是字节码兼容性和新功能之间的最佳折衷.
But I guess they did it because it was the best compromise between bytecode compatibility and new features.
这篇关于如何在不使用抽象的情况下强制实现子类中的方法?的文章就介绍到这了,希望我们推荐的答案对大家有所帮助,也希望大家多多支持IT屋!