I'll work on a simplified example.

Briefly, if we have interfaces InterfaceA1, InterfaceB1, InterfaceA2 and
InterfaceB2.

We must have four classes as follows:

Class1 implements InterfaceA1, InterfaceB1

Class2 implements InterfaceA1, InterfaceB2

Class3 implements InterfaceA2, InterfaceB1

Class4 implements InterfaceA2, InterfaceB2

Each class produces quite different results (drug dose optimisation).

 Is there a

There are several methods in the base class that are common to all
subclasses. A lot are implemented in the base class and there are some
abstract ones that the base class depends on implementation in subclass.

This probably doesn't clarify too much so I will work on an example and
post back in a new thread in the near future.

Thanks for you help :).

Lionel.

Quick summary of the below. There is too much to explain, I've only
really touch the simplest part. I won't be offended if you look at it
and choose not to respond because it is difficult to provide everything
necessary.

They are very similar. Which is why I'm asking the question :).

I'm with you on that.

But here I think it falls down. A1 is more like the opposite of A2 so
this design would mean that SuperClass would need some concept of who
and what A and B are and what they do. I need to think about this more
because you may have raised a possibility that I need to consider.

Perhaps I can dispose of the interfaces. Let's take SubClass1 and
SubClass2 that both implement InterfaceA1. The main time that this is
useful is when I'm saving the data from the subclasses or when I'm
creating new instances of the subclass from data from the database:

public static void saveClass(SuperClass superClass) {
    //save the common data
    ...

    //look at what else needs saving
    if(superClass instanceof InterfaceA1) {
        saveInterfaceA1((InterfaceA1)superClass);
    }
    if(superClass instanceof InterfaceA2) {
        saveInterfaceA2((InterfaceA2)superClass);
    }
    //and so on
}

private static void saveInterfaceA1(InterfaceA1 a1) {
    //construct sql query and save data such as a1.getInterfaceInt()
}

Similarly when we are reading data from the database if we have an
instance of SubClass1 then we know there is a table with an entry
containing the data that can be set using the setters in InterfaceA1.

It's convenient to know that an implementation of InterfaceA1 contains
certain methods.

You are right. I'm going to have to figure out how I can give you more
data before we continue. The problem is larger than what we have
discussed so far and I need to portray the information without posting a
ridiculous amount otherwise I am wasting your time.

A brief summary is that each interface is very simple, four or so
methods. Say you have a drug, the input method can be intravascular or
extravascular. One interface is IVDrug and contains setters and getters
for minInfusionTime and maxInfustionTime stating the min and max time to
give the drug into the vein. EVDrug has a rate constant Ka which
describes how quickly the drug goes from tablet form in the stomach into
the bloody. Ka can be expressed as a formula. There is also a
variability on Ka, so it is accurate +- some percentage amount.

e.g.

interface IVDrug {
    public int getMinInfusionTime();
    public int getMaxInfusionTime();
}

interface EVDrug {
   public String getKaEquation();
   public double getKaVariability();
}

I'll continue:

interface TwoCompDrug {
   public String getVpEquation();
   public double getVpVariability();
   public String getQEquation();
   public String getQVariability();
}

Actually the 4th interface doesn't exist, it would however be
OneCompDrug but there is nothing special about it.

A subclass is either (One Compartment or Two Compartment) AND
(intravascular or extravascular).

Overall my feeling is that the code is fairly nice. It's easy to read
and understand and recent extensions were very simple to design and
implement. My view is that even if this isn't the best design it is
still highly readable. There is some slight duplication of code.

It's just in my best efforts to continue improving my design skills that
I seek to see if there is a better approach. I haven't had the luxury of
being taught this stuff. University courses introduce you to software
patterns, OO design etc. but when it comes to practice it is a different
story. I just want to make sure I do the best job possible.

Thanks for your comments

Lionel.