abstract class declaring a derived class as a return

[keldon85]

I almost had a bit of a problem when turning an interface into an abstract class. Basically I wanted it to provide an implementation (which is why I changed it to abstract), however since it was mutable and therefore returning itself the abstract class caused problems for any code that implemented the derived class.

1   2   3   4   5   6   7   8   9   10   11   12   13   14   15   16   17   18

abstract class Abstract {    public Abstract mutableMethod (){       return createInstance ().doSomething();    } } abstract class Derived extends Abstract {    public Derived doSomething (){       ...    } } class Main {    void poorMethod (){       // problem !!!      Derived derived = new Derived().doSomething();    } }

However using templates you can eliminate this problem without overriding every method or making main look weirder in any way.

1   2   3   4   5   6   7   8   9   10   11   12   13   14   15   16   17   18

abstract class Abstract <DerivedClass extends Abstract> {    public DerivedClass mutableMethod (){       return createInstance ().doSomething();    } } abstract class Derived extends Abstract <Derived> {    public Derived doSomething (){       ...    } } class Main {    void poorMethod (){       // no more problem !!!      Derived derived = new Derived().doSomething();    } }

[broumbroum]

note that you cannot namely instantiate an abstract-class, but you must use a non-abstract extending class or an anonymous instanciation...   

[keldon85]

note that you cannot namely instantiate an abstract-class, but you must use a non-abstract extending class or an anonymous instanciation...   

Yes, that was the aim. Basically it is for an implementation of a tone generator - at first I had a oscillator interface. As soon as I created another waveform it was more than obvious to keep a majority of the implementation in the oscillator since very little is going to change between the sub classes other than what it thinks is at a particular phase.

In fact the only abstract methods in Oscillator are getAmplitude and createInstance. createInstance is there so that the abstract Oscillator can still provide implementations to mutable methods. Also I amended the example so that you can not later create an error by doing something like "class Derived extends Abstract<NotDerrived>".

Disclaimer: this is not for anything sound related, other than the fact that you could use some principles. It's for a game involving waves!

Games published by our own members! Check 'em out!

[karmaGfa]

Hi,

I have been using this pattern for year, and there is something you need to realize:

It is not because you write :

public abstract class X<C extends X<C>> {...}

... that you should suppose that X will always be used like that:

public class A extends X<A> {...}

It could also be used like that:

public class B extends X<A> {...}