Generics and API design

Question

I am building a library for a product we will be releasing and am trying to design it for compatibility with some design alterations that are presently on the road map. Specifically the library needs to handle different versions of a product which shares the same commands but which have different requirements for the available options for parameters. To accomplish this I have an abstract class for the product with concrete classes for each of the versions. Additionally I have an abstract class for the peripheral which varies and concrete classes for the specific peripherals. I want the concrete versions to implement an abstract method from the abstract class but for a specified type T rather than specifying the super class and then checking instanceof. For example:

class PeripheralA {}

class PeripheralB {}

abstract class AbstractProduct<T> {

     public abstract void SomeFunction(T param);
}

class ProductA extends AbstractProduct<PeripheralA> {
     public void SomeFunction(T param);
}

class ProductB extends AbstractProduct<PeripheralB> {
     public void SomeFunction(T param);
}

The problem is the compiler says I am not implementing the abstract method SomeFunction. My previous design was to not use generics and specify the abstract type. The problem here is that if PeripheralB is passed to ProductA there will be a class cast exception which I can catch, but I would prefer that the code not compile in the first place (and for that matter, not use the class cast). Is there a way to pull off what I am trying to accomplish or am I simply going about the design incorrectly?

Answer 1

Don't use T for the type of the method parameter; use the type you specified for the class, ie PeripheralA, and you must provide a method body for a non-abstract class:

class ProductA extends AbstractProduct<PeripheralA> {
    public void SomeFunction(PeripheralA param) {
     // your impl here
    }