成人免费xxxxx在线视频软件_久久精品久久久_亚洲国产精品久久久_天天色天天色_亚洲人成一区_欧美一级欧美三级在线观看

Java 的新未來：逐漸“Kotlin 化”

作者：The Bored Dev
新聞 前端
來自不同編程語言的競爭正促使 Java 不斷吸收新特性，變得更能適應(yīng)時代和開發(fā)人員的新需求。

來自不同編程語言的競爭正促使 Java 不斷吸收新特性，變得更能適應(yīng)時代和開發(fā)人員的新需求。

我們行業(yè)始終有一個熱門話題，那就是對 Java 的批判，這種批判很大程度上來源于 Java 的繁瑣性以及它所生成的大量樣板式代碼，而這些代碼在很多場景下是根本不需要的。

雖然我一直以來都很喜歡 Java，但是我不能說這些指責(zé)是錯誤的。的確，Java 的繁瑣性以及數(shù)量不菲的雜亂代碼在很多情況下會很煩人。在大多數(shù)情況下，我們不得不接受我們生活在一個不完美的世界這一現(xiàn)實，很多時候，我們必須兩害相權(quán)取其輕。我們都知道，Java 并不完美，但是主要的問題在于在此之前為什么沒有采取任何措施來解決這些問題呢？

我認(rèn)為，變更需要耗費這么長時間的唯一原因就是 Java 缺乏足夠的競爭。Java 語言之所以能夠主導(dǎo)市場，可能就是因為缺乏真正的競爭對手，當(dāng)然也要歸功于 Sun 和 Oracle 先后做出的巨大努力。

Java 提供的強類型安全性，以及作為一個結(jié)構(gòu)良好的語言所帶來的其他特性，使其成為大型項目中非常流行的語言。通過使用 Java，我們很少會讓事情變得難以收拾。Java 的另外一個重要特點是作為多平臺語言，它運行在自己的虛擬機上，這使其能夠完美契合很多的組織。如果你通過著名的 JIT 編譯器啟用了其自動性能優(yōu)化的固有能力，那么在很多情況下都能將糟糕代碼所帶來的影響最小化，這樣我們就有了一組使用 Java 的堅實理由。

但是，后來發(fā)生了什么呢？接下來的事情就是，能夠像 Java 那樣運行在相同 JVM 中的新語言推向了市場，這些語言消除了 Java 中最令人頭疼的問題，并為開發(fā)人員提供了更好的環(huán)境，而且在很多情況下，它們的學(xué)習(xí)曲線非常平坦。

在繼續(xù)下面的內(nèi)容之前，我們簡要回顧一下 JVM 語言的歷史。

1. JVM 語言的歷史

在開始之前，我想澄清一點，那就是我省略掉了一些現(xiàn)有的 JVM 語言，這主要是因為它們從來沒有具備足夠強的吸引力，不能視為我們行業(yè)中廣泛使用的候選語言。那么，我們就開始快速回顧一下 JVM 語言的歷史。

圖片出自 Unsplash 站點，作者為 Maximilian Weisbecker

[[339426]]

我們的旅程當(dāng)然要從 Java 開始，它是 JVM 領(lǐng)域最古老和最流行的語言。

Java 語言最初是在 1996 年 1 月份正式發(fā)布的，所以它已經(jīng)有 24 年的歷史了，怎么樣，還不錯吧？最初，Java 是一種命令式語言，遵循純粹的面向?qū)ο蟪绦蝻L(fēng)格。它同時也是強類型語言，Java 的語法在某種程度上與 C++ 和 C 語言很相似，但它被認(rèn)為是一個改進版本，因為使用 Java 編寫代碼要比使用 C 或 C++ 容易得多。另外，在它的批評者中，最大的爭議在于其繁瑣性。

第二個發(fā)布的 JVM 語言是 Groovy，它最早出現(xiàn)于 2003 年，不過其第一個官方和標(biāo)準(zhǔn)版本 1.0 是 2007 年才發(fā)布的。Groovy 的好處在于，它還可以用作腳本語言。Groovy 是一種動態(tài)類型語言，所以類型檢查是在運行時進行的；這也是一些開發(fā)人員不喜歡 Groovy 的原因之一。我們使用 Groovy 編寫代碼，在編譯時看起來它是正確的，但是在運行時，我們才會發(fā)現(xiàn)其中有問題。

圖片來源：維基百科

接下來出現(xiàn)了另外一種流行的語言，也就是我們要討論的 Scala。Scala 在 2004 年正式發(fā)布，它為 JVM 領(lǐng)域帶來了一種新的編程模型，也就是函數(shù)式編程和它的聲明式方法。我們可以確定，Scala 率先引入了不可變性（immutability）的理念，所以它對 Java 的轉(zhuǎn)變做出了重要貢獻。但另一方面，Scala 的批評者并不喜歡它，因為它語法復(fù)雜，可讀性一般比較差。

圖片來源：維基百科

JVM 領(lǐng)域出現(xiàn)的下一個語言是 Clojure，它是一個純函數(shù)式語言，最近變得非常流行，但是它最早出現(xiàn)于 2007 年。Clojure 是一種基于 LISP 的語言，其特點是簡單和使用純函數(shù)。在它的缺點中，值得一提的是動態(tài)類型（與 Groovy 相同），而且學(xué)習(xí)曲線更陡峭，因為它的語法與其他 JVM 語言完全不同。如果你對學(xué)習(xí) Clojure 感興趣的話，那么應(yīng)該閱讀如下這兩本好書：“The joy of Clojure”和“Programming Clojure（第三版）”。

圖片來源：維基百科

最后但同樣重要的是 Kotlin！Kotlin 在 2016 年 2 月份首次發(fā)布，從那時開始，它就變得不斷流行起來。該語言是由 JetBrains 公司設(shè)計的，它有一個明確的目標(biāo)：消除 Java 中所有常見的問題。它的設(shè)計方式保留了 Java 所有的優(yōu)點，但是消除了 Java 的大多數(shù)問題，這也是它為何如此流行的原因，很多人甚至認(rèn)為在未來的幾年中它有可能會擊敗 Java。如果你想要了解 Kotlin 的更多內(nèi)容的話（我鼓勵你這樣做，因為它是一門偉大的語言），那么我推薦你閱讀“Kotlin in Action”一書，對于 Java 開發(fā)人員來說，這是一本入門 Kotlin 的優(yōu)秀圖書。

圖片出自 Unsplash 站點，作者為 Louis Tsai

這就是最重要的 JVM 語言，我們省略了一些不太流行的 JVM 語言，但是我們可以提一下它們的名字：Jython、JRuby、Ceylon、Fantom 等等。你可以通過該地址獲取現(xiàn)有 JVM 語言的全部列表。

我們可以發(fā)現(xiàn)，在最初的八年或十年間，Java 并沒有太多的競爭對手，但從那之后，Java 就面臨一些競爭了，那么有競爭是一件好事兒還是壞事兒呢？

2. 競爭加劇帶來的好處

正如我們在前文所述，Java 在早期并沒有太多改變，這很可能是因為沒有改變的必要，盡管它遠遠稱不上完美，但也已經(jīng)得到了廣泛的使用。

但是，新的競爭者出現(xiàn)了，這些更現(xiàn)代的語言帶來了新的特性，解決了長期困擾 Java 開發(fā)人員的一些痛點。

舉例來說，我們看一下 Scala 語言，自 2009 年以來，Scala 變得越來越受歡迎，開發(fā)人員歡迎這種新的函數(shù)式風(fēng)格，它能夠讓他們的編碼更靈活，也能安全輕松地編寫出并行代碼。我們可以在下面的谷歌趨勢圖中看到這個趨勢：

圖片來源：theboreddev.com

那 Oracle 對這種新趨勢的反應(yīng)是什么呢？那就是在 2014 年發(fā)布了 Java Lambdas 和 Streams。很多人都認(rèn)為當(dāng)時這是 Java 擊敗 Scala 的最大舉措。目前行業(yè)中每個人都能感受到最近幾年 Scala 因為缺少流所遭受的損失。

JVM 領(lǐng)域中存在競爭者的另外一個好處就是 JIT 編譯器和 JVM 本身正在經(jīng)歷的持續(xù)改進。現(xiàn)在，有更多的人對 JVM 優(yōu)化和性能改善感興趣。所以，競爭對每個人都是好事。

Kotlin 是這個領(lǐng)域最新的競爭者。Kotlin 非常重要，因為它在一定程度上為 Oracle 指明了前進方向。Kotlin 表明它能夠保持 Java 好的組成部分，同時創(chuàng)建一個更簡潔和快速的編碼語言。

如果看一下谷歌趨勢的話，我們能夠看到在過去幾年間，Kotlin 的流行程度：

圖片來源：theboreddev.com

從圖中可以看出，Kotlin 迅速變得非常流行，但是在最近幾年，它似乎穩(wěn)定了下來。

Oracle 很好地記錄了業(yè)界對 Kotlin 的反應(yīng)，如果你看一下 JDK 15 的發(fā)布說明，就會發(fā)現(xiàn) Java 的一些新特性基本上就是對 Kotlin 變更的復(fù)制。例如，新的 Java record、文本塊（使用三個引號的多行字符串）以及 switch 語句（或多或少借鑒了 Kotlin 的 when 語句）。我們可以通過該地址查閱 JDK 15 的發(fā)布說明。

剛才提到的這些，我都將其稱為“Java 的 Kotlin 化（Kotlinisation）”。Kotlin 通過成為 Java 有史以來最強的競爭對手，為 Java 指明了發(fā)展的方向。在我看來，Kotlin 是我見過的唯一一種能夠戰(zhàn)勝 Java，并成為行業(yè)領(lǐng)導(dǎo)者的語言。

3. Java 的“Kotlin”化

Java 的一些新特性主要在可讀性方面進行了增強，并改善了其主要的一個弱點，那就是繁瑣性。我們可以斷言，它與某些 Kotlin 的特性具有相似性。

需要注意，這些特性大多數(shù)都還處于特性預(yù)覽階段，這意味著你安裝 JDK 14 或 JDK 15 時，默認(rèn)不會啟用這些特性。

Java 特性預(yù)覽指的是一些在發(fā)布版本中包含、但默認(rèn)禁用的特性。在發(fā)行版中包含它們僅僅是為了收集社區(qū)開發(fā)人員的反饋，因此它們更經(jīng)常發(fā)生變更，這也是為何不推薦在生產(chǎn)環(huán)境代碼中使用它們的原因。

要在編譯時啟用這些特性，我們需要執(zhí)行如下代碼：

  1. javac --enable-preview --release 14 

如果你想要在運行時啟用它們的話，如下執(zhí)行如下代碼：

  1. Javajava --enable-preview YourClass 

當(dāng)然，你也可以在 IDE 中啟用它們，但是不要在你的新項目中默認(rèn)啟用預(yù)覽功能。

我們看一看這些變更，在未來的 Java 版本中，它們會對我們的編碼產(chǎn)生更大的影響。

Java record

Java record 是我們長期以來一直要求的一項特性，我相信你早就多次遇到這樣的場景了，那就是極不情愿地實現(xiàn) toString、hashCode、equals 方法以及每個字段的 getter（在這里，我假設(shè)你已經(jīng)不再實現(xiàn) setter 了，還記得我們在“Java 中新的并發(fā)模型”一文中所討論的不可變性嗎？）。

Kotlin 提供了數(shù)據(jù)類（data class）來解決這個問題，Java 也通過發(fā)布 record 類來解決了這個問題，同樣的問題，Scala 是通過 case 類來解決的。

這些類的主要目的是在對象中保存不可變的數(shù)據(jù)。讓我們通過一個示例來看看它在 Java 中能夠帶來多么好的效果。我們實例化并對比 Employee 類，需要編寫這么多的代碼：

  1. package com.theboreddev.java14; 
  2.  
  3. import java.util.Objects; 
  4.  
  5. public class Employee { 
  6.  
  7. private final String firstName; 
  8.  
  9. private final String surname; 
  10.  
  11. private final int age; 
  12.  
  13. private final Address address; 
  14.  
  15. private final double salary; 
  16.  
  17. public Employee(String firstName, String surname, int age, Address address, double salary) { 
  18.  
  19. this.firstName = firstName; 
  20.  
  21. this.surname = surname; 
  22.  
  23. this.age = age; 
  24.  
  25. this.address = address; 
  26.  
  27. this.salary = salary; 
  28.  
  29. } 
  30.  
  31. public String getFirstName() { 
  32.  
  33. return firstName; 
  34.  
  35. } 
  36.  
  37. public String getSurname() { 
  38.  
  39. return surname; 
  40.  
  41. } 
  42.  
  43. public int getAge() { 
  44.  
  45. return age; 
  46.  
  47. } 
  48.  
  49. public Address getAddress() { 
  50.  
  51. return address; 
  52.  
  53. } 
  54.  
  55. public double getSalary() { 
  56.  
  57. return salary; 
  58.  
  59. } 
  60.  
  61. @Override 
  62.  
  63. public boolean equals(Object o) { 
  64.  
  65. if (this == o) return true; 
  66.  
  67. if (o == null || getClass() != o.getClass()) return false; 
  68.  
  69. Employee employee = (Employee) o; 
  70.  
  71. return age == employee.age && 
  72.  
  73. Double.compare(employee.salary, salary) == 0 && 
  74.  
  75. Objects.equals(firstName, employee.firstName) && 
  76.  
  77. Objects.equals(surname, employee.surname) && 
  78.  
  79. Objects.equals(address, employee.address); 
  80.  
  81. } 
  82.  
  83. @Override 
  84.  
  85. public int hashCode() { 
  86.  
  87. return Objects.hash(firstName, surname, age, address, salary); 
  88.  
  89. } 
  90.  
  91. @Override 
  92.  
  93. public String toString() { 
  94.  
  95. return "Employee{" + 
  96.  
  97. "firstName='" + firstName + '\'' + 
  98.  
  99. ", surname='" + surname + '\'' + 
  100.  
  101. ", age=" + age + 
  102.  
  103. ", address=" + address + 
  104.  
  105. ", salary=" + salary + 
  106.  
  107. '}'; 
  108.  
  109. } 
  110.  
  111. } 

它所包含的 Address 對象如下所示：

  1. package com.theboreddev.java14; 
  2.  
  3. import java.util.Objects; 
  4.  
  5. public class Address { 
  6.  
  7. private final String firstLine; 
  8.  
  9. private final String secondLine; 
  10.  
  11. private final String postCode; 
  12.  
  13. public Address(String firstLine, String secondLine, String postCode) { 
  14.  
  15. this.firstLine = firstLine; 
  16.  
  17. this.secondLine = secondLine; 
  18.  
  19. this.postCode = postCode; 
  20.  
  21. } 
  22.  
  23. public String getFirstLine() { 
  24.  
  25. return firstLine; 
  26.  
  27. } 
  28.  
  29. public String getSecondLine() { 
  30.  
  31. return secondLine; 
  32.  
  33. } 
  34.  
  35. public String getPostCode() { 
  36.  
  37. return postCode; 
  38.  
  39. } 
  40.  
  41. @Override 
  42.  
  43. public boolean equals(Object o) { 
  44.  
  45. if (this == o) return true; 
  46.  
  47. if (o == null || getClass() != o.getClass()) return false; 
  48.  
  49. Address address = (Address) o; 
  50.  
  51. return Objects.equals(firstLine, address.firstLine) && 
  52.  
  53. Objects.equals(secondLine, address.secondLine) && 
  54.  
  55. Objects.equals(postCode, address.postCode); 
  56.  
  57. } 
  58.  
  59. @Override 
  60.  
  61. public int hashCode() { 
  62.  
  63. return Objects.hash(firstLine, secondLine, postCode); 
  64.  
  65. } 
  66.  
  67. @Override 
  68.  
  69. public String toString() { 
  70.  
  71. return "Address{" + 
  72.  
  73. "firstLine='" + firstLine + '\'' + 
  74.  
  75. ", secondLine='" + secondLine + '\'' + 
  76.  
  77. ", postCode='" + postCode + '\'' + 
  78.  
  79. '}'; 
  80.  
  81. } 
  82.  
  83. } 

為了完成一件簡單的事情，我們寫了太多的代碼，對不對？

接下來，我們看一下使用新的 Java record 之后，代碼會是什么樣子：

  1. public record EmployeeRecord(String firstName, String surname, 
  2.  
  3. int age, AddressRecord address, double salary) { 
  4.  
  5. } 

再看一下 Address 類：

  1. public record AddressRecord(String firstLine, String 
  2.  
  3. secondLine, String postCode) { 
  4.  
  5. } 

這和我們前面所編寫的一大堆代碼是同樣的效果，我們不得不承認(rèn)：這非常棒！從要保存的代碼數(shù)量和簡潔性方面都是如此。

現(xiàn)在我們看看新的 switch 語句有什么不同。

改善 switch 語句

新的 switch 語句解決了在 Java 中使用 switch 語句的一些固有問題。我們一直以來都被教導(dǎo)應(yīng)該避免使用 switch 語句，因為它們很容易出錯并會導(dǎo)致代碼重復(fù)。舉例來說，我們很容易遇到某個 case 條件覆蓋不到的場景。

新的 switch 語句解決了這個問題，因為如果我們的 switch 語句沒有涵蓋我們傳遞給它的領(lǐng)域類型的所有范圍，它就無法編譯通過。

為了闡述該例子，我們使用 Java 創(chuàng)建一個 DayOfTheWeek 枚舉：

  1. public enum DayOfTheWeek { 
  2.  
  3. MONDAY, 
  4.  
  5. TUESDAY, 
  6.  
  7. WEDNESDAY, 
  8.  
  9. THURSDAY, 
  10.  
  11. FRIDAY, 
  12.  
  13. SATURDAY, 
  14.  
  15. SUNDAY 
  16.  
  17. } 

我們需要 switch 語句告訴我們每周的某一天所對應(yīng)的位置。看一下通過 Java 11 該怎么實現(xiàn)：

  1. final DayOfTheWeek dayOfTheWeek = DayOfTheWeek.THURSDAY; 
  2.  
  3. int position = 0; 
  4.  
  5. switch (dayOfTheWeek) { 
  6.  
  7. case MONDAY: 
  8.  
  9. position = 1; 
  10.  
  11. break; 
  12.  
  13. case TUESDAY: 
  14.  
  15. position = 2; 
  16.  
  17. break; 
  18.  
  19. case WEDNESDAY: 
  20.  
  21. position = 3; 
  22.  
  23. break; 
  24.  
  25. case THURSDAY: 
  26.  
  27. position = 4; 
  28.  
  29. break; 
  30.  
  31. case FRIDAY: 
  32.  
  33. position = 5; 
  34.  
  35. break; 
  36.  
  37. case SATURDAY: 
  38.  
  39. position = 6; 
  40.  
  41. break; 
  42.  
  43. case SUNDAY: 
  44.  
  45. position = 7; 
  46.  
  47. break; 
  48.  
  49. } 
  50.  
  51. System.out.println("Day " + dayOfTheWeek + " is in position " + position + " of the week"); 

使用原來的 switch 語句時，我們必須要使用一個變量，而且如果我們遺漏了一周中的某一天，代碼也能編譯通過。這就是 switch 語句的問題之一，非常容易出錯。

Java 14 會怎樣改善這種情況呢？我們快速看一下：

  1. final DayOfTheWeek dayOfTheWeek = DayOfTheWeek.THURSDAY; 
  2.  
  3. int position = switch (dayOfTheWeek) { 
  4.  
  5. case MONDAY -> 1; 
  6.  
  7. case TUESDAY -> 2; 
  8.  
  9. case WEDNESDAY -> 3; 
  10.  
  11. case THURSDAY -> 4; 
  12.  
  13. case FRIDAY -> 5; 
  14.  
  15. case SATURDAY -> 6; 
  16.  
  17. case SUNDAY -> 7; 
  18.  
  19. }; 
  20.  
  21. System.out.println("Day " + dayOfTheWeek + " is in position " + position + " of the week"); 

我們可以看到，新的 switch 語句可以用作表達式，而不僅僅是語句。

這樣帶來的結(jié)果就是更加簡潔，也更具有表述性，這就足以說服我們使用它了。但是，現(xiàn)在的 switch 還有一個重要改善，那就是如果在 switch 中沒有涵蓋所有 case 的話，它將無法編譯通過。它會顯示如下錯誤：

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

現(xiàn)在，我們不會在 switch 語句中遺漏 case 了，這是一項非常棒的特性。

這非常類似于 Kotlin 的 when 語句，你可以通過該地址了解該語句的更多信息。

接下來，我們看一下文本塊。

文本塊

你有沒有遇到過將一個大的 blob JSON 賦值給 Java 變量的場景？你是否也受夠了這種丑陋的代碼？Java 將會引入多行字符串特性，我們可以通過將它們封裝在三重引號中來定義它們。當(dāng)這個功能被正式發(fā)布后，定義多行長字符串會更加容易。

我們來看一下兩種模式的差異。假設(shè)我們想要將一個格式化后的 JSON 存儲到一個變量中，那么丑陋的代碼如下所示：

  1. final String text = "{\"widget\": {\n" + 
  2.  
  3. " \"debug\": \"on\",\n" + 
  4.  
  5. " \"window\": {\n" + 
  6.  
  7. " \"title\": \"Sample Konfabulator Widget\",\n" + 
  8.  
  9. " \"name\": \"main_window\",\n" + 
  10.  
  11. " \"width\": 500,\n" + 
  12.  
  13. " \"height\": 500\n" + 
  14.  
  15. " },\n" + 
  16.  
  17. " \"image\": { \n" + 
  18.  
  19. " \"src\": \"Images/Sun.png\",\n" + 
  20.  
  21. " \"name\": \"sun1\",\n" + 
  22.  
  23. " \"hOffset\": 250,\n" + 
  24.  
  25. " \"vOffset\": 250,\n" + 
  26.  
  27. " \"alignment\": \"center\"\n" + 
  28.  
  29. " },\n" + 
  30.  
  31. " \"text\": {\n" + 
  32.  
  33. " \"data\": \"Click Here\",\n" + 
  34.  
  35. " \"size\": 36,\n" + 
  36.  
  37. " \"style\": \"bold\",\n" + 
  38.  
  39. " \"name\": \"text1\",\n" + 
  40.  
  41. " \"hOffset\": 250,\n" + 
  42.  
  43. " \"vOffset\": 100,\n" + 
  44.  
  45. " \"alignment\": \"center\",\n" + 
  46.  
  47. " \"onMouseUp\": \"sun1.opacity = (sun1.opacity / 100) * 90;\"\n" + 
  48.  
  49. " }\n" + 
  50.  
  51. "}} "; 

可以更容易地編寫整潔的代碼了：

  1. final String multiLineText = """ 
  2.  
  3. {"widget": { 
  4.  
  5. "debug": "on", 
  6.  
  7. "window": { 
  8.  
  9. "title": "Sample Konfabulator Widget", 
  10.  
  11. "name": "main_window", 
  12.  
  13. "width": 500, 
  14.  
  15. "height": 500 
  16.  
  17. }, 
  18.  
  19. "image": {\s 
  20.  
  21. "src": "Images/Sun.png", 
  22.  
  23. "name": "sun1", 
  24.  
  25. "hOffset": 250, 
  26.  
  27. "vOffset": 250, 
  28.  
  29. "alignment": "center" 
  30.  
  31. }, 
  32.  
  33. "text": { 
  34.  
  35. "data": "Click Here", 
  36.  
  37. "size": 36, 
  38.  
  39. "style": "bold", 
  40.  
  41. "name": "text1", 
  42.  
  43. "hOffset": 250, 
  44.  
  45. "vOffset": 100, 
  46.  
  47. "alignment": "center", 
  48.  
  49. "onMouseUp": "sun1.opacity = (sun1.opacity / 100) * 90;" 
  50.  
  51. } 
  52.  
  53. }} 
  54.  
  55. """; 

我覺得這樣好太多了。這也是 Kotlin 所支持的，可以在這里的類型定義中找到。

總之，我們能看到 Java 從它的競爭對手之一，也就是 Kotlin，那里“繼承”了許多方案來解決自己的問題。我們不知道這次 Oracle 在對抗 Kotlin 的崛起方面是否及時做出了正確的反應(yīng)，或許這有點太晚了。但我個人認(rèn)為 Java 正在朝著正確的方向前進，盡管這些變化是由它的競爭對手以某種方式觸發(fā)的，而且可能來得有點遲了。

如前所述，如果這篇文章激發(fā)了你學(xué)習(xí) Kotlin 語言的興趣，我建議你閱讀“Kotlin in Action”，對于 Java 開發(fā)人員來說，這是一門很棒的 Kotlin 入門圖書。

4. 結(jié)論

我認(rèn)為競爭是 Java 語言有史以來所遇到的最好的事情。如果不這樣，Java 就會作繭自縛。Java 的競爭對手也表明了不同的編程方式是可行的，它表明了前進的方向，并讓我們避免使用老式的、陳舊的編寫代碼方式。

我最近在 Java 中看到了一些變化，以及所有即將發(fā)布的特性和改善，它們正在使 Java 變得比以往任何時候都更強大。它是一種適應(yīng)當(dāng)前時代的語言，一種希望發(fā)展并忘記傳統(tǒng)做事方式的語言：Java 的新未來！

 

 

責(zé)任編輯：張燕妮 來源： 架構(gòu)頭條
Java開發(fā)代碼
相關(guān)推薦

2013-09-26 09:45:40

2009-03-30 17:51:30

Vmwareesx虛擬化

2010-05-10 12:59:02

Unix系統(tǒng)

2013-12-31 16:32:37

2024-06-11 14:40:46

2014-12-22 10:49:04

隱私隱私保護網(wǎng)絡(luò)安全

2017-09-18 11:49:07

互聯(lián)網(wǎng)

2024-07-10 17:20:44

2012-05-28 09:35:27

2017-12-12 23:24:19

物聯(lián)網(wǎng)人工智能邊緣計算

2020-07-31 10:01:10

新基建華為智慧醫(yī)療

2015-08-07 09:07:45

Java新特性面向未來

2021-01-19 18:58:23

云計算ARVR

2021-07-09 14:26:11

KotlinLogo設(shè)計

2013-09-02 13:27:59

以太網(wǎng)數(shù)據(jù)中心

2012-03-24 21:02:41

iOS

2018-06-27 17:46:16

智慧化

2015-09-23 10:23:08

2011-02-23 17:44:49

虛擬化標(biāo)準(zhǔn)

2023-08-30 15:02:32

點贊
收藏

51CTO技術(shù)棧公眾號

主站蜘蛛池模板： 亚洲第一免费播放区 | 中文字幕 国产精品 | 在线欧美一区 | 国产午夜精品理论片a大结局 | 久久在线 | 亚州成人 | 精品久久久网站 | 国产在线对白 | 99中文字幕 | 国产色 | 久久亚洲一区二区三区四区 | 日韩在线观看视频一区 | 国精产品一品二品国精在线观看 | 欧美日韩在线不卡 | 欧美日韩a| 国产三级大片 | 国产成人综合一区二区三区 | 美女视频黄的免费 | 成人一区二区三区视频 | 久久色视频 | 日本黄色短片 | 日本亚洲一区 | 日本成人综合 | 先锋资源在线 | 最新午夜综合福利视频 | 免费观看日韩精品 | h片在线播放 | 欧美日韩精品一区二区三区四区 | 欧美三级网站 | 国产精品一区网站 | 成人在线视频观看 | 一区二区三区免费 | 国产欧美日韩在线播放 | 成人在线观看网站 | 亚洲福利片 | 国产人久久人人人人爽 | 久久久久久久一区二区三区 | 99久久精品国产一区二区三区 | 日韩国产欧美一区 | 中国一级特黄真人毛片免费观看 | 国产亚洲精品久久久久动 |