OOP-Design: Interface-Methods with implementation-dependent parameters

Question

The subject says it already:

I am thinking right now about following design-problem: I define an interface for a specific type of object that contains various methods. Now i have the problem, that different implementations of this interface, need additional/different method-parameters (because the way they are implemented makes this necessary), which i cannot incorporate into the interface because they are not common to all interface-implementations.

Now i realize that interface implementations could come with their own property-files, loading their additional parameters from there, but what if these parameters need to be passed in at runtime?

Currently i can only think of passing in a Map<String, Object> parameters to overcome this problem - since JDK-Classes like DocumentBuilderFactory are doing something very similar by providing methods like setAttribute(String attName, Object attValue) this seems like a feasible approach to solve this problem. Nevertheless i would be interested in how others solve issues like this, alternative ideas?

I dont want to derive from the interface and add additional methods, since in my case i would then have to throw NotImplementException from the methods of the base interface.

UPDATE:

What could be eventual problems of the Map-approach? Implementing classes are free to ignore it completely if they cant make use of additional parameters. Others might check if the Map contains the desired parameter-names, check the type of their values and use them if valid, throw an exception if not. I have also seen this being used for the abstract class JAXBContext, so it seems to be a common approach..

UPDATE:

I decided to go for the map-approach, since i dont see any obvious disadvantages and it is being used in the JDK as well (yes, i know this does not necessarily mean much :) Since i cannot accept an answer on this question, i will just upvote. Thanks for your input!

regards,

--qu

Answer 1

You should just initialize each inheritor with its own specific required parameters and let the interface method remain parameter-less, as in:

Interface Runnable:

public interface Runnable {
    public abstract void run();
}

Implementation:

public class MyRunnable {

    private final String myConcreteString;

    public MyRunnable(String myConcreteString) {
        this.myConcreteString = myConcreteString;
    }

    public void run() {
        // do something with myConcreteString
    }
}