Logo Questions Linux Laravel Mysql Ubuntu Git Menu
 

How to force implementation of a method in subclass without using abstract?

Tags:

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 ...    }  } 

So, in this exemple, I want to force myClass implement myMethod.

Sorry for my english...

like image 905
Maniz Avatar asked Aug 20 '13 09:08

Maniz


People also ask

Do subclasses have to implement abstract methods?

The subclass of abstract class in java must implement all the abstract methods unless the subclass is also an abstract class. All the methods in an interface are implicitly abstract unless the interface methods are static or default.

How do you override an abstract method in a subclass?

To implement features of an abstract class, we inherit subclasses from it and create objects of the subclass. A subclass must override all abstract methods of an abstract class. However, if the subclass is declared abstract, it's not mandatory to override abstract methods.

Which method will force a subclass to implement it?

4 Answers. Show activity on this post. You can not force a subclass to override a method. You can only force it to implement a method by making it abstract.

Can I override non abstract method?

"Is it a good practice in Java to override a non-abstract method?" Yes.


2 Answers

You can not force a subclass to override a method. You can only force it to implement a method by making it abstract.

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(); } 

EDIT

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_(); } 

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.

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. } 

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.

like image 173
René Link Avatar answered Sep 17 '22 15:09

René Link


You could rework your hierarchy so that your concrete classes are only leafs of the tree.

Instead of

myClass extends myMotherClass 

Consider

myClass extends myMotherAbstractClass myMotherClass extends myMotherAbstractClass  

This way the Abstract class is inherited by both instantiated classes. It is likely in this case the myMotherClass would be extremely thin, just the implementation of myMethod.

like image 32
Karthik T Avatar answered Sep 20 '22 15:09

Karthik T