Using Abstract Class to Implement Interface

Question

I have an interface. For the sake of this question, I'll simplify it to this:

interface EraseableColoredPencil {

  //This method seems appropriate for an interface;
  //The implementation will change with each class that implements this interface.
  void draw();

  //This method does not seem as appropriate;
  //The implementation of the erase method would be the same for all classes.
  void erase();
}

My question is: According to OOP principles, what is the best way to express this? An interface for both methods does not seem appropriate. Here are the options that I have come up with:

List all methods, whether or not the implementation is the same, on the interface. Then use an abstract class for the shared erase() implementation. This seems like be best solution to me, as an EraseableColoredPencil WILL need to implement erase() and this allows all classes to share the same implementation. I know this is possible, but my concern is whether or not it follows best practices.
Eliminate the interface and use an abstract class. This does NOT seem like it follows good design patterns, but would guarantee that each extending class would have the appropriate methods and even have consistent implementation until a given method is overridden.
Leave As-Is. It's possible I'm overthinking this and this really is an OK way to do it.
Something Else. I'm sure I have missed something. Is there a better way to do this?

If you are coming from a C# perspective, that is the case, yes. I have had this problem in both Java and C#, and Java naming conventions do not call for the I prefix. See oracle.com/technetwork/java/codeconventions-135099.html — Curious Blueprints
– Curious Blueprints, Commented Jul 16, 2015 at 11:57
I tried to simplify this question for the sake of the website, when in reality it is a much more complicated class. The idea behind this is that the draw() method is different based on color, but ultimately the erase() method just removes the color from the page in this example. — Curious Blueprints
– Curious Blueprints, Commented Jul 16, 2015 at 12:00
Sorry about that, have had the problem in multiple languages, but I removed the tag for now. — Curious Blueprints
– Curious Blueprints, Commented Jul 16, 2015 at 12:06

Community · Accepted Answer · 2017-05-23 11:43:51Z

2

Something else: Follow the Interface Segregation Principle and split the interface:
```
interface Drawer{
  void draw();
}

interface Erasable {
  void erase();
}

interface EraseableDrawer extends Drawer, Erasable {
}
```
Now you only need to depend on either Drawer or Erasable, depending on what method you really need (or on ErasableDrawer if you need both).

If erase() is really the same implementation for all or most classes, you still can use an abstract class AbstractErasableDrawer that implements ErasableDrawer with a concrete implementation of erase() (or use a default implementation as suggested above)

edited May 23, 2017 at 11:43

CommunityBot

11 silver badge

answered Jul 16, 2015 at 12:25

Fabian Schmengler

24.6k9 gold badges82 silver badges114 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

David Arno · Accepted Answer · 2015-07-16 12:09:44Z

1

As you are now just asking with regards to Java, there is a third option for you, available with Java 8: default methods on interfaces.

This allows you to use an interface and define the default behaviour for erase, removing the need for the abstract class:

interface EraseableColoredPencil {

    void draw();

    default void erase() { ... }
}

answered Jul 16, 2015 at 12:09

David Arno

43.4k16 gold badges89 silver badges132 bronze badges

Collectives™ on Stack Overflow

Using Abstract Class to Implement Interface

2 Answers 2

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related