คอฟฟี่เบรค #37 อนาคตใหม่สำหรับ Java โอกาสของ JVM, Kotlin และ Java หลังจากปี 2020

แหล่งที่มา: Medium Java ได้รับการวิพากษ์วิจารณ์จากสองสิ่งหลัก: การใช้คำฟุ่มเฟือยและจำนวนโค้ดสำเร็จรูปที่สร้างขึ้นในหลายกรณีโดยไม่จำเป็นต้องชัดเจน แม้ว่าฉันจะชอบ Java มาโดยตลอด แต่ฉันไม่สามารถพูดได้ว่าข้อความเหล่านี้ผิด มันเป็นเรื่องจริง: รายละเอียดที่มากเกินไปใน Java บางครั้งอาจทำให้น่ารำคาญมาก อย่างไรก็ตาม เราต้องยอมรับว่าเราไม่ได้อยู่ในโลกอุดมคติ และในกรณีส่วนใหญ่ เราต้องเลือกความชั่วร้ายที่น้อยกว่าจากสองประการ นับตั้งแต่ก่อตั้ง Java ไม่ได้สมบูรณ์แบบ เราทุกคนรู้เรื่องนี้ แต่คำถามที่แท้จริงก็คือ เหตุใดจึงไม่ทำอะไรเลยมาก่อนเพื่อแก้ไขปัญหาเหล่านี้ ฉันคิดว่าเหตุผลเดียวที่การเปลี่ยนแปลงใช้เวลานานมากก็เพราะว่าภาษา Java ขาดการแข่งขันและสิ่งต่างๆ ก็เป็นเช่นนั้น Java ครองตลาด อาจเกิดจากการขาดคู่แข่งที่สำคัญและความพยายามอันยิ่งใหญ่ที่ทำโดย Sun ก่อนแล้วจึงทำโดย Oracle ความปลอดภัยประเภทระดับสูงที่ Java มอบให้และโครงสร้างภาษาที่ดีทำให้ได้รับความนิยมอย่างมากสำหรับโปรเจ็กต์ขนาดใหญ่ นอกจากนี้ยังเป็นภาษาหลายแพลตฟอร์มที่ทำงานบนเครื่องเสมือนของตัวเอง เมื่อรวมกับการเพิ่มประสิทธิภาพอัตโนมัติผ่านคอมไพเลอร์ JIT ทั้งหมดนี้ช่วยลดผลกระทบของโค้ดที่เขียนไม่ดี โดยรวมแล้ว นี่เป็นเหตุผลที่น่าสนใจมากในการใช้ Java แต่เกิดอะไรขึ้นต่อไป? สิ่งที่เกิดขึ้นคือมีภาษาใหม่ๆ เข้ามาในตลาด ที่สามารถรันใน JVM เดียวกันกับ Java ได้ ภาษาที่ขจัดความไม่สะดวกที่ใหญ่ที่สุดใน Java และในบางกรณีก็ทำให้นักพัฒนามีสภาพแวดล้อมที่น่าพึงพอใจมากขึ้นโดยมีอุปสรรคในการเข้าน้อยกว่า ก่อนที่เราจะดำเนินการต่อไป เรามาดูประวัติความเป็นมาของภาษา JVM กันก่อน

ประวัติความเป็นมาของภาษา JVM

ก่อนอื่น ฉันอยากจะชี้แจงสิ่งหนึ่งให้ชัดเจน: ฉันไม่ได้พูดถึงภาษา JVM บางภาษาที่มีอยู่ เนื่องจากไม่มีการสนับสนุนเพียงพอที่จะได้รับการพิจารณาให้เป็นตัวเลือกสำหรับการใช้งานอย่างแพร่หลายในอุตสาหกรรมของเรา เรามาเริ่มภาพรวมโดยย่อเกี่ยวกับประวัติความเป็นมาของภาษา JVM กัน ก่อนอื่น เราจะมี Java ซึ่งเป็นภาษาที่เก่าแก่และเป็นที่นิยมมากที่สุดในโลก JVM Java เปิดตัวอย่างเป็นทางการในเดือนมกราคม พ.ศ. 2539 ดังนั้นภาษาจึงมีมาเป็นเวลา 24 ปีแล้ว ไม่เลวใช่มั้ย? เดิมที Java เป็นภาษาที่จำเป็นอย่างยิ่งซึ่งเป็นไปตามรูปแบบการเขียนโปรแกรมเชิงวัตถุ มันเป็นภาษาที่พิมพ์ยากเช่นกัน ไวยากรณ์ของ Java ค่อนข้างคล้ายกับภาษา C++ และ C แต่ถือว่าเป็นเวอร์ชันที่ได้รับการปรับปรุง เนื่องจากการเขียนโค้ดใน Java นั้นง่ายกว่าใน C หรือ C++ มาก ในทางกลับกัน เรามีข้อโต้แย้งที่ใหญ่ที่สุดในหมู่ผู้ที่ว่าร้ายเขา - การใช้คำฟุ่มเฟือย ภาษา JVM ที่สองคือ Groovy มีมาตั้งแต่ปี 2546 แม้ว่าเวอร์ชันมาตรฐานแรก 1.0 จะปรากฏในเดือนมกราคม 2550 เท่านั้น ข้อดีของ Groovy คือสามารถใช้เป็นภาษาสคริปต์ได้ Groovy เป็นภาษาที่พิมพ์แบบไดนามิก ดังนั้นการตรวจสอบประเภทจึงเสร็จสิ้นที่รันไทม์ นี่เป็นหนึ่งในสาเหตุที่นักพัฒนาบางคนไม่ชอบ Groovy คุณเขียนโค้ดของคุณใน Groovy และดูเหมือนว่าถูกต้องในเวลาคอมไพล์ แต่เมื่อรันไทม์ คุณจะพบว่ามีบางอย่างผิดปกติ จากนั้นภาษายอดนิยมอีกภาษาหนึ่งก็ปรากฏขึ้น: เราพูดถึงสกาล่า เปิดตัวในปี 2547 เขานำรูปแบบการทำงานใหม่มาสู่โลกของ JVM: การเขียนโปรแกรมเชิงฟังก์ชันและแนวทางการประกาศ โดยพื้นฐานแล้ว สกาล่าเป็นภาษาแรกที่แนะนำแนวคิดเรื่องความไม่เปลี่ยนรูป ซึ่งต่อมาถูกนำมาใช้เพื่อปรับปรุง Java ในทางกลับกัน ผู้ว่าไม่ชอบสกาล่าเนื่องจากมีไวยากรณ์ที่ซับซ้อนและอ่านได้ค่อนข้างต่ำ ภาษาถัดไปที่โผล่ออกมาจากโลก JVM คือ Clojure ซึ่งเป็นภาษาที่ใช้งานได้ล้วนๆ ได้รับความนิยมค่อนข้างมากเมื่อเร็ว ๆ นี้ แม้ว่าจะปรากฏตัวในปี 2550 ก็ตาม Clojure เป็นภาษาที่ใช้ LISP ซึ่งโดดเด่นด้วยความเรียบง่ายและการใช้ฟังก์ชันที่เรียบง่าย ข้อเสียประการหนึ่งของมันคือการพิมพ์แบบไดนามิก (เช่น Groovy) และเส้นโค้งการเรียนรู้นั้นชันกว่ามากเนื่องจากไวยากรณ์ของมันแตกต่างอย่างสิ้นเชิงจากภาษา JVM อื่น ๆ และสุดท้ายเราก็มี Kotlin Kotlin ปรากฏตัวครั้งแรกในเดือนกุมภาพันธ์ 2559 และตั้งแต่นั้นมาความนิยมก็ไม่หยุดเติบโต ได้รับการพัฒนาโดย JetBrains โดยมีเป้าหมายหลัก: เพื่อแก้ไขปัญหา Java ที่มีชื่อเสียงที่สุด จากการออกแบบ Kotlin ยังคงรักษาข้อดีทั้งหมดของ Java ไว้ แต่ในขณะเดียวกันก็แก้ไขปัญหาได้หลายอย่าง ภาษาเหล่านี้เป็นภาษา JVM ที่สำคัญที่สุด อย่างที่ฉันบอกไป เราพลาดภาษาอื่น ๆ ที่ไม่ได้รับความนิยมมากนัก: Jython, JRuby, Ceylon, Fantom ฯลฯ หากต้องการ คุณสามารถค้นหารายการภาษา JVM ที่มี อยู่ทั้งหมดได้บนวิกิพีเดีย คุณคงทราบแล้วว่า Java ไม่มีการแข่งขันมากนักในช่วงแปดหรือสิบปีแรกหลังจากการสร้างขึ้น แต่สิ่งต่างๆ เปลี่ยนไปตั้งแต่นั้นมา การแข่งขันจะดีหรือไม่ดี?

ประโยชน์ของการเพิ่มการแข่งขัน

Java ไม่มีการเปลี่ยนแปลงมากนักในช่วงปีแรกๆ อาจเป็นเพราะมันไม่จำเป็น ภาษานี้มีการใช้กันอย่างแพร่หลายและได้รับความนิยมอย่างมากมาโดยตลอด แม้ว่าจะยังไม่สมบูรณ์แบบก็ตาม แต่แล้วคู่แข่งก็ปรากฏตัวขึ้น ภาษาที่ทันสมัยกว่าที่นำเสนอคุณสมบัติใหม่และแก้ไขปัญหาบางอย่างที่รบกวนนักพัฒนา Java มาเป็นเวลานาน ตัวอย่างเช่น มาดูภาษาสกาล่ากัน ความนิยมของ Scala เติบโตขึ้นมาตั้งแต่ปี 2009 นักพัฒนายินดีกับรูปแบบการทำงานใหม่นี้ ซึ่งทำให้พวกเขามีความยืดหยุ่นมากขึ้น รวมถึงความสามารถในการเขียนโค้ดคู่ขนานได้อย่างปลอดภัยและง่ายดาย Oracle ตอบสนองต่อเทรนด์ใหม่นี้อย่างไร ในปี 2014 Java Lambdas และ Streams ปรากฏขึ้น ฉันคิดว่าเราทุกคนเห็นพ้องต้องกันว่านี่คือตอนที่ Java ก้าวครั้งใหญ่ที่สุดในการเอาชนะ Scala ตอนนี้โปรแกรมเมอร์คนใดก็รู้ดีว่า Scala ไม่ทันสมัยอีกต่อไป ข้อดีอีกประการของการมีคู่แข่งมากขึ้นในโลก JVM คือการปรับปรุงอย่างต่อเนื่องกับคอมไพเลอร์ JIT และ JVM ขณะนี้ผู้คนจำนวนมากสนใจที่จะเพิ่มประสิทธิภาพ JVM และปรับปรุงประสิทธิภาพ การแข่งขันจึงดีสำหรับทุกคน! ทางเลือกล่าสุดสำหรับ Java คือภาษา Kotlin รูปร่างหน้าตาของมันมีความสำคัญมากสำหรับการพัฒนา Java เนื่องจากภาษาใหม่นั้นแสดงให้เห็นว่า Oracle ก้าวไปข้างหน้า ตัวอย่างของ Kotlin แสดงให้เห็นว่าเป็นไปได้ที่จะรักษาข้อดีของ Java ไว้ แต่สร้างภาษาที่กะทัดรัดมากขึ้นซึ่งเขียนโค้ดได้เร็วกว่า หากดูกราฟ Google Trends จะเห็นว่าตั้งแต่ปี 2559 ถึง 2561 ความนิยมของ Kotlin เพิ่มขึ้นอย่างรวดเร็ว แต่ในช่วงสองปีที่ผ่านมาความตื่นเต้นได้ลดลง Oracle ได้พิจารณาการตอบสนองของอุตสาหกรรมต่อ Kotlin อย่างใกล้ชิด หากคุณดูบันทึกประจำรุ่น JDK 15คุณจะเห็นว่าฟีเจอร์ Java ใหม่บางอย่างนั้นเป็นสำเนาของสิ่งที่มาใน Kotlin สิ่งเหล่านี้คือรายการ Java ใหม่บล็อกข้อความใหม่ (สตริงหลายบรรทัดที่มีเครื่องหมายคำพูดสามบรรทัด) และตัวดำเนินการใหม่switchซึ่งโดยพื้นฐานแล้วจะเป็นสำเนาของตัวดำเนินการwhenใน Kotlin ทุกสิ่งที่เราพูดถึงคือสิ่งที่ฉันเรียกว่า "Kotlinization of Java" ด้วยการเป็นคู่แข่งที่แข็งแกร่ง Kotlin ได้แสดงให้ Java เห็นเส้นทางที่ต้องเดินตาม

"Kotlinization" ของ Java

คุณลักษณะ Java ที่กำลังจะมีขึ้นบางส่วนจะได้รับการปรับปรุงอย่างมีนัยสำคัญในแง่ของความสามารถในการอ่าน และจะแก้ไขจุดอ่อนที่ใหญ่ที่สุดประการหนึ่งของภาษา Java นั่นคือการใช้คำฟุ่มเฟือย อาจมีคนแย้งว่าฟีเจอร์ Java ที่ประกาศไว้หลายอย่างมีความคล้ายคลึงกับฟีเจอร์ Kotlin บางอย่างอย่างน่าสงสัย แต่โปรดทราบว่าส่วนใหญ่เป็นเวอร์ชันก่อนเผยแพร่ ซึ่งหมายความว่าหากคุณติดตั้ง JDK 14 หรือ JDK 15 (เมื่อมีการเปิดตัว) คุณจะไม่สามารถใช้งานได้ตามค่าเริ่มต้น การแสดงตัวอย่างคุณลักษณะ Java เป็นคุณลักษณะใหม่ที่นำมาใช้ในรีลีส แต่ถูกปิดใช้งานตามค่าเริ่มต้น สิ่งเหล่านี้รวมอยู่ในเวอร์ชันใหม่เพื่อรวบรวมคำติชมจากชุมชนนักพัฒนาเท่านั้น ดังนั้นจึงอาจยังคงมีการเปลี่ยนแปลงได้ ด้วยเหตุนี้จึงไม่แนะนำให้ใช้ในโค้ดการผลิต หากต้องการเปิดใช้งานในเวลารวบรวม คุณจะต้องดำเนินการดังต่อไปนี้:

javac --enable-preview --release 14

หากคุณต้องการเปิดใช้งานในขณะรันไทม์ คุณจะต้องดำเนินการดังต่อไปนี้:

java --enable-preview YourClass

แน่นอน คุณยังสามารถเปิดใช้งานได้ใน IDE ของคุณ แต่ระวังอย่าเปิดใช้งานการแสดงตัวอย่างตามค่าเริ่มต้นในโปรเจ็กต์ใหม่ทั้งหมดของคุณ! มาดูการเปลี่ยนแปลงที่จะมีผลกระทบมากขึ้นต่อการเขียนโค้ดของเราใน Java เวอร์ชันต่อๆ ไป

จาวาโพสต์

Java Records เป็นคุณสมบัติที่พวกเราหลายคนเรียกร้องมาเป็นเวลานาน ฉันเดาว่าคุณพบว่าตัวเองอยู่ในสถานการณ์ที่คุณต้องใช้toString , hashCode เท่ากับและ getters สำหรับทุกฟิลด์ที่มีอยู่ Kotlin มีคลาสข้อมูล ที่จะแก้ไขปัญหานี้ และ Java ตั้งใจที่จะทำเช่นเดียวกันโดยปล่อยคลาสบันทึกที่ Scala มีอยู่แล้วในรูปแบบของคลาสเคส วัตถุประสงค์หลักของคลาสเหล่านี้คือการจัดเก็บข้อมูลที่ไม่เปลี่ยนรูปในวัตถุ ลองมาดูตัวอย่างเพื่อดูว่า Java จะดีกว่านี้ได้มากแค่ไหน นี่คือจำนวนโค้ดที่เราจะต้องเขียนเพื่อสร้างและเปรียบเทียบชั้นเรียนของเรา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 +
                '}';
    }
}

และยังมีวัตถุAddressที่ประกอบด้วย:

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 + '\'' +
                '}';
    }
}

อาจมีโค้ดมากเกินไปสำหรับบางสิ่งที่เรียบง่ายใช่ไหม ตอนนี้เรามาดูกันว่าสิ่งนี้จะมีลักษณะอย่างไรกับรายการ Java ใหม่:

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

และอย่าลืมคลาส Address:

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

นี่เป็นสิ่งเดียวกับที่เราเขียนไว้ก่อนหน้านี้โดยมีโค้ดมากมาย เห็นด้วย: นี่น่าทึ่งมาก และจำนวนโค้ดที่เราจะประหยัดได้ และความสะดวกในการเขียน! ตอนนี้เรามาดูกันว่าโอเปอเรเตอร์ใหม่มีความแตกต่างกันswitchอย่างไร

ผู้ประกอบการที่ได้รับการปรับปรุงswitch

โอเปอเรเตอร์ใหม่switchใน Java จะช่วยแก้ปัญหาเก่าบางส่วน รวมถึงข้อบกพร่องและการทำโค้ดซ้ำ ด้วยโอเปอเรเตอร์ใหม่switchปัญหานี้จะได้รับการแก้ไข เพื่ออธิบายสิ่งนี้ด้วยตัวอย่าง เราจะสร้าง enum DayOfTheWeekใน Java:

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

หลังจากนั้นเราswitchจะบอกเราว่าตำแหน่งใดในสัปดาห์ที่ตรงกับวันนั้น ก่อนอื่นเรามาดูกันว่าเราสามารถทำสิ่งนี้ได้อย่างไรในปัจจุบันโดยใช้ 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");

ด้วยคำสั่งปัจจุบันswitchเราจำเป็นต้องใช้ตัวแปร และหากเราพลาดวันใดวันหนึ่งในสัปดาห์ โค้ดของเราจะคอมไพล์ได้ตามปกติ นี่เป็นหนึ่งในปัญหาของผู้ปฏิบัติงานswitch: พวกมันมีแนวโน้มที่จะเกิดข้อผิดพลาดได้ง่ายเกินไป Java 14 ปรับปรุงสิ่งต่าง ๆ ได้อย่างไร? มาดูกันดีกว่า:

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");

ดังที่คุณเห็นแล้วว่า ตัวดำเนินการใหม่switchสามารถใช้เป็นนิพจน์ได้ ไม่ใช่เป็นเพียงคำสั่งเท่านั้น ผลลัพธ์ที่ได้จะกระชับและแสดงออกมากขึ้น นี่จะเพียงพอที่จะโน้มน้าวใจพวกเราหลายคนให้ใช้มัน แต่การปรับปรุงที่สำคัญประการหนึ่งคือ ในตอนนี้งบต่างๆswitchจะไม่ถูกรวบรวม เว้นแต่เราจะครอบคลุมทุกกรณีในswitch. มันจะแสดงข้อผิดพลาดนี้ให้เราทราบ เช่น:

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

จากนี้ไป จะไม่สามารถข้ามกรณีในโอเปอเรเตอร์ของเราswitchได้ สิ่งนี้คล้ายกับโอเปอเรเตอร์whenใน Kotlin มาก ซึ่งคุณสามารถอ่านได้ในเอกสารประกอบ เรามาดูบล็อกข้อความใหม่กันดีกว่า

บล็อกข้อความ

คุณเคยบ่นบ้างไหมว่าการกำหนด JSON blob ให้กับตัวแปรใน Java นั้นยากแค่ไหน? Java มีลำดับหลายบรรทัดที่คุณสามารถอธิบายได้โดยการใส่เครื่องหมายคำพูดสามบรรทัด เมื่อฟีเจอร์นี้เปิดตัวอย่างเป็นทางการแล้ว การอธิบายลำดับยาวๆ บนหลายบรรทัดจะง่ายขึ้นมาก มาดูความแตกต่างระหว่างสองโหมดกัน หากเราต้องการใช้ JSON ที่จัดรูปแบบแล้วในตัวแปร ผลลัพธ์ที่ได้จะออกมาไม่ดี:

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" +
                "}} ";

ในทางกลับกัน เมื่อมีการเปิดตัวบล็อกข้อความใหม่ ทุกอย่างจะง่ายขึ้นมาก:

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;"
                    }
                }}
                """;

นี่ดูดีขึ้นแน่นอน ทั้งหมด นี้ ได้รับการ รองรับแล้วใน Kotlin ดังที่คุณเห็นในคำจำกัดความประเภท ดังนั้นเราจึงเห็นว่า Java "สืบทอด" วิธีแก้ปัญหามากมายจากคู่แข่งรายหนึ่ง: Kotlin เราไม่รู้ว่า Oracle ตอบสนองทันเวลาเพื่อต่อสู้กับการเพิ่มขึ้นของ Kotlin หรือว่ามันสายเกินไป โดยส่วนตัวแล้ว ฉันเชื่อว่า Java กำลังก้าวไปข้างหน้าอย่างถูกต้อง แม้ว่าการเปลี่ยนแปลงเหล่านี้จะริเริ่มโดยคู่แข่งและอาจมาพร้อมกับความล่าช้าบ้างก็ตาม

บทสรุป

ฉันคิดว่าการแข่งขันเป็นสิ่งที่ดีที่สุดที่เคยเกิดขึ้นกับภาษาจาวา ความประทับใจของฉันคือไม่อย่างนั้น Java ก็จะเหลือแต่เกียรติยศของมัน นอกจากนี้ คู่แข่งของ Java ยังแสดงให้เห็นว่ามีวิธีการเขียนโปรแกรมที่แตกต่างออกไป โดยแสดงวิธีก้าวไปข้างหน้าและหลีกเลี่ยงวิธีการเขียนโค้ดที่ล้าสมัยและไม่มีประสิทธิภาพ การเปลี่ยนแปลงในอนาคตจะทำให้ Java มีประสิทธิภาพมากขึ้นกว่าเดิม ภาษาที่ปรับให้เข้ากับยุคสมัยใหม่ ภาษาที่ต้องการพัฒนา