Re: Design question - implentation and composition

Hi

It sound to me that you are trying to model a class hierarchy that is
designed around variant properties. I think it would be better to use
composition instead. I don't quite understand all of your design yet,
but as an example lets take the DB saveClass functionality.

By using composition and interfaces you could for example do the
following. Lets say you have a class named Drug which is composed of a
list of drug properties. The drug properties list would hold objects
that implements a saveToDB() method. So, to save the list of properties
to a db you would only need to iterate the list and call the saveToDB().
Here is a code example that only considers the db storage aspect.

interface DbStorage {
    public int saveToDb(Connection dbConn);
}

public class DrugPropertyA implements DbStorage, PropertyA {

    public int saveToDb(Connection dbConn) {
      // details on how to save a DrugProperty for the
      // property A class type.
    }
}

public class DrugPropertyB implements DbStorage, PropertyB {

    public int saveToDb(Connection dbConn) {
      // details on how to save a DrugProperty for the
      // property B class type
    }

}

public class Drugs {

    List<DbStorage> prop = new ArrayList();

    public List<DbStorage> getDrugProperties() {
        return prop;
    }
}

public class DbManager {

    public int storeDrugs(List<DbSTorage>) {

      for(DbStorage e : prop) {
        e.saveToDb(dbcon);
      }
    }
}

This way you don't have to consider the type of the properties. I am not
saying this works for your design, but I think you should be looking in
that direction for a solution.

You could extend this by doing

public class Drug {

    protected String PropertyName;
....
}

public class DrugA extends DrugProperty implements DbStorage, PropertyA {
   ...
}

But I suspect that's what you already have done.

Lionel wrote:


I am assuming what you are talking about above is actually the specific
example below, right?


I am not sure of exactly how to do this, because the problem is that you
have different methods for different drugs. But my question is: could
you express this in a different way? My thought is that composition is
the way to go here as well, but in a different way. For example, at some
point you need to know what specific methods you need to call to get
what you want. Could the properties be expressed by a hash instead,
which only contained what was relevant for the current drug? Its not
very OO I suppose, but I think its a better way. Or if how you use these
methods is done i such a way that you could use an exec()/calc() method
in each drug/property instead, which returned the final result.
Or providing the necessary arguments to the method?

E.g.

public interface PropertyCalculation {

    public float calc(int amount, int something);
}

public class PropertyA implements PropertyCalculation {

    public float calc(int amount, int something) {

        return (vpEquation * amount / something) / qeEquation /
            vpVariability);
    }
}

public class Drug {

    calculateX() {
        for(PropertyCalculation c : prop) {
            xValue += e.exec();
       }
    }
}

This was just an example, which might not even be relevant, but its
difficult when not having all the details.

tom