Java - enum wildcard

I have some problems implementing a Java feature.

I have a list of Sensors. I have different kinds of them, they all extend the base class Sensor. I have some abstract functions in the base class, and I want these functions to take an Enum as a parameter. The problem is that the Enum is unique for each sub class, and therefore, I can't declare the Enum in the base class.

The code below has Enum as parameter. I know it's not legal syntax, but I just want to illustrate that this is where I want to have the sub class Enum as parameter.

private Vector<Sensor> sensors;

public abstract class Sensor {  
    p开发者_运维问答ublic Sensor() {}  
    public abstract int getParam(Enum param);  
    public abstract void setParam(Enum param, int value);  
}

public class TempSensor extends Sensor {
    // Parameter names
    public static enum TEMP_PARAMETERS{ PARAM_ALARM_HI, PARAM_ALARM_LO }

    public TempSensor() {}

    @Override
    public int getParam(TEMP_PARAMETERS param) {
            // Will do some stuff here
            return 0;
    }

    @Override
    public void setParam(TEMP_PARAMETERS param, int value) {
            // Will do some stuff here
    }
}

If the different Enums implement an interface, I can use the interface as the parameter type in the abstract methods, but then I can pass Enums that don't belong to the respective class as parameter. Is there a way to avoid that?

Looks like you want contradictory things. The whole point of using polymorphism is to take advantage of the substitution principle. If you want to have a class hierarchy and be sure the right type is entered to the right object, you may consider using the factory pattern. I strongly recommend against inheritance on Enums; Java doesn't handle that well.

You're on the right track. Assuming you have a marker interface called MyEnumTypeInterface, just have your different enums implement that inferface. Then use MyEnumTypeInterface as the type of the formal parameter for your methods that accept the enum. However, you need to ensure that you're getting an enum that implements MyEnumTypeInterface and not just any other class that implements MyEnumTypeInterface:

public <E extends Enum<E> & MyEnumTypeInterface>void getParam(E e)

This ensures that the formal parameter is an enum and that it implements MyEnumTypeInterface; the methed won't accept as a parameter, another class that also implements MyEnumTypeInterface.

So your classes end up looking like this:

public interface MyEnumTypeInterface {
}

public abstract class Sensor {  
    public Sensor() {}  
    public abstract <E extends Enum<E> & MyEnumTypeInterface>int getParam(E param);  
    public abstract <E extends Enum<E> & MyEnumTypeInterface>void setParam(E param, int value);  
}

public enum TempEnum extends MyEnumTypeInterface {
    PARAM_ALARM_HI, 
    PARAM_ALARM_LO
}


public class TempSensor extends Sensor {

    public TempSensor() {}

    @Override
    public<E extends Enum<E> & MyEnumTypeInterface>int getParam(E param) {
            return 0;
    }

    @Override
    public <E extends Enum<E> & MyEnumTypeInterface>void setParam(E param, int value) {
            // Will do some stuff here
    }
}

So you want each Sensor to work a particular param type? That would mean making Sensor generic.

public abstract class Sensor<P extend Enum<P>> {  
    public Sensor() {}  
    public abstract int getParam(P param);  
    public abstract void setParam(P param, int value);  
}

There are probably bigger problems with you design. Fixing those could remove the requirement for the get and set.