在嵌套枚举实现接口中继承泛型类型

Question

I try to write a generic abstract class for my state machine, that will be utilizing enum implementing some interface defined inside that abstract class. I have an abstract class which contains a field implementing a generic interface and some wrapper functions for state switching logic. I try to extend this abstract class and create nested enum type implementing this generic interface, but there are some places, where I have to define explicitely which types I am using for generics. The code below demostrates this problem

public abstract class FiniteStateMachine<C, I> { // <- generic types declared here
   private State<C, I> currentState;
   protected FiniteStateMachine(State<C, I> initial){ currentState = initial; }
   // some other methods for FSM, that I don't want to include in State<>
   // ...

   public synchronized void process(C context, I input) {
      State<C, I> nextState = currentState.process(context, input)
      if(currentState != nextState){
         currentState.onExit(nextState, context);
         State<C, I> previousState = currentState;
         currentState = nextState;
         nextState.onEnter(previousState, context);
      }
   }

   public interface State<C, I> { //<- this interface should use the same types as FiniteStateMachine
      State<C, I> process(C context, I input);
      default void onEnter(State<C, I> s, C context) {}
      default void onExit(State<C, I> s, C context) {}
   }
}

class FSM extends FiniteStateMachine<Data, String> { // <- here I define types used for FSM
   public FSM() { super(FSMStage.START); }

   enum FSMState implements State<Data, String> { // <- and here I have to repeat them
      START{
         @Override
         public FSMState process(Data p, String s) {
            // ...
            return NEXT;
         },
         @Override
         public void onExit(State s, Data d) { /* ... */ }
      },
      NEXT{
         // ...
      }

   }
}

The main concern is that type information is defined in multiple places in extending class - once in type info of the abstract class and onec in interface the enum implements.

FiniteStateMachine is abstract and not an interface because I need some flags and initial state fields (and I can't make an "abstract field" otherwise than with protected constructor hack). FiniteStateMachine.State is an interface, because it's used in enums which cannot be extended. I also want to keep FiniteStateMachine and FiniteStateMachineState in one file, because separate fiels create lots of bloat content in project. Also inside extending FSM the onExit method has a type of State instead of FSMStage.

I tried something like FiniteStateMachine<C, I, State<C, I>> but errors said that 'State is not accessible in the context'.

Is there any way to declare the types in one place in extending class instead of FSM and FSMState like right now? Or maybe there is a way to declare types only for FSMState and make FSM reuse those types? Or maybe this design is completely flawed?

Answer 1

The point is that inner interfaces (and enums too btw) are implicitely static, so they cannot use generic parameters of outer class, because they have no access to instances of the outer class.

So basically this interface is inside the abstract class only for code convenience, you may aswell extract it to separate file. In this design I don't think there is a way to skip multiple generic type declarations.

I think changing the design just to avoid the re-declaration is not worth it - you could make State an abstract class and remove generic types from declaration so it gets generic types from the outer class, but then the idea with enums doesn't work.

Answer 2

C in FiniteStateMachine is not the same C in State class, If you want to make them dependent, you have to define a third type in your FiniteStateMachine which uses C and I with State . You were almost right with FiniteStateMachine<C, I, State<C, I>> , but here how you can do it :

public abstract class FiniteStateMachine<C, I, T extends FiniteStateMachine.State<C, I>> {
    private T currentState;
    protected FiniteStateMachine(T initial){ currentState = initial; }

    public synchronized void process(C context, I input) {
        FiniteStateMachine.State<C, I> nextState = currentState.process(context, input);
        if(currentState != nextState){
            currentState.onExit(nextState, context);
            State<C, I> previousState = currentState;
            currentState = (T) nextState;
            nextState.onEnter(previousState, context);
        }
    }

    public interface State<CTX, INPT> {
        State<CTX, INPT> process(CTX context, INPT input);
        default void onEnter(State<CTX, INPT> s, CTX context) {}
        default void onExit(State<CTX, INPT> s, CTX context) {}
    }
}

Now you force the types of State to be same as those defined in FiniteStateMachine .

You can use it now like :

public class FSM extends FiniteStateMachine<Date, String, FSM.FSMState> { 
    public FSM() { super(FSMState.START); }

    public enum FSMState implements FiniteStateMachine.State<Date, String> {
        START{
            @Override
            public FSMState process(Date p, String s) {
                // ...
                return NEXT;
            }

            @Override
            public void onExit(FiniteStateMachine.State s, Date d) { /* ... */ }
        },
        NEXT{
            @Override
            public FiniteStateMachine.State<Date, String> process(Date context, String input) {
                return null;
            }
            // ...
        }
    }
}

Otherwise, what about repeating the generic types !? From what i've learned so far, there's no way to simplify the writing of your classes. I think the origin of your question was when the two classes are declared in the same file. What if they were separated in two different files ? Do you continue thinking this way ?