'a' 不是一个 String 符号；换成 "a" （我也不完全理解这个用例——或者可能会使用regex引擎编写完全不同的用例）。但是，为了避免无意义的铸造…只需检查 instanceof ，你想投的东西。与此类似，没有多少空间来进行模棱两可的调用和无用的来回转换。

问题是三元运算符的两个分支返回不同的类型。
这个怎么样：

System.out.println(
        String.valueOf(
            true ? (Object)'a' : fail()
        )
    );

简单问题的简单答案：

class Code {

    public static void main(String[] args) throws Throwable {
        System.out.println((
                true ? 'a' :
                true ? 'b' :
                true ? 'c' :
                fail()).toString()
        );
    }
    private static <R> R fail() {
        throw null;
    }

}

只要您没有任何 null 价值观。也包括 null 需要引入其他方法的值：

class Code {

    public static void main(String[] args) throws Throwable {
        System.out.println(valueOf(
                true ? 'a' :
                true ? 'b' :
                true ? 'c' :
                fail()
            )
        );
    }
    private static <R> R fail() {
        throw null;
    }

    static String valueOf(Object object) {
        return String.valueOf(object);
    }
}

两种解决方案都不需要编辑 ? : 编译器警告和错误都不是bug。在错误情况下，您为编译器提供的信息太少，无法选择正确的方法，在第二次尝试中，您告诉编译器将一个对象强制转换为一个不必要且至少值得产生警告的对象；-）

对角色进行显式装箱是一种可能性：

class Code {
    public static void main(String[] args) throws Throwable {
        System.out.println(
                String.valueOf(
                        true ? Character.valueOf('a') : fail()
                )
        );
    }
    private static <R> R fail() {
        throw null;
    }
}

您可以与供应商联系以获得以下方法：

class Code {
   public static void main(String[] args) throws Throwable {
        System.out.println(((Supplier<Object>) () ->
                true ? 'a' :
                        false ? 'b' :
                                false ? 'c' :
                                        fail()).get());
    }
    private static <R> R fail() { throw null; }
 }

如果我忽略了我对 String 我可以写：

String.valueOf((Character)(
            true ? 'a' :
            fail()
        ))

两者兼备 char 以及 String 我可以用这个奇怪的词：

String.valueOf((Comparable<?>)(
            true ? 'a' :
            fail()
        ))

或者使用java序列化实现一些有用的功能：

String.valueOf((java.io.Serializable)(
            true ? 'a' :
            fail()
        ))

它应该被认为是一个bug，但是我不想和bug.java.com打交道。
另一种解决方法是引入不必要的本地解决方案：

Object symbol = 
            true ? 'a' :
            fail();
    System.out.println(String.valueOf(symbol));

这应该不是必需的，但是可以使类型参数 fail() 显式并避免任何讨厌的显式强制转换：

String.valueOf(
            true ? 'a' :
            Code.<Object>fail()
        )

可爱的语法！或者， fail() 可能有多余的演员。。。

将表达式的结果提取到局部变量：

T obj =
        true ? 'a' :
                true ? 'b' :
                        true ? 'c' : fail();
System.out.println(String.valueOf(obj));

关于“不明确的方法调用”的错误是正确的，因为java 8.
甚至在java之前 8，你会写字

char c = fail();
Object o = fail();

没有编译器错误。当你通过一个有条件的 condition? 'a': genericMethod() 像这样的方法 String.valueOf(…) ，编译器推断 <Object> 为了 fail() 并挑选 String.valueOf(Object) 由于其有限的类型推断。
但是java 8个表达式：
独立表达式的类型可以完全由表达式的内容决定；相反，多边形表达式的类型可能受表达式的目标类型的影响(§5（转换和上下文）。
泛型方法的调用和包含poly表达式的条件表达式（即泛型方法的调用）都是poly表达式。
所以我想 String.valueOf(char) 是有条件的，我们可以推断 <Character> 为了 fail() . 请注意，这两种方法都不适用于严格的调用上下文，因为这两种变体都需要装箱或拆箱操作。在松散的调用上下文中， String.valueOf(Object) 以及 String.valueOf(char) 是适用的，因为我们是否拆开 Character 调用后 fail() 或者盒子 char 文字的 'a' .
自 char 不是的子类型 Object 以及 Object 不是的子类型 char ，两种方法都不是， String.valueOf(Object) 也不是 String.valueOf(char) ，更具体，因此会生成编译器错误。
对警告的判断比较困难，因为警告没有正式的标准。在我看来，每一个声称源代码工件已经过时的编译器警告都是不正确的，尽管在删除源代码工件后，代码不会做同样的事情（或者删除它甚至会引入错误）。有趣的是，这个警告在java中已经存在了 7的版本 javac ，删除演员阵容确实没有什么区别，所以也许，这是一个需要更新的遗留问题。
这个问题的解决方法取决于上下文，并且没有足够的信息。请注意，只需要一个不可分配的分支 char ，使方法 String.valueOf(char) 不适用。一旦插入计算结果为的分支，就会发生这种情况 String . 你也可以用 SurroundingClass.<Object>fail() 以获得与前java相同的类型 8个编译器。
或者完全删除泛型签名，因为这里不需要它。泛型方法 fail() 在表达式上下文中似乎有一个抛出方法。更干净的解决方案将是表达式的工厂方法，例如。

class Code {
    public static void main(String[] args) throws SpecificExceptionType {
        System.out.println(
            String.valueOf(switch(0) {
                case 0 -> 'a';
                case 1 -> 'b';
                case 2 -> 'c';
                default -> throw fail();
            })
        );
    }
    private static SpecificExceptionType fail() {
        return new SpecificExceptionType();
    }
    static class SpecificExceptionType extends Exception {
    }
}

如果switch表达式不可行，可以使用

System.out.println(
    String.valueOf(
        true ? 'a' :
        true ? 'b' :
        true ? 'c' :
        Optional.empty().orElseThrow(Code::fail)
    )
);

两者的优点都是对可能抛出的异常的实际类型非常具体，并且不需要求助于未检查的异常或异常 throws Throwable 声明。第二种方法可能会让人觉得很粗糙，但只不过是定义了一个从不返回任何内容的泛型方法。
当然，如果您接受更多代码的引入，也有其他的解决方法，比如用于字符串转换的专用helper方法（无重载）或用于抛出方法的非泛型 Package 方法。或者临时变量或类型为泛型调用强制转换或显式类型等 "" + (expression) 或者 (expression).toString() 而不是 String.valueOf(expression) ，表达式不是poly表达式，因此，不是pro­杜­“方法调用不明确”错误。
当然，由于这是一个错误的警告，你也可以保留演员阵容并添加一个 @SuppressWarnings("cast") 方法（并等待编译器开发人员修复）。