แหล่งที่มา: Medium Java ได้รับการวิพากษ์วิจารณ์จากสองสิ่งหลัก: การใช้คำฟุ่มเฟือยและจำนวนโค้ดสำเร็จรูปที่สร้างขึ้นในหลายกรณีโดยไม่จำเป็นต้องชัดเจน แม้ว่าฉันจะชอบ Java มาโดยตลอด แต่ฉันไม่สามารถพูดได้ว่าข้อความเหล่านี้ผิด มันเป็นเรื่องจริง: รายละเอียดที่มากเกินไปใน Java บางครั้งอาจทำให้น่ารำคาญมาก อย่างไรก็ตาม เราต้องยอมรับว่าเราไม่ได้อยู่ในโลกอุดมคติ และในกรณีส่วนใหญ่ เราต้องเลือกความชั่วร้ายที่น้อยกว่าจากสองประการ
นับตั้งแต่ก่อตั้ง Java ไม่ได้สมบูรณ์แบบ เราทุกคนรู้เรื่องนี้ แต่คำถามที่แท้จริงก็คือ เหตุใดจึงไม่ทำอะไรเลยมาก่อนเพื่อแก้ไขปัญหาเหล่านี้ ฉันคิดว่าเหตุผลเดียวที่การเปลี่ยนแปลงใช้เวลานานมากก็เพราะว่าภาษา Java ขาดการแข่งขันและสิ่งต่างๆ ก็เป็นเช่นนั้น Java ครองตลาด อาจเกิดจากการขาดคู่แข่งที่สำคัญและความพยายามอันยิ่งใหญ่ที่ทำโดย Sun ก่อนแล้วจึงทำโดย Oracle ความปลอดภัยประเภทระดับสูงที่ Java มอบให้และโครงสร้างภาษาที่ดีทำให้ได้รับความนิยมอย่างมากสำหรับโปรเจ็กต์ขนาดใหญ่ นอกจากนี้ยังเป็นภาษาหลายแพลตฟอร์มที่ทำงานบนเครื่องเสมือนของตัวเอง เมื่อรวมกับการเพิ่มประสิทธิภาพอัตโนมัติผ่านคอมไพเลอร์ JIT ทั้งหมดนี้ช่วยลดผลกระทบของโค้ดที่เขียนไม่ดี โดยรวมแล้ว นี่เป็นเหตุผลที่น่าสนใจมากในการใช้ Java แต่เกิดอะไรขึ้นต่อไป? สิ่งที่เกิดขึ้นคือมีภาษาใหม่ๆ เข้ามาในตลาด ที่สามารถรันใน JVM เดียวกันกับ Java ได้ ภาษาที่ขจัดความไม่สะดวกที่ใหญ่ที่สุดใน Java และในบางกรณีก็ทำให้นักพัฒนามีสภาพแวดล้อมที่น่าพึงพอใจมากขึ้นโดยมีอุปสรรคในการเข้าน้อยกว่า ก่อนที่เราจะดำเนินการต่อไป เรามาดูประวัติความเป็นมาของภาษา JVM กันก่อน
ข้อดีอีกประการของการมีคู่แข่งมากขึ้นในโลก JVM คือการปรับปรุงอย่างต่อเนื่องกับคอมไพเลอร์ JIT และ JVM ขณะนี้ผู้คนจำนวนมากสนใจที่จะเพิ่มประสิทธิภาพ JVM และปรับปรุงประสิทธิภาพ การแข่งขันจึงดีสำหรับทุกคน! ทางเลือกล่าสุดสำหรับ Java คือภาษา Kotlin รูปร่างหน้าตาของมันมีความสำคัญมากสำหรับการพัฒนา Java เนื่องจากภาษาใหม่นั้นแสดงให้เห็นว่า Oracle ก้าวไปข้างหน้า ตัวอย่างของ Kotlin แสดงให้เห็นว่าเป็นไปได้ที่จะรักษาข้อดีของ Java ไว้ แต่สร้างภาษาที่กะทัดรัดมากขึ้นซึ่งเขียนโค้ดได้เร็วกว่า หากดูกราฟ Google Trends จะเห็นว่าตั้งแต่ปี 2559 ถึง 2561 ความนิยมของ Kotlin เพิ่มขึ้นอย่างรวดเร็ว แต่ในช่วงสองปีที่ผ่านมาความตื่นเต้นได้ลดลง
Oracle ได้พิจารณาการตอบสนองของอุตสาหกรรมต่อ Kotlin อย่างใกล้ชิด หากคุณดูบันทึกประจำรุ่น JDK 15คุณจะเห็นว่าฟีเจอร์ Java ใหม่บางอย่างนั้นเป็นสำเนาของสิ่งที่มาใน Kotlin สิ่งเหล่านี้คือรายการ Java ใหม่บล็อกข้อความใหม่ (สตริงหลายบรรทัดที่มีเครื่องหมายคำพูดสามบรรทัด) และตัวดำเนินการใหม่ผู้ประกอบการที่ได้รับการปรับปรุง
โอเปอเรเตอร์ใหม่
![คอฟฟี่เบรค #37 อนาคตใหม่สำหรับ Java โอกาสของ JVM, Kotlin และ Java หลังปี 2020 - 1](https://cdn.javarush.com/images/article/583e2f7e-fc61-4c4b-a3fc-51b2748a45e8/800.jpeg)
ประวัติความเป็นมาของภาษา 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 ไม่ทันสมัยอีกต่อไป![คอฟฟี่เบรค #37 อนาคตใหม่สำหรับ Java โอกาสของ JVM, Kotlin และ Java หลังปี 2020 - 2](https://cdn.javarush.com/images/article/280d9da4-bb5d-41ff-b4c1-8e187bd02432/800.jpeg)
![คอฟฟี่เบรค #37 อนาคตใหม่สำหรับ Java โอกาสของ JVM, Kotlin และ Java หลังปี 2020 - 3](https://cdn.javarush.com/images/article/50d8c671-8167-44e5-9439-6f0ff10abbf2/800.jpeg)
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 กำลังก้าวไปข้างหน้าอย่างถูกต้อง แม้ว่าการเปลี่ยนแปลงเหล่านี้จะริเริ่มโดยคู่แข่งและอาจมาพร้อมกับความล่าช้าบ้างก็ตาม
GO TO FULL VERSION