Interfaces, what if not all implementations use all methods?

Question

I'm fairly new to programming against interfaces and am trying to get it right as a major tool for developing test driven.

Currently we have a lot of Manager classes that all implement a CRUD interface. However some Managers don't yet do updates and some don't do delete, some may never do so.

---

Not implemented exception?

Is it okay, to just

throw new NotImplementedException()

until the method gets implemented or even for all time if it never does?

(obviously with a source code comment telling the programmer "this method is not supposed to be used, as e.g. Types like 'male' 'female' do never get deleted)?

---

Split?

Or should I split my CRUD interface into Creatable, Readable(Searchable), Updatable and Deletable? Wouldn't that clutter my class definition?

PersonManager implements Creatable<Person>, Updateable<Person>, Deletable<Person>, Searchable<Person>

---

Split and combine?

Or should I combine some interfaces like all 4 into CRUD and maybe some other combinations like Read + Update?

Maybe that would also create a load of interfaces where one has to click through a big inheritence path to find out which interface implements all the desired atomic interfaces for the current situation (I need read and create, so which one just implements the two? and this can get a lot more complex quickly)

Answer 1

IMO, for the middle stage - it is OK to use NotImplementedException, until you finish implementing it.

However, as a permanentsolution - I believe it is a bad practice [in most cases].

Instead, I'd create an interface that contains behavior common to all implementing classes, and use subinterfaces to cluster them up for more specific behavior.

The idea is similar to java standard SortedSet, which extends a Set - we wouldn't want to regard Set as SortedSets and give a variable of this type a value of HashSet, instead we use a sub-interface, SortedSet for this purpose.

Answer 2

Generally you would like to throw UnsupportedOperationException which is a runtime exception, clearly mentioning that the requested operation is not supported.

Having loads of interfaces will lead to too many files and also if someone tries to look at them they will get confused. Java docs don't help much either in such cases.

Splitting interface makes sense if there are too many operations for one interface, and not all operations are logically binded together.

For database operation rarely its the case as you will have some basic operation which will be true for most of the scenario.

Answer 3

NotImplementedException doesn't mean that class doesn't support this action. It means it's not implemented, but it will be in the future.

From logical point of view all interface methods must be implemented, and must work well. But if you leave it, and write an application just for yourself, then you will remember about this limitation. In other hand I would be angry that some developer implemented interface and left it unimplemented. So I don't think you can leave interface method not implemented just for future development.

My suggestion is rather to modify interfaces, then use exceptions inside implemented methods.