Rehat kopi #37. Masa depan baru untuk Java. Prospek JVM, Kotlin dan Java selepas 2020

Sumber: Medium Java terutamanya dikritik kerana dua perkara: verbosity dan jumlah kod boilerplate yang dijana dalam banyak kes tanpa keperluan yang jelas. Walaupun saya sentiasa menyukai Java, saya tidak boleh mengatakan bahawa kenyataan ini salah. Memang benar: perincian yang berlebihan dalam Java kadangkala boleh menjadi sangat menjengkelkan. Walau bagaimanapun, kita mesti mengakui bahawa kita tidak hidup dalam dunia yang ideal, dan dalam kebanyakan kes kita perlu memilih yang lebih kecil daripada dua kejahatan. Sejak penubuhannya, Java tidak sempurna: kita semua tahu ini, tetapi persoalan sebenar ialah mengapa tiada apa yang dilakukan sebelum ini untuk menyelesaikan masalah ini. Saya rasa satu-satunya sebab perubahan itu mengambil masa yang lama adalah kerana bahasa Jawa tidak mempunyai persaingan dan keadaan adalah seperti biasa. Java mendominasi pasaran, mungkin disebabkan oleh kekurangan pesaing yang serius dan usaha hebat yang dibuat pertama kali oleh Sun dan kemudian oleh Oracle. Tahap keselamatan jenis yang tinggi yang disediakan oleh Java dan penstrukturan bahasa yang baik telah menjadikannya sangat popular untuk projek besar. Di samping itu, ia adalah bahasa berbilang platform yang berjalan pada mesin mayanya sendiri. Digabungkan dengan pengoptimuman prestasi automatik melalui pengkompil JIT, semua ini meminimumkan kesan kod yang ditulis dengan buruk. Secara keseluruhannya, ini adalah satu set sebab yang cukup menarik untuk menggunakan Java. Tetapi apa yang berlaku seterusnya? Apa yang telah berlaku ialah bahasa baharu telah datang ke pasaran yang boleh dijalankan dalam JVM yang sama seperti Java. Bahasa yang menghapuskan beberapa kesulitan terbesar di Jawa dan, dalam beberapa kes, menawarkan pembangun persekitaran yang lebih menyenangkan dengan halangan yang lebih rendah untuk masuk. Sebelum kita meneruskan, mari kita semak dan lihat secara ringkas sejarah bahasa JVM.

Sejarah bahasa JVM

Pertama, saya ingin menjelaskan satu perkara: Saya tidak menyebut beberapa bahasa JVM sedia ada kerana mereka tidak pernah mendapat sokongan yang mencukupi untuk dianggap sebagai calon untuk kegunaan meluas dalam industri kami. Sekarang mari kita mulakan gambaran ringkas tentang sejarah bahasa JVM. Mula-mula kita akan mempunyai Java, bahasa tertua dan paling popular di dunia JVM. Java dikeluarkan secara rasmi pada Januari 1996, jadi bahasa itu telah wujud selama 24 tahun. Tidak buruk, bukan? Java pada asalnya adalah bahasa imperatif semata-mata yang mengikuti gaya pengaturcaraan berorientasikan objek; ia juga merupakan bahasa yang ditaip dengan kuat. Sintaks Java agak serupa dengan bahasa C++ dan C, tetapi ia dianggap sebagai versi yang lebih baik kerana menulis kod dalam Java adalah lebih mudah daripada dalam C atau C++. Sebaliknya, kita mempunyai hujah terbesar di kalangan pengkritiknya - keterlaluan. Bahasa JVM kedua ialah Groovy. Ia telah wujud sejak 2003, walaupun versi piawai pertamanya, 1.0, hanya muncul pada Januari 2007. Kelebihan Groovy ialah ia boleh digunakan sebagai bahasa skrip. Groovy ialah bahasa yang ditaip secara dinamik, jadi pemeriksaan jenis dilakukan pada masa jalan. Ini adalah salah satu sebab mengapa sesetengah pembangun tidak menyukai Groovy. Anda menulis kod anda dalam Groovy dan ia kelihatan betul pada masa penyusunan, tetapi kemudian pada masa jalan anda menyedari ada sesuatu yang tidak kena. Kemudian satu lagi bahasa popular muncul: kita bercakap tentang Scala. Ia dikeluarkan pada tahun 2004. Beliau membawa model kerja baharu ke dunia JVM: pengaturcaraan berfungsi dan pendekatan deklaratif. Pada asasnya, Scala adalah bahasa pertama yang memperkenalkan konsep kebolehubah, yang kemudiannya digunakan untuk meningkatkan Java. Sebaliknya, pengkritik tidak menyukai Scala kerana tatabahasanya yang kompleks dan kebolehbacaan yang agak rendah. Bahasa seterusnya yang muncul dari dunia JVM ialah Clojure, bahasa yang berfungsi semata-mata. Ia telah menjadi agak popular baru-baru ini, walaupun ia muncul pada tahun 2007. Clojure ialah bahasa berasaskan LISP yang dicirikan oleh kesederhanaan dan penggunaan fungsi mudahnya. Antara kelemahannya ialah ia ditaip secara dinamik (seperti Groovy) dan keluk pembelajaran adalah lebih curam kerana sintaksnya berbeza sama sekali daripada bahasa JVM yang lain. Dan akhirnya, kami mempunyai Kotlin. Kotlin pertama kali muncul pada Februari 2016, dan sejak itu popularitinya tidak berhenti berkembang. Ia dibangunkan oleh JetBrains dengan matlamat utama: untuk menyelesaikan masalah Java yang paling terkenal. Dengan reka bentuk, Kotlin mengekalkan semua kelebihan Java, tetapi pada masa yang sama menyelesaikan banyak masalah. Ini adalah bahasa JVM yang paling penting. Seperti yang saya katakan, kami terlepas beberapa bahasa lain yang tidak begitu popular: Jython, JRuby, Ceylon, Fantom, dll. Jika anda mahu, anda boleh mengetahui keseluruhan senarai bahasa JVM sedia adadi Wikipedia. Anda mungkin telah menyedari bahawa Java tidak mempunyai banyak persaingan dalam lapan atau sepuluh tahun pertama selepas penciptaannya, tetapi keadaan telah berubah sejak itu. Jadi, adakah persaingan baik atau buruk?

Faedah Meningkatkan Persaingan

Java tidak banyak berubah pada tahun-tahun awalnya. Mungkin kerana ia tidak perlu. Bahasa ini telah digunakan secara meluas dan sentiasa menjadi sangat popular, walaupun pada hakikatnya ia jauh dari sempurna. Tetapi kemudian pesaing muncul, bahasa yang lebih moden yang menawarkan ciri-ciri baru dan menyelesaikan beberapa masalah yang telah melanda pembangun Java untuk masa yang lama. Sebagai contoh, mari kita lihat bahasa Scala. Populariti Scala telah berkembang sejak 2009. Pembangun mengalu-alukan gaya fungsi baharu ini, yang memberikan mereka lebih fleksibiliti serta keupayaan untuk menulis kod selari dengan selamat dan mudah. Bagaimanakah Oracle bertindak balas terhadap trend baharu ini? Pada tahun 2014, Java Lambdas dan Streams muncul. Saya rasa kita semua boleh bersetuju bahawa ini adalah ketika Java mengambil langkah terbesar ke arah mengalahkan Scala. Sekarang mana-mana pengaturcara tahu bahawa Scala tidak lagi bergaya. Faedah lain untuk mempunyai lebih banyak pesaing dalam dunia JVM ialah penambahbaikan berterusan dibuat pada pengkompil JIT dan JVM. Kini lebih ramai orang berminat untuk mengoptimumkan JVM dan meningkatkan prestasi. Jadi persaingan adalah baik untuk semua orang! Alternatif terkini untuk Java ialah bahasa Kotlin. Penampilannya sangat penting untuk pembangunan Java, kerana bahasa baru, dalam erti kata lain, menunjukkan Oracle jalan ke hadapan. Contoh Kotlin menunjukkan bahawa adalah mungkin untuk mengekalkan kelebihan Java, tetapi mencipta bahasa yang lebih padat di mana ia lebih pantas untuk menulis kod. Jika anda melihat graf Google Trends, anda dapat melihat bahawa dari 2016 hingga 2018, populariti Kotlin berkembang pesat. Tetapi sejak dua tahun kebelakangan ini keterujaan telah menurun. Oracle telah melihat dengan teliti tindak balas industri terhadap Kotlin. Jika anda melihat nota keluaran JDK 15 , anda akan melihat bahawa beberapa ciri Java baharu adalah salinan daripada apa yang terdapat dalam Kotlin. Ini ialah entri Java baharu , blok teks baharu (rentetan berbilang baris dengan petikan tiga) dan operator baharu switch, yang pada asasnya ialah salinan operator whendalam Kotlin. Semua yang kami bincangkan adalah apa yang saya panggil "Kotlinisasi Java." Dengan menjadi pesaing yang lebih kuat, Kotlin menunjukkan Java jalan untuk diikuti.

"Kotlinisasi" Java

Beberapa ciri Java yang akan datang akan menjadi penambahbaikan yang ketara dari segi kebolehbacaan dan akan menangani salah satu kelemahan terbesar bahasa Java - verbositinya. Seseorang boleh berhujah bahawa banyak ciri Java yang diumumkan adalah serupa dengan beberapa ciri Kotlin. Tetapi sila ambil perhatian bahawa kebanyakannya adalah versi pra-keluaran . Ini bermakna jika anda memasang JDK 14 atau JDK 15 (apabila ia dikeluarkan), anda tidak akan dapat menggunakannya secara lalai. Pratonton ciri Java ialah ciri baharu yang diperkenalkan dalam keluaran tetapi dilumpuhkan secara lalai. Mereka disertakan dalam versi baharu hanya untuk mengumpulkan maklum balas daripada komuniti pembangun, jadi mereka mungkin masih tertakluk kepada perubahan. Inilah sebabnya mengapa tidak disyorkan untuk menggunakannya dalam kod pengeluaran. Untuk membolehkannya pada masa penyusunan, anda perlu melakukan perkara berikut:

javac --enable-preview --release 14

Jika anda ingin mendayakannya semasa runtime, anda perlu menjalankan perkara berikut:

java --enable-preview YourClass

Sudah tentu, anda juga boleh mendayakannya dalam IDE anda, tetapi berhati-hati untuk tidak mendayakan pratonton secara lalai dalam semua projek baharu anda! Mari kita lihat perubahan yang akan memberi kesan yang lebih besar pada pengekodan kami dalam versi Java masa hadapan.

Java Posts

Java Records adalah ciri yang ramai di antara kita telah lama merayu. Saya rasa anda telah mendapati diri anda berada dalam situasi di mana anda perlu melaksanakan toString , hashCode , equals , serta getter untuk setiap medan sedia ada. Kotlin mempunyai kelas data untuk menyelesaikan masalah ini , dan Java berhasrat untuk melakukan perkara yang sama dengan mengeluarkan kelas rekod yang Scala sudah ada dalam bentuk kelas kes . Tujuan utama kelas ini adalah untuk menyimpan data tidak berubah dalam objek. Mari kita ambil contoh untuk melihat sejauh mana Java boleh menjadi lebih baik. Ini ialah jumlah kod yang perlu kita tulis untuk mencipta dan membandingkan kelas kita Employee:

package com.theboreddev.java14;

import java.util.Objects;

public class Employee {
    private final String firstName;
    private final String surname;
    private final int age;
    private final Address address;
    private final double salary;

    public Employee(String firstName, String surname, int age, Address address, double salary) {
        this.firstName = firstName;
        this.surname = surname;
        this.age = age;
        this.address = address;
        this.salary = salary;
    }

    public String getFirstName() {
        return firstName;
    }

    public String getSurname() {
        return surname;
    }

    public int getAge() {
        return age;
    }

    public Address getAddress() {
        return address;
    }

    public double getSalary() {
        return salary;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Employee employee = (Employee) o;
        return age == employee.age &&
                Double.compare(employee.salary, salary) == 0 &&
                Objects.equals(firstName, employee.firstName) &&
                Objects.equals(surname, employee.surname) &&
                Objects.equals(address, employee.address);
    }

    @Override
    public int hashCode() {
        return Objects.hash(firstName, surname, age, address, salary);
    }

    @Override
    public String toString() {
        return "Employee{" +
                "firstName='" + firstName + '\'' +
                ", surname='" + surname + '\'' +
                ", age=" + age +
                ", address=" + address +
                ", salary=" + salary +
                '}';
    }
}

Dan juga objek Addressyang terkandung di dalamnya:

import java.util.Objects;

public class Address {
    private final String firstLine;
    private final String secondLine;
    private final String postCode;

    public Address(String firstLine, String secondLine, String postCode) {
        this.firstLine = firstLine;
        this.secondLine = secondLine;
        this.postCode = postCode;
    }

    public String getFirstLine() {
        return firstLine;
    }

    public String getSecondLine() {
        return secondLine;
    }

    public String getPostCode() {
        return postCode;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Address address = (Address) o;
        return Objects.equals(firstLine, address.firstLine) &&
                Objects.equals(secondLine, address.secondLine) &&
                Objects.equals(postCode, address.postCode);
    }

    @Override
    public int hashCode() {
        return Objects.hash(firstLine, secondLine, postCode);
    }

    @Override
    public String toString() {
        return "Address{" +
                "firstLine='" + firstLine + '\'' +
                ", secondLine='" + secondLine + '\'' +
                ", postCode='" + postCode + '\'' +
                '}';
    }
}

Mungkin terdapat terlalu banyak kod untuk sesuatu yang begitu mudah, bukan? Sekarang mari kita lihat bagaimana ini akan kelihatan dengan entri Java baharu:

public record EmployeeRecord(String firstName, String surname, int age, AddressRecord address, double salary) {
}

Dan jangan lupa kelas Alamat:

public record AddressRecord(String firstLine, String secondLine, String postCode) {
}

Ini adalah perkara yang sama yang kami tulis sebelum ini dengan begitu banyak kod. Setuju: ini menakjubkan. Dan jumlah kod yang akan kami simpan, dan kemudahan menulis! Sekarang mari kita lihat apakah perbezaannya dengan pengendali baharu switch.

Operator yang Diperbaikiswitch

Pengendali baharu switchdi Java akan menyelesaikan beberapa masalah lama, termasuk beberapa pepijat dan pertindihan kod. Dengan pengendali baharu switchmasalah ini akan diselesaikan. Untuk menjelaskan ini dengan contoh, kami akan membuat enum DayOfTheWeekdi Jawa:

public enum DayOfTheWeek {
    MONDAY,
    TUESDAY,
    WEDNESDAY,
    THURSDAY,
    FRIDAY,
    SATURDAY,
    SUNDAY
}

Selepas itu, kami switchakan memberitahu kami kedudukan mana dalam minggu yang sepadan dengan hari itu. Mari kita lihat bagaimana kita boleh melakukan ini pada masa ini menggunakan Java 11.

final DayOfTheWeek dayOfTheWeek = DayOfTheWeek.THURSDAY;

        int position = 0;

        switch (dayOfTheWeek) {
            case MONDAY:
                position = 1;
                break;
            case TUESDAY:
                position = 2;
                break;
            case WEDNESDAY:
                position = 3;
                break;
            case THURSDAY:
                position = 4;
                break;
            case FRIDAY:
                position = 5;
                break;
            case SATURDAY:
                position = 6;
                break;
            case SUNDAY:
                position = 7;
                break;
        }

        System.out.println("Day " + dayOfTheWeek + " is in position " + position + " of the week");

Dengan pernyataan semasa, switchkami perlu menggunakan pembolehubah, dan jika kami terlepas salah satu hari dalam seminggu, kod kami akan disusun dengan baik. Ini adalah salah satu masalah dengan pengendali switch: mereka terlalu terdedah kepada ralat. Jadi bagaimana Java 14 menambah baik perkara? Mari lihat:

final DayOfTheWeek dayOfTheWeek = DayOfTheWeek.THURSDAY;

        int position = switch (dayOfTheWeek) {
            case MONDAY -> 1;
            case TUESDAY -> 2;
            case WEDNESDAY -> 3;
            case THURSDAY -> 4;
            case FRIDAY -> 5;
            case SATURDAY -> 6;
            case SUNDAY -> 7;
        };

        System.out.println("Day " + dayOfTheWeek + " is in position " + position + " of the week");

Seperti yang anda lihat, pengendali baharu switchboleh digunakan sebagai ungkapan, bukan hanya sebagai pernyataan. Hasilnya lebih ringkas dan ekspresif. Ini sudah cukup untuk meyakinkan ramai daripada kita untuk menggunakannya, tetapi salah satu penambahbaikan utama ialah kini kenyataan itu switchtidak akan disusun melainkan kita meliputi semua kes dalam switch. Ia akan menunjukkan kepada kami ralat ini, sebagai contoh:

Error:(9, 24) java: the switch expression does not cover all possible input values

Mulai sekarang, mustahil untuk melangkau kes dalam pengendali kami switch. Ini sangat serupa dengan pengendali whendalam Kotlin, yang boleh anda baca dalam dokumentasi . Mari kita lihat juga blok teks baharu.

Blok teks

Pernahkah anda merungut tentang betapa sukarnya untuk memberikan gumpalan JSON kepada pembolehubah dalam Java? Java mempunyai jujukan berbilang baris yang boleh anda huraikan dengan melampirkannya dalam petikan tiga kali ganda. Sebaik sahaja ciri ini dikeluarkan secara rasmi, ia akan menjadi lebih mudah untuk menerangkan urutan panjang pada berbilang baris. Mari lihat perbezaan antara kedua-dua mod. Jika kita mahu menggunakan JSON yang diformatkan dalam pembolehubah, ternyata buruk:

final String text = "{\"widget\": {\n" +
                "    \"debug\": \"on\",\n" +
                "    \"window\": {\n" +
                "        \"title\": \"Sample Konfabulator Widget\",\n" +
                "        \"name\": \"main_window\",\n" +
                "        \"width\": 500,\n" +
                "        \"height\": 500\n" +
                "    },\n" +
                "    \"image\": { \n" +
                "        \"src\": \"Images/Sun.png\",\n" +
                "        \"name\": \"sun1\",\n" +
                "        \"hOffset\": 250,\n" +
                "        \"vOffset\": 250,\n" +
                "        \"alignment\": \"center\"\n" +
                "    },\n" +
                "    \"text\": {\n" +
                "        \"data\": \"Click Here\",\n" +
                "        \"size\": 36,\n" +
                "        \"style\": \"bold\",\n" +
                "        \"name\": \"text1\",\n" +
                "        \"hOffset\": 250,\n" +
                "        \"vOffset\": 100,\n" +
                "        \"alignment\": \"center\",\n" +
                "        \"onMouseUp\": \"sun1.opacity = (sun1.opacity / 100) * 90;\"\n" +
                "    }\n" +
                "}} ";

Sebaliknya, apabila blok teks baharu dikeluarkan, semuanya akan menjadi lebih mudah:

final String multiLineText = """
                {"widget": {
                    "debug": "on",
                    "window": {
                        "title": "Sample Konfabulator Widget",
                        "name": "main_window",
                        "width": 500,
                        "height": 500
                    },
                    "image": {\s
                        "src": "Images/Sun.png",
                        "name": "sun1",
                        "hOffset": 250,
                        "vOffset": 250,
                        "alignment": "center"
                    },
                    "text": {
                        "data": "Click Here",
                        "size": 36,
                        "style": "bold",
                        "name": "text1",
                        "hOffset": 250,
                        "vOffset": 100,
                        "alignment": "center",
                        "onMouseUp": "sun1.opacity = (sun1.opacity / 100) * 90;"
                    }
                }}
                """;

Ini pasti kelihatan lebih baik. Semua ini sudah disokong dalam Kotlin, seperti yang anda boleh lihat dalam definisi jenisnya . Jadi kita telah melihat bahawa Java "mewarisi" banyak penyelesaian kepada masalahnya sendiri daripada salah satu pesaingnya: Kotlin. Kami tidak tahu sama ada Oracle bertindak balas tepat pada masanya untuk memerangi kebangkitan Kotlin atau ia datang terlambat. Secara peribadi, saya percaya bahawa Java sedang membuat langkah yang betul ke hadapan, walaupun perubahan ini entah bagaimana dimulakan oleh pesaingnya dan mungkin datang dengan sedikit kelewatan.

Kesimpulan

Saya fikir persaingan adalah perkara terbaik yang pernah berlaku kepada bahasa Jawa. Tanggapan saya ialah jika tidak Java akan berpuas hati dengan kejayaannya. Selain itu, pesaing Java telah menunjukkan bahawa cara pengaturcaraan yang berbeza mungkin, menunjukkan cara untuk bergerak ke hadapan dan mengelakkan cara menulis kod yang lapuk dan tidak cekap. Perubahan masa depan akan menjadikan Java lebih berkuasa daripada sebelumnya, bahasa yang disesuaikan dengan era moden, bahasa yang ingin berkembang.