强制枚举实现者包含某些元素

Question

我正在尝试执行以下操作：

public interface Type
{
    // somehow force implementors to have:
    // ONE;
    // TWO;

    public String getName();
}

public enum Type_A implements Type
{
    ONE("A Is One"),
    TWO("A Is Two");

    private String name;

    private Type_A( String name_in )
    {
        name = name_in;
    }

    @Override
    public String getName()
    {
        return name;
    }
}

public enum Type_B implements Type
    {
        ONE("B Is One"),
        TWO("B Is Two");

        private String name;

        private Type_B(String name_in)
        {
            name = name_in;
        }

        @Override
        public String getName()
        {
            return name;
        }
    }

以便我可以执行以下操作：

 {
    Type type = Type_A;

    type.ONE.getName();
  }

我没能做到这一点。

我想我需要一个特定于枚举的接口？

//忽略以下内容，这样我就可以通过“代码太多”过滤器

Answer 1

我会使用访客模式。这使您可以确保提供每个枚举值行为的类不会错过为任何枚举值提供行为，即使添加新值也是如此，同时不需要多个枚举类型：

package com.example.so;



public class Eg {
    public static void main(String[] args) {
        TypeVisitor<String> nameVisitorA = new TypeVisitor<>() {
            @Override
            public String visitONE() {
                return "A is ONE";
            }

            @Override
            public String visitTWO() {
                return "A is TWO";
            }
        };
        TypeVisitor<String> nameVisitorB = new TypeVisitor<>() {
            @Override
            public String visitONE() {
                return "B is ONE";
            }

            @Override
            public String visitTWO() {
                return "B is TWO";
            }
        };

        System.out.println(Type.ONE.accept(nameVisitorA));
        System.out.println(Type.ONE.accept(nameVisitorB));
    }
}

interface TypeVisitor<T> {
    T visitONE();
    T visitTWO();
}

enum Type {
    ONE {
        @Override
        public <T> T accept(TypeVisitor<T> visitor) {
            return visitor.visitONE();
        }
    },
    TWO {
        @Override
        public <T> T accept(TypeVisitor<T> visitor) {
            return visitor.visitTWO();
        }
    };

    public abstract <T> T accept(TypeVisitor<T> visitor);
}