C＃和Java三元运算符（？:)之间的区别

我是C＃新手，刚遇到问题。处理三元运算符（? :）时，C＃和Java之间有所不同。

在以下代码段中，为什么第四行不起作用？编译器显示错误消息there is no implicit conversion between 'int' and 'string'。第五行效果不佳。两者List都是对象，不是吗？

int two = 2;
double six = 6.0;
Write(two > six ? two : six); //param: double
Write(two > six ? two : "6"); //param: not object
Write(two > six ? new List<int>() : new List<string>()); //param: not object

但是，相同的代码在Java中也有效：

int two = 2;
double six = 6.0;
System.out.println(two > six ? two : six); //param: double
System.out.println(two > six ? two : "6"); //param: Object
System.out.println(two > six ? new ArrayList<Integer>()
                   : new ArrayList<String>()); //param: Object

C＃中缺少什么语言功能？如果有，为什么不添加？

查看C＃5语言规范的第7.14节：条件运算符，我们可以看到以下内容：

• 如果x具有X类型，而y具有Y类型，则

  • 如果存在从X到Y的隐式转换（第6.1节），但不存在从Y到X的转换，则Y是条件表达式的类型。

  • 如果存在从Y到X的隐式转换（第6.1节），但是从X到Y不存在，则X是条件表达式的类型。

  • 否则，无法确定表达式类型，并且会发生编译时错误

换句话说：它试图找到Y是否x和可以转化成海誓山盟并且如果不是，则产生编译错误。在我们的情况下int，string没有显式或隐式转换，因此将无法编译。

将此与Java 7语言规范的第15.25节：条件运算符进行对比：

• 如果第二个操作数和第三个操作数具有相同的类型（可能为null类型），则这是条件表达式的类型。（没有）
• 如果第二个操作数和第三个操作数之一是原始类型T，而另一个操作数的类型是对T应用装箱转换（第5.1.7节）的结果，则条件表达式的类型为T。（NO）
• 如果第二个操作数和第三个操作数之一为空类型，而另一个的类型为引用类型，则条件表达式的类型为该引用类型。（没有）
• 否则，如果第二和第三操作数具有可转换（第5.1.8节）为数字类型的类型，则有以下几种情况：（NO）
• 否则，第二和第三操作数分别为S1和S2类型。令T1为对S1进行装箱转换所产生的类型，而T2为对S2进行装箱转换所产生的类型。
  条件表达式的类型是将捕获转换（§5.1.10）应用于lub（T1，T2）（§15.12.2.7）的结果。（是）

并且，请参阅第15.12.2.7节。根据实际参数推断类型参数，我们可以看到它试图找到一个共同的祖先，该祖先将用作调用它的调用的类型Object。Object 是可以接受的参数，因此该调用将起作用。

给出的答案是好的。我要补充一点，这是C＃规则是更通用的设计指南的结果。当要求从几种选择之一推断出表达式的类型时，C＃会选择其中唯一的一种。也就是说，如果您给C＃一些选择，例如“长颈鹿，哺乳动物，动物”，那么它可能会根据情况选择最通用的动物（动物），也可能选择最特殊的长颈鹿。但是它必须选择实际给出的选择之一。C＃从不说“我的选择是在猫和狗之间，因此我会推断出动物是最好的选择”。那不是给定的选择，所以C＃无法选择它。

对于三元运算符，C＃会尝试选择更通用的int和string类型，但都不是最通用的类​​型。C＃决定不推断任何类型，而不是选择对象之类的非首选类型。

我还注意到这与C＃的另一种设计原则保持一致：如果出现问题，请告诉开发人员。该语言不会说“我会猜你的意思，如果可以的话，请继续进行下去”。语言说：“我认为您在这里写了一些令人困惑的东西，我将告诉您。”

另外，我注意到C＃并不是从变量到赋值，而是从另一个方向。C＃不会说“您正在分配给对象变量，因此表达式必须可转换为对象，因此我将确保它是”。相反，C＃说“此表达式必须具有类型，并且我必须能够推断出该类型与对象兼容”。由于表达式没有类型，因此会产生错误。

关于泛型部分：

two > six ? new List<int>() : new List<string>()

在C＃中，编译器尝试将右侧的表达式部分转换为某种常见的类型。由于List<int>和List<string>是两种不同的构造类型，因此不能将一种转换为另一种。

在Java中，编译器会尝试查找通用的超类型而不是进行转换，因此代码的编译涉及通配符的隐式使用和类型擦除；

two > six ? new ArrayList<Integer>() : new ArrayList<String>()

具有编译类型ArrayList<?>（实际上，根据使用上下文的不同，也可以是ArrayList<? extends Serializable>或ArrayList<? extends Comparable<?>>，因为它们都是通用的通用超类型）和原始的运行时类型ArrayList（因为它是通用的原始超类型）。

例如（自己测试），

void test( List<?> list ) {
    System.out.println("foo");
}

void test( ArrayList<Integer> list ) { // note: can't use List<Integer> here
                                 // since both test() methods would clash after the erasure
    System.out.println("bar");
}

void test() {
    test( true ? new ArrayList<Object>() : new ArrayList<Object>() ); // foo
    test( true ? new ArrayList<Integer>() : new ArrayList<Object>() ); // foo 
    test( true ? new ArrayList<Integer>() : new ArrayList<Integer>() ); // bar
} // compiler automagically binds the correct generic QED

在Java和C＃（以及大多数其他语言）中，表达式的结果都有一个类型。对于三元运算符，将为结果评估两个可能的子表达式，并且两个子表达式必须具有相同的类型。对于Java，int可以Integer通过自动装箱将变量转换为。现在，由于Integer和String都继承自Object，可以通过简单的缩小转换将它们转换为相同类型。

另一方面，在C＃中，an int是基元，并且没有隐式转换为string或任何其他object。

这很简单。字符串和整数之间没有隐式转换。三元运算符需要最后两个操作数具有相同的类型。

尝试：

Write(two > six ? two.ToString() : "6");