Почему Java не делает вывод типов?

Я всегда удивлялся, почему Java не делает вывод типов, учитывая, что язык такой, какой он есть, и его виртуальная машина очень зрелая. Google Go - это пример языка с превосходным выводом типов, который уменьшает количество набираемых текстов. Есть ли какая-то особая причина того, что эта функция не является частью Java?

Технически говоря, Java имеет вывод типов при использовании обобщений. С помощью общего метода, такого как

public <T> T foo(T t) {
  return t;
}

Компилятор проанализирует и поймет это при написании

// String
foo("bar");
// Integer
foo(new Integer(42));

String будет возвращен для первого вызова и Integer для второго вызова на основе того, что было введено в качестве аргумента. В результате вы получите правильную проверку во время компиляции. Кроме того, в Java 7 можно получить дополнительные выводы при создании экземпляров обобщенных типов, например

Map<String, String> foo = new HashMap<>();

Java достаточно любезен, чтобы заполнить пустые угловые скобки для нас. Теперь, почему Java не поддерживает вывод типов как часть назначения переменных? В какой-то момент был RFE для вывода типа в объявлениях переменных, но это было закрыто как "Не будет исправлено", потому что

Люди извлекают выгоду из избыточности объявления типа двумя способами. Во-первых, избыточный тип служит ценной документацией - читателям не нужно искать объявление getMap (), чтобы выяснить, какой тип он возвращает. Во-вторых, избыточность позволяет программисту объявлять предполагаемый тип и, таким образом, извлекать выгоду из перекрестной проверки, выполняемой компилятором.

Автор, который закрыл это, также отметил, что это просто «не похоже на java», с чем я согласен. Многословие Java может быть и благословением, и проклятием, но оно делает язык таким, какой он есть.

Конечно, этот конкретный RFE не был концом этого разговора. Во время Java 7 эта возможность снова обсуждалась , при этом были созданы некоторые тестовые реализации, в том числе сам Джеймс Гослинг. Опять же, эта функция была в конечном итоге сбита.

С выпуском Java 8 мы теперь получаем вывод типа как часть лямбда-выражений как таковых:

List<String> names = Arrays.asList("Tom", "Dick", "Harry");
Collections.sort(names, (first, second) -> first.compareTo(second));

Компилятор Java , может смотреть на метод , Collections#sort(List<T>, Comparator<? super T>)а затем интерфейс Comparator#compare(T o1, T o2)и определить , что firstи secondдолжно быть , Stringтаким образом , позволяя программисту отказаться от того , чтобы пересчитать тип в лямбда - выражении.

Ну, во-первых, вывод типа не имеет никакого отношения к зрелости среды выполнения, будь то 30-летний процессор или виртуальная машина, которая настолько нова, что биты все еще блестящие. все дело в компиляторе.

Тем не менее, это разрешено для обобщенных типов, причина, почему это не разрешено для неуниверсальных типов, по-видимому, из-за философии - ничто не мешает дизайнерам добавить его.

Обновление: похоже, что java 10 поддерживает это - http://openjdk.java.net/jeps/286

Насколько я знаю, когда Java была разработана в начале девяностых, вывод типа не был настолько популярен среди основных языков (но это уже была очень хорошо известная концепция, например, в ML). Итак, я могу себе представить, что вывод типов, вероятно, не был поддержан, потому что Java была нацелена на программистов, пришедших из C ++, Pascal или других основных языков, у которых этого не было (принцип наименьшего удивления).

Кроме того, одним из принципов разработки Java является явное написание вещей, чтобы гарантировать, что программист и компилятор понимают код одинаково: дублирование информации уменьшает вероятность ошибок. Конечно, может быть дело вкуса, стоит ли вводить еще несколько символов дополнительной безопасности, которую он обеспечивает, но такова была философия проектирования Java: писать вещи явно.

Я не знаю, получит ли Java вывод типов в будущем, но IMO, что станет большой революцией для языка (как упомянул Гленн Нельсон, это было описано как «не-java-подобный»), и тогда можно было бы также рассмотреть возможность удаления Назовите Java в пользу нового имени.

Если вы хотите использовать язык JVM с выводом типа, вы можете использовать Scala.

Я могу придумать несколько возможных причин. Во-первых, явная типизация является самодокументированием. Java обычно делает это приоритетом над краткостью. Другая причина может быть в случаях, когда тип является несколько двусмысленным. Например, когда тип или любой подтип может удовлетворить процедуру. Допустим, вы хотите использовать List, но кто-то приходит и использует метод, эксклюзивный для ArrayList. JIT выведет ArrayList и продолжит работу, даже если вы захотите скомпилировать ошибку.

Это противоречит устоявшейся рекомендации объявлять переменные с использованием наиболее общего интерфейса, который будет соответствовать вашим потребностям, и инициализировать их соответствующим классом реализации, как в

Collection<String> names = new ArrayList<>();

Эффективно,

var names = new ArrayList<String>();

ничего, кроме синтаксического сахара для

ArrayList<String> names = new ArrayList<String>();

Если вы хотите, ваша IDE может создать его из new ArrayList<String>()выражения «одним щелчком» (рефакторинг / создание локальной переменной), но помните, что это противоречит рекомендации «использовать интерфейсы».