I am trying to model a menuing system that can have menus which contain sub-menus. I wanted a generified `interface` for retrieving options from menus and from sub-menus via their parent menus and I am having trouble designing it while keeping it type-safe, flexible and free of compile-time 'incompatible types' errors. I tried to achieve my goal by using Java generics to specify a `Menu interface` for simple menus and a `ParentMenu interface` for parent menus which use generic type parameters for method parameters and return types. 

I have a third `Enumerable interface` for representing the options available on a particular menu. The classes which `implement` the `Enumerable interface` are all `enum classes` that enumerate the options on a menu. A parent menu can hold numerous sub-menus, and I want a generified single method that allows a client of the parent menu class to get the options for any one of its sub-menus. 

A parent menu concrete `class` has a method with a signature that specifies a return value of `List<Enumerable>`. I want to be able to return a `List<MenuOption>` where `MenuOption` `implements` the `Enumerable interface`. However, I get an error which says that the `List<MenuOption>` I want to return is incompatible with a `List<Enumerable>`. 

The basic `Menu interface`:

```
package example;

import java.util.List;

public interface Menu<T> {
    public List<T> getOptions();
}

```

The `ParentMenu interface`:

```
package example;

import java.util.List;

public interface ParentMenu<T,U> {
    public List<T> getSubMenuOptions(U subMenu);
}

```

The `Enumerable interface:

```
package example;

public interface Enumerable {
    public String getName();
}

```

Here is an implementation of the `Menu interface`:

```
package example;

import java.util.*;

public class SimpleMenu implements Menu<MenuOption> {

    private final Map<MenuOption, String> menuLinks;

    public SimpleMenu() {
        menuLinks = new HashMap<>();
        for(MenuOption option : MenuOption.values()) {
            //Totally arbitrary mapping to avoid adding extra classes and Selenium stuff that is not actually part of
            //the question I'm asking.
            menuLinks.put(option, option.getName());
        }
    }

    public final List<MenuOption> getOptions() {
        Set keys = menuLinks.keySet();
        List<MenuOption> options = new ArrayList<MenuOption>(keys);

        return options;
    }
}

```

Here is the `enum class` that enumerates the options on the `SimpleMenu`:

```
package example;

import java.util.HashMap;
import java.util.Map;

public enum MenuOption implements Enumerable {

    OPTION_ONE("Option One"),
    OPTION_TWO("Option Two");

    private static final Map<String, MenuOption> lookup = new HashMap<>();

    private final String name;

    static {
        for (MenuOption option : MenuOption.values()) {
            lookup.put(option.toString(), option);
        }
    }

    private MenuOption(final String name) {
        this.name = name;
    }

    public final static MenuOption getByName(final String name) {
        return lookup.get(name);
    }

    public final String getName() {
        return name;
    }
}

```

Here is an implementation of the `ParentMenu interface` which contains `SimpleMenu` as a sub-menu. The return statement below is where I am still getting an 'incompatible types' error because `List<Enumerable>` is not compatible with `List<MenuOption>`.

```
package example;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public final class ConfigureMenu implements ParentMenu<Enumerable,ConfigureMenu.ConfigureSubMenu> {

    public static enum ConfigureSubMenu implements Enumerable {

        SIMPLE_MENU("An Option");

        private final String name;

        private static final Map<String, ConfigureSubMenu> lookup = new HashMap<>();

        static {
            for (ConfigureSubMenu subMenu : ConfigureSubMenu.values()) {
                lookup.put(subMenu.toString(), subMenu);
            }
        }

        private ConfigureSubMenu(final String name) {
            this.name = name;
        }

        public final String getName() { return name; }

        public static ConfigureSubMenu getByName(String name) {
            return lookup.get(name);
        }
    }

    public final List<Enumerable> getSubMenuOptions(final ConfigureSubMenu subMenu) {
        switch(subMenu) {
            case SIMPLE_MENU:
                List<MenuOption> options = new SimpleMenu().getOptions();
                //This line causes the incompatible types error (List<Enumerable> is not compatible with List<MenuOption>)
                return options;
            default:
                return new ArrayList<>();
        }
    }
}

```

How do I alter the signatures of my generic `interfaces` or the signatures of my concrete implementations so that I can get rid of this error and still have a flexible generic method that can return the options for any sub-menu contained by a parent menu?

NOTE: I have edited this question numerous times since it was asked and answered in order to improve the quality and to make it very clear what my problem and my desired objective were.