KotlinRush: makatuwiran bang magpatuloy sa pagsusulat sa Java?

Kumusta, mag-aaral ng JavaRush, bago ka tuluyang ma-absorb ng Java, gusto kong palawakin ang iyong mga abot-tanaw at bigyang pansin ang lalong popular na wikang Kotlin ! Ang Kotlin ay isang medyo batang wika na binuo ng JetBrains . Oo, oo, ang mismong kumpanya na bumuo ng aming paboritong IDE: IntelliJ IDEA. Ang Kotlin ay isang wikang JVM at ganap na katugma sa Java , ibig sabihin, mula sa Kotlin code ay madali mong ma-access ang mga pamilyar na library ng Java. Paano naman ang mga aklatan: Ang mga klase ng Kotlin at Java ay maaaring magkasama sa isang pakete! Napakasikat ng Kotlin sa komunidad ng programming kung kaya't kinilala ito ng Google bilang opisyal na wika ng pag-develop para sa Android, at kamakailan lamang ay nagsimulang sumikat si Kotlin sa mga proyekto ng enterprise. Sa artikulong ito, nais kong magbigay ng ilang mga paghahambing na halimbawa ng code na nakasulat sa Kotlin at Java, at gumuhit ng ilang konklusyon. Go! Magsimula tayo, gaya ng dati, sa "Hello World"

// Java
public class Application {
    public static void main(String[] args) {
        System.out.println("Hello World!");
    }
}

// Kotlin
class Application
fun main(vararg args: String) {
    println("Hello World!")
}

Sa pagtingin sa halimbawa ng Kotlin, mapapansin natin kaagad ang sumusunod:

• hindi na kailangang magsulat ng semicolon sa dulo ng linya;
• lahat ng mga pamamaraan ay inilarawan ng masayang keyword ;
• Upang mag-print ng isang linya, sapat na ang isang salita - println() !

Paggawa ng Instance

// Java (до 10)
final Application application = new Application();

// Kotlin
val application = Application()

Mga pagkakaiba sa Kotlin:

• hindi na kailangang ideklara ang uri ng isang variable kung ito ay malinaw mula sa halimbawa;
• sa halip na ang uri ng variable - val (hindi nababago) o var (nababago);
• Hindi mo kailangang isulat ang bagong keyword upang lumikha ng isang instance !

Paglalarawan ng mga pamamaraan

// Java
public int sum(int a, int b) {
    return (a + b);
}

// Kotlin
fun sum(a: Int, b: Int): Int {
return (a + b)
}

Mga pagkakaiba sa Kotlin:

• kung may kailangang ibalik mula sa isang paraan, “ : Int ” ay idinaragdag sa lagda, kung saan ang Int ay ang uri ng pagbabalik;
• paglalarawan ng mga parameter ng pamamaraan: una ang variable na pangalan, pagkatapos ay ang uri;
• dahil ang katawan ng pamamaraan ay binubuo lamang ng isang linya, maaari mong alisin ang pagbabalik :
  

  fun sum(a: Int, b: Int): Int = (a+b)

Naka-format na output ng string

// Java
public int sum(int a, int b) {
    int result = (a + b);
    System.out.printf("Сумма %d и %d равна %d\n", a, b, result);
    return result;
}

// Kotlin
fun sum(a: Int, b: Int): Int {
    val result = (a + b)
    println("Сумма $a и $b равна $result")
    return result
}

Sinusuportahan ng Kotlin ang string interpolation, gamitin lang ang "$" na simbolo sa simula ng variable. Ang notasyong ito ay makabuluhang nagpapabuti sa kalinisan at pagiging madaling mabasa ng code. Paghahambing ng mga pagkakataon

// Java
object1.equals(object2)

// Kotlin
object1 == object2

Sa Kotlin, ang paghahambing na " ==" para sa mga uri ng bagay ay isinalin sa equals! At para ihambing ang mga link, " ===" ang ginagamit. Mga pagbubukod

// Java
public List<String> getFileContent(String file) throws IOException {
    Path path = Paths.get(file);
    return Files.readAllLines(path);
}

// Kotlin
fun getFileContent(file: String): List<String> {
    val path = Paths.get(file)
    return Files.readAllLines(path)
}

Walang mga naka-check na eksepsiyon sa Kotlin ; ngayon ay hindi mo na kailangang walang katapusang magtapon ng exception sa buong application o lumikha ng mga multi-level na exception try-catch. Null Safety

// Java
public class Data {
    String value;

    String render() {
        if (value == null) {
            return "Value: undefined";
        } else {
            return "Value:" + value.toUpperCase();
        }
    }
}

// Kotlin
class Data {
    var value: String? = null
    fun render(): String =
            "Value: ${value?.toUpperCase() ?: "undefined"}"
}

Inalagaan ni Kotlin ang problema sa NPE at ipinakilala ang ilang kinakailangan:

• lahat ng mga field at variable ng klase ay dapat na masimulan;
• Maaari mong isulat ang "null" sa isang field o variable, ngunit pagkatapos ay dapat mong tahasang sabihin na ang iyong variable ay Nullable (isulat ang "?" sign);
• элвис-оператор "?:" работает следующим образом: если слева Null, возьми то, что указано справа. В случае с нашим примером, когда переменная value не проинициализирована, возьмется meaning "undefined".

Поля класса и доступ к ним

// Java
public class Data {
    private String value;

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }
}
class App {
    void execute() {
           Data data = new Data()
           data.setValue("Foo")
     }
}

// Kotlin
class Data {
    var value: String = ""
}
class App {
    fun execute() {
          val data = Data()
          data.value = "Foo" // Под капотом выполнится data.set("Foo")
     }
}

В Kotlin достаточно просто описать поле и всё: у него уже есть неявные геттеры и сеттеры (привет lombok), которые при желании в любой момент можно переопределить. При этом читаем и модифицируем meaning поля просто обращаясь непосредственно к нему, а под капотом вызывается get()|set(). Циклы

// Java
void example() {
    for(int i = 1; i <= 10; i++) {
        System.out.println(i);
    }

    for(String line : "a,b,c".split(",")) {
        System.out.println(line);
    }
}

// Kotlin
fun example() {
    for(i in 1..10) {
        println(i)
    }

    for(line in "a,b,c".split(",")) {
        println(line)
    }
}

Kotlin предоставил удобный и единообразный синтаксис обхода последовательностей: ты просто используешь слева переменную, справа последовательность, а между ними — ключевое слово "in", тип определяется автоматически по содержимому. Синглтон

// Java
public class Singleton {
    private static Singleton ourInstance = new Singleton();

    public static Singleton getInstance() {
        return ourInstance;
    }

    private Singleton() {
    }
}
class App {
    void execute() {
         Singleton singleton = Singleton.getInstance()
    }
}

// Kotlin
object Singleton {}

class App {
    fun execute() {
          val singleton = Singleton
    }
}

Знакомый всем паттерн "одиночка" достаточно часто используется на практике, поэтому в Kotlin решor создать отдельное ключевое слово "object", которое пишется instead of "class" и означает, что класс является синглтоном, при использовании даже не нужно звать конструктор or Howие-либо другие методы! Именованные параметры методов и дефолтные значения

// Java
void setStatus(String code) {
    setStatus(code, "");
}

void setStatus(String code, String desc) {
    this.code = code;
    this.desc = desc;
}

// Kotlin
fun setStatus(code: String, desc: String = "") {
    this.code = code;
    this.desc = desc;
}

fun execute() {
    setStatus("200")
    setStatus(code = "200", desc = "Ok")
}

Случается такое, что не все параметры в методе or конструкторе должны быть обязательными, и в Java мы привыкли создавать набор методов or конструкторов под всевозможную комбинацию параметров. В Kotlin ввели дефолтные параметры, что позволяет объявить 1 метод и передавать в него необходимый набор параметров по ситуации. Стримы

// Java
String getFirst(List<String> strings, String alpha) {
    return strings.stream()
            .filter(x -> x.startsWith(alpha))
            .findFirst()
            .orElse("");
}

// Kotlin
fun getFirst(strings: List<String>, alpha: String): String {
    return strings.first { it.startsWith(alpha) }
}

Появившиеся stream в Java 8 стали неотъемлемым функционалом при работе с коллекциями. В Kotlin стримы сделали еще более удобными и функциональными: у каждой коллекции уже есть набор удобных частоиспользуемых методов для работы с данными. Кроме того, обрати внимание на лямбда выражение внутри метода first: если функциональный литерал имеет ровно один параметр, его объявление можно удалить (вместе с ->), и обращаться к нему по имени it. Пора бы закругляться... Я продемонстрировал лишь малую, базовую часть функционала, но, я уверен, тебе уже захотелось попробовать Kotlin! По своему опыту я могу сделать следующие выводы:

• Java разработчику очень легко освоить синтаксис Kotlin и начать писать code;
• у Kotlin полная совместимость с Java, и его уже можно пробовать в своих действующих проектах, например, в тестах;
• code на Kotlin чище и читабельнее, не нужно писать кучу бойлерплэйта;
• в IDEA есть автоматический конвертер Java в Kotlin, вы можете брать готовый Java-code и автоматически конвертировать его в Kotlin;
• новый проект нужно писать на Kotlin, так How с инфраструктурной точки зрения — это та же Java, а по использованию — лучше и удобнее!

Если статья понравилась и вообще уместна на ресурсе о Java, могу продолжить писать об опыте использования Kotlin в реальном энтерпрайзном проекте. Полезные ссылки:

• Попробовать написать что-либо на Kotlin в online
• Учим Kotlin - набор и описание разнообразных интерактивных примеров
• Плагин для IDEA для обучения с валидацией (такой mini-JavaRush)
• Официальный сайт Kotlin
• Русский сайт Kotlin