在利用多态性的同时避免类的创建

Question

I don't really have a lot of practical experience with either java or oop in general so now I'm stuck with a problem that's probably really easy to work around but where I'm not sure at all how an elegant, oop oriented solution might look like.

So here's a simplified rundown:

Say I wanted to write some sort of calculating application which first of all contains several methods like:

static double sine(double x){...}
static double cosine(double x){...}

and so forth. Some other static method would then perform some sort of calculation that involves the derivative of one of these functions. If we pretend there was no way to approximate that derivative, the easiest solution that came to mind for me was to wrap each of the method above in a class and to let those classes implement an interface 'Differentiable' that defines the method 'evaluateDerivative', eg:

interface Differentiable {
    double evaluateDerivative(double x);
}

class sine implements Differentiable {          
    static double evaluate(double x){
        return...;
    }

    public double evaluateDerivative(double x) {
        return cosine.evaluate(x);
    }
}

so if I needed the derivative of any method for another calculation I could simply do something like this:

static double returnDerivativePlusOne(Differentiable d, double x){          
    return d.evaluateDerivative(x) + 1;
}

Okay, now the problem is this: when I actually want to call the method above, I need an instance of the sine class, eg:

DerivativePlusOne(new sine(), 1);

which doesn't really make sense because the sine class only contains static methods (and maybe some final fields) so creating an object seems strange to me.

So, is there a different approach that would produce the same outcome in a more elegant way ? Any help would be appreciated.

Answer 1

Why not make evaluateDerivative function static as well. There is no need of interface.

To make use of polymorphism, we can do the following. Suppose we are doing the following: we have two class Sine and Cosine, and an interface Differentiable.

interface Differentiable {
    double evaluateDerivative(double x);
}

class Sine implements Differentiable {
    static double evaluate(double x){return...}
    public double evaluateDerivative(double x) {return somevalue;}
}

class Cosine implements Differentiable {        
    static double evaluate(double x){return...}
    public double evaluateDerivative(double x) {return somevalue;}
}

In that case, to make use of polymorphism, what you can do is:

Differentiable d = new Sine();
double derivative = d.evaluateDerivate();
d = new Cosine();
derivative = d.evaluateDerivate();

Hope it helps.

Answer 2

Why do you want that methods to be static? And if there is no particular reason, maybe your application should just create an instance of a calculating class at startup, and then use it?

In my opinion, if you really insist on creating objects that provide typical functions and you want to have derivatives of those functions as well, you may hand-code those derived methods (in another or even the same class). I actually can't see where you'd use polymorphism with such case, as this is not a typical oo app (because your objects are just bundles of calculating methods).

What's even more, if you really wanted to create derived classes to calculate derivatives, your evaluateDerivative method should return an object of the derived class, and not a numer.

An elegant solution in this case would be, in my opinion, to create a kind-of-library containing the methods you want. Just an easy-to-use bundle of methods, as your classes does not seem to provide anything more than calculating methods (of typical maths functions, for which there are already written functions as well). I'd still say that created bundle (which may be even a static class) fulfills Single Responsibility Principle (as it only provides some maths functions), but even this does not appear to be so important here. The rules of creating elegant OO solutions (like SOLID rules, for example) are there to help you write code that is easier to manage and handy to build on top of. I can't see how would you build a bigger class hierarchy actually based on your calculating class, so the simplest solution may be the best.