Как может выглядеть будущее Java

Более вывод типа

Java сделала вывод типов начиная с Java 5 (для свидетелей типов в универсальных методах), и механизм был расширен в Java 7 (оператор diamond), 8 (типы параметров лямбда) и 9 (diamond в анонимных классах). В Java X это вполне может охватывать объявления переменных. Вот пример Брайана:

 // now
URL url = new URL("...")
URLConnectoin conn = url.openConnection();
Reader reader = new BufferedReader(new InputStreamReader(conn.getInputStream()));

// maybe in the future
var url = new URL("...")
var conn = url.openConnection();
var reader = new BufferedReader(new InputStreamReader(conn.getInputStream()));

Здесь типы urlconnreader Как следствие, компилятор может вывести их, что делает ненужным их указание. В общем, вывод типа может уменьшить шаблон, но также и скрыть важную информацию. Если вы считаете имена переменных более важными, чем их типы, вам понравится это, поскольку они идеально выравнивают имена, выбрасывая избыточную информацию.

Обратите внимание, что вывод типа не является динамической типизацией — это все еще сильная типизация, просто с меньшим набором текста (каламбур Брайана — предположительно предназначенный). Информация о типе будет по-прежнему попадать в байт-код, и IDE также смогут их показывать — просто нам больше не нужно ее выписывать.

Автоматическое определение типов процессов подразумевает, что изменения кода изменят результат этих вычислений. Хотя обычно локальная переменная может менять свой тип (например, на супертип), этого нельзя сказать о полях, параметрах метода или возвращаемых значениях и т. Д. Напротив, любое изменение здесь может привести к двоичной несовместимости, что привести к коду, скомпилированному со старой версией, не способной связать во время выполнения. Не хорошо и, следовательно, запрещено.

Таким образом, вывод только типов локальных переменных — это больше защита экосистемы от нестабильного кода, чем защита разработчиков от нечитаемого кода.

Сопоставление с образцом

Текущий оператор switch довольно слабый. Вы можете использовать его для примитивов, перечислений и строк, но это все. Если вы хотите сделать что-то более сложное, вы должны либо прибегнуть к цепочкам if-else-if, либо, если вы не можете выбросить из головы книгу «Банды четырех», шаблон посетителей .

Но подумайте об этом, на самом деле не существует внутренней причины этих ограничений. На более высоком уровне можно описать, как переключатель использует переменную для оценки некоторых условий и выбора подходящей ветви, оценки того, что он там находит — почему тип переменной должен быть настолько ограничен, а условия проверяют только равенство? Если подумать, почему switchделает что-то, а не становится чем-то. Следуя по этому пути, мы получаем сопоставление с образцом, которое не имеет ни одного из этих ограничений.

Прежде всего, все виды переменных могут быть разрешены. Во-вторых, условия могут быть гораздо шире. Они могут, например, проверять типы или даже деконструировать целые объекты данных. И наконец, что не менее важно, весь switch

Вот примеры Брайана:

 // matching types
String formatted;
switch (constant) {
    case Integer i: formatted = String.format("int %d", i); break;
    case Byte b: //...
    case Long l: // ...
    // ...
    default: formatted = "unknown"
}

// used as an expression
String formatted = switch (constant) {
    case Integer i -> String.format("int %d", i);
    case Byte b: //...
    case Long l: // ...
    // ...
    default: formatted = "unknown"
}

// deconstructing objects
int eval(ExprNode node) {
    return switch (node) {
        case ConstantNode(var i) -> i;
        case NegNode(var node) -> -eval(node);
        case PlusNode(var left, var right) -> eval(left) + eval(right);
        case MulNode(var left, var right) -> eval(left) * eval(right);
        // ...
    }
}

Для связанного списка я также использовал его как выражение и для деконструкции узлов:

 currentNode = switch (currentNode.get()) {
    case InnerNode(_, var nextNode) -> Optional.of(nextNode);
    case EndNode(_) -> Optional.empty();
    default: throw new IllegalArgumentException();
}

Гораздо приятнее, чем то, на что это было бы похоже сейчас:

 if (currentNode.get() instanceof InnerNode) {
    currentNode = Optional.of(((InnerNode) currentNode.get()).getNext());
} else if (currentNode.get() instanceof EndNode) {
    currentNode = Optional.empty();
} else {
    throw new IllegalArgumentException();
}

(Да, я знаю, этот конкретный пример можно решить с помощью полиморфизма.)

Резюме

Опять вау! Объекты данных, типы значений, общая специализация, больше выводов типов и сопоставление с образцом — это набор огромных возможностей, над которыми работает команда JDK. Я не могу дождаться их выхода! (Кстати, в то время как я представил все функции здесь, Брайан предоставляет гораздо более интересную информацию — вам определенно следует проверить весь доклад .)

Как вы думаете? Вы хотите написать код на Java?

Понравился этот пост? Хотите узнать больше о настоящем и будущем Java? Подпишитесь на нашу ленту новостей или рассылку .