Разница между тернарным оператором C # и Java (? :)

Я новичок в C #, и у меня возникла проблема. При работе с тернарным оператором ( ? :) существует разница между C # и Java .

Почему в следующем фрагменте кода не работает 4-я строка? Компилятор показывает сообщение об ошибке there is no implicit conversion between 'int' and 'string'. 5-я строчка тоже не работает. Оба 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 # отсутствует? Если есть, то почему не добавляется?

Просматривая раздел 7.14 Спецификации языка C # 5: Условный оператор, мы можем увидеть следующее:

• Если x имеет тип X, а y имеет тип Y, то

  • Если существует неявное преобразование (§6.1) из X в Y, но не из Y в X, то Y является типом условного выражения.

  • Если существует неявное преобразование (§6.1) из Y в X, но не из X в Y, то X - это тип условного выражения.

  • В противном случае невозможно определить тип выражения, и произойдет ошибка времени компиляции.

Другими словами: он пытается определить, могут ли x и y быть преобразованы друг в друга, и если нет, возникает ошибка компиляции. В нашем случае , intи stringне имеют никакого явного или неявного преобразования , поэтому он не будет компилироваться.

Сравните это с разделом 15.25 спецификации языка Java 7: Условный оператор :

• Если второй и третий операнды имеют один и тот же тип (который может быть нулевым типом), то это тип условного выражения. ( НЕТ )
• Если один из второго и третьего операндов имеет примитивный тип T, а тип другого является результатом применения преобразования упаковки (§5.1.7) к T, тогда тип условного выражения - T. ( НЕТ )
• Если один из второго и третьего операндов имеет тип null, а тип другого является ссылочным типом, то тип условного выражения является этим ссылочным типом. ( НЕТ )
• В противном случае, если у второго и третьего операндов есть типы, которые могут быть преобразованы (§5.1.8) в числовые типы, тогда есть несколько случаев: ( НЕТ )
• В противном случае второй и третий операнды относятся к типам 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 # никогда не говорит: «Я выбираю между Cat и Dog, поэтому я сделаю вывод, что Animal - лучший выбор». Это не было возможностью выбора, поэтому C # не может его выбрать.

В случае тернарного оператора C # пытается выбрать более общий тип int и string, но ни один из них не является более общим типом. Вместо того, чтобы выбирать тип, который изначально не был выбран, например, object, 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<?>>, в зависимости от контекста использования, поскольку они оба являются общими универсальными супертипами) и тип времени выполнения raw 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");