Java 我如何摆脱这些关于枚举的警告？

我想消除这些关于未经检查的转换和参数化的警告，而不必对它们进行限制

interface Switch {
    void toggle();
}
enum A implements Switch {
    a1,a2;
    @Override public void toggle() {
        state=!state;
    }
    boolean state;
}
enum B implements Switch {
    b1,b2;
    @Override public void toggle() {
        state=!state;
    }
    boolean state;
}
public class Warnings {
    public static void main(String[] args) {
        Class<? extends Enum>[] enums=new Class[]{A.class,B.class};
        for(Class<? extends Enum> clazz:enums)
            try {
                Enum s=Enum.valueOf(clazz,args[0]);
                ((Switch)s).toggle();
            } catch(IllegalArgumentException eee) {}
    }
}

接口开关{
void toggle（）；
}
枚举一个实现开关{
a1，a2；
@覆盖公共无效切换（）{
状态=！状态；
}
布尔状态；
}
枚举B实现交换机{
b1，b2；
@覆盖公共无效切换（）{
状态=！状态；
}
布尔状态；
}
公开课警告{
公共静态void main（字符串[]args）{
类不要混合使用数组和泛型。它们不能很好地协同工作，因为java中的泛型是使用类型擦除实现的

这应该行得通

interface Switch {
void toggle();
}

enum A implements Switch {

a1, a2;
@Override
public void toggle() {
    state = !state;
}

boolean state;
}
enum B implements Switch {

b1, b2;
@Override
public void toggle() {
    state = !state;
}

boolean state;
}

public class Test {

public static void main(String[] args) {
    List<Class<? extends Switch>> enums = new ArrayList<Class<? extends Switch>>();
    enums.add(A.class);
    enums.add(B.class);

    for (Class<? extends Switch> clazz : enums)
        try {
            Switch s = clazz.getEnumConstants()[0];
            ((Switch) s).toggle();
        } catch (IllegalArgumentException eee) {
    }
} 
}

接口开关{
void toggle（）；
}
枚举一个实现开关{
a1，a2；
@凌驾
公共无效切换（）{
状态=！状态；
}
布尔状态；
}
枚举B实现交换机{
b1，b2；
@凌驾
公共无效切换（）{
状态=！状态；
}
布尔状态；
}
公开课考试{
公共静态void main（字符串[]args）{
列出如果不编写自己的
值，则不能将
枚举定义为：

class Enum<E extends Enum<E>>

public static <T extends Enum<T>> T valueOf(Class<T> enumType,
                                            String name) 

请注意递归类型参数化，这意味着您只能使用特定的枚举类（例如
a.class
）调用
valueOf
，而不能使用泛型类，因为
类>
不匹配，因为编译器不假设这两个问号表示相同（未知）的类型

因此，除了使用泛型集合而不是数组之外，您还必须编写自己的
valueOf
方法来接受任何枚举类

public class Warnings {
    public static void main(final String[] args) {
        List<Class<? extends Enum<?>>> enums = new ArrayList<Class<? extends Enum<?>>>();
        enums.add(A.class);
        enums.add(B.class);
        for (Class<? extends Enum<?>> clazz : enums) {
            try {
                Switch s = valueOf(clazz, args[0]);
                s.toggle();
            } catch (IllegalArgumentException eee) {
            }
        }
    }

    private static Switch valueOf(final Class<? extends Enum<?>> enumClass, final String name) {
        Enum<?>[] enumConstants = enumClass.getEnumConstants();
        for (Enum<?> constant : enumConstants) {
            if (constant.name().equals(name)) {
                return (Switch) constant;
            }
        }
        throw new IllegalArgumentException(name + " is not a constant of enum class " + enumClass.getName());
    }
}

公共类警告{
公共静态void main（最终字符串[]args）{
列表>>（）；
enums.add（A.class）；
enums.add（B.class）；
对于（类>类：枚举）{
试一试{
开关s=valueOf（clazz，args[0]）；
s、 切换（）；
}捕获（IllegalArgumentException eee）{
}
}
}
私有静态开关值（最终类>枚举类，最终字符串名称）{
Enum[]enumConstants=enumClass.getEnumConstants（）；
用于（枚举常量：枚举常量）{
if（constant.name（）.equals（name））{
返回（开关）常数；
}
}
抛出新的IllegalArgumentException（name+“不是枚举类”+enumClass.getName（）的常量）；
}
}
您是否尝试过
@SuppressWarnings（“未选中”）
？我应该在不禁用它们的情况下添加它们。感谢中断：Enum s=Enum.valueOf（clazz，args[0]）；在它的当前状态下，我看不出调用a.a1.toggle（）或a.a2.toggle（）有什么区别。我想做：（（Switch）Enum.valueOf（clazz，args[0]）。toggle（）；