Tinitiyak ang pagiging tugma sa Java

1. Kasaysayan ng mga bersyon ng Java

Nagsimula ang kasaysayan ng Java noong 1991, nang nagpasya ang isang grupo ng mga programmer ng Sun na lumikha ng wika para sa maliliit na device: mga remote control ng TV, mga coffee maker, toaster, bank card, at iba pa.

Ang mga tagagawa ng mga device na ito ay gumamit ng iba't ibang mga processor upang kontrolin ang kanilang mga produkto, kaya naging napakahalaga na maugnay sa arkitektura ng isang partikular na processor o OS.

Nagpasya ang mga tagalikha ng Java na hatiin ang problema sa dalawang bahagi: Ang kanilang mga programa ay isasama hindi sa machine code para sa isang partikular na processor, ngunit sa isang espesyal na intermediate code. Sa turn, ang intermediate code na iyon ay isasagawa ng isang espesyal na programa na tinatawag na virtual machine .

Karamihan sa mga programmer ay tumutukoy sa isang computer bilang isang makina.

Ang unang bersyon ng Java ay inilabas noong 1996. Simula noon, sinimulan ng Java ang matagumpay na martsa nito sa buong mundo, na, naman, ay nagpasigla sa ebolusyon at paglago ng wika mismo. Ngayon, milyon-milyong mga aklatan at bilyun-bilyong linya ng code ang nakasulat sa Java, at ang mga bagong bersyon ng Java ay inilalabas tuwing 6 na buwan:

Bagama't regular na inilabas ang mga bersyon ng Java, hindi lahat ng ito ay may pantay na kahalagahan para sa mga programmer: Ang Java ay umunlad sa mga akma at pagsisimula.

2. Java 2

Ang unang malaking paglukso ay naganap sa paglabas ng JDK 1.2. Napakaraming inobasyon doon kaya pinalitan ito ng mga tagalikha ng Java ng Java 2 Platform Standard Edition o J2SE 1.2 para sa maikling salita.

Ang mga pangunahing inobasyon ay:

• strictfpkeyword
• Ang Swing library para sa pagtatrabaho sa mga graphics
• Ang JIT compiler, na nagpabilis sa pagpapatupad ng mga programa ng Java
• Isang malaking hanay ng mga koleksyon
• Buong suporta sa Unicode: Japanese, Chinese at Korean.

Ngayon, ang mga pagbabagong ito ay hindi mukhang napakalaki, ngunit ang bawat malaking proyekto ay lumalaki mula sa isang maliit. Ang Java ay hindi magiging kasing tanyag ngayon kung ang isang maliit na grupo ng mga programmer ay hindi nagpatuloy sa pagpapabuti ng wika 20 taon na ang nakakaraan.

3. Java 5

Ang JDK 1.5 ay inilabas noong Setyembre 2004. Nagpakilala rin ito ng maraming inobasyon, kaya hindi nito maiwasang maging karapat-dapat sa isang bagong pangalan: sa halip na mga bersyon 1.5, 1.6, at 1.7, nagpasya silang gumamit ng 5.0, 6.0, at 7.0. Kaya, ang buong pangalan ng JDK 1.5 ay Java 2 Standard Edition 5.0

Kasama sa update na ito ang mga bagay na kung wala ay hindi magiging posible ang karagdagang pag-unlad ng wika.

Mga anotasyon . Ang kalahati ng mga pangunahing modernong framework ay binuo sa mga anotasyon, mula Spring at Hibernate hanggang JUnit.

Generics . Nakuha ng mga generic ang kapangyarihan ng mga koleksyon (at marami pang iba) sa mga bagong taas. Ang code ay naging mas simple, mas compact at mas ligtas.

Ang autoboxing/unboxing ay awtomatikong conversion sa pagitan ng mga primitive na uri at mga uri ng wrapper ng mga ito. Pinadali nito ang pagsulat at pagbabasa ng code, at ginawang mas sikat ang mga koleksyon.

Ang foreachloop ay account na ngayon para sa hindi bababa sa kalahati ng lahat ng mga loop na isinulat ng mga programmer. At, siyempre, ito ay kailangang-kailangan kapag nagtatrabaho sa mga koleksyon.

Ang enum ay isa pang magandang bagong tampok. Nagbibigay-daan ito sa maraming bagay na pasimplehin nang maganda.

Ito ay hindi lahat ng mga pagbabago: daan-daang mga bagong klase ang idinagdag. Ang mahalagang bagay ay ang mga ito ay tama lamang na mga inobasyon, at nagbigay ng isa pang malakas na tulong sa katanyagan ng Java.

4. Java 6

Ang Java 6 ay naaalala para sa isang malaking bilang ng mga maliliit na pagpapabuti at ang pag-abandona ng numero 2 sa pangalan: ito ay hindi na "Java 2 Standard Edition 6.0", ngunit simpleng "Java Standard Edition 6.0".

Narito ang ilan sa mga kagiliw-giliw na inobasyon:

Ginawang posible ng Java Compiler API na tawagan ang Java compiler nang direkta mula sa code. Nangangahulugan iyon na ang iyong programa ay maaari na ngayong bumuo ng text na kumakatawan sa class code, i-compile ito sa pamamagitan ng pagtawag sa mga pamamaraan ng Java Compiler API , at pagkatapos ay agad na simulan ang pagtawag sa mga pamamaraan ng pinagsama-samang klase. Mayroong buong mga lugar ng pag-unlad kung saan ang kakayahang ito ay lubos na nagpapadali sa buhay.

Naging posible na magsagawa ng JavaScript nang direkta sa loob ng isang Java program. Lumitaw ang feature na ito dahil kasama sa JavaSE 6 ang Rhino JavaScript engine.

5. Java 7

Ang Java 7 ay inilabas noong Hulyo 2011. Dapat ay maraming mga pagpapabuti dito, ngunit ang mga programmer ay pinamamahalaang magdagdag lamang ng isang maliit na bahagi ng kung ano ang binalak. Sa partikular, nagdagdag sila ng mga bagay tulad ng:

Isang bagong library para sa pagtatrabaho sa input at output ng data. Kilala bilang Bagong Input Output API , ito ay matatagpuan sa java.niopackage.

Ang awtomatikong uri ng inference ng Java compiler sa oras ng pag-compile ay nagpapahintulot sa mga programmer na magsulat ng mas kaunting code. Ang compiler ay naging mas matalino, at iyon ay simula pa lamang.

Ang switch statement ay nakakuha ng kakayahang gumamit ng mga string bilang mga case value.

Ang awtomatikong pamamahala ng mapagkukunan ay napabuti din nang malaki: Sa try-with-resourcespagbuo, maaaring isara ng isang Java program ang mga stream ng data para sa iyo kapag hindi na kailangan ang mga ito.

Mayroong maraming iba pang mga pagbabago, ngunit hindi ito napakahalaga sa aming kasalukuyang yugto ng pag-aaral ng Java.

6. Java 8

Ang Java 8 ay lumabas noong Marso 2014 at ito ang pinakamalakas na kamakailang pag-update ng Java.

Higit sa lahat, naaalala ito ng mga programmer para sa pagdaragdag nito ng mga lambda expression at functional na interface (ang @FunctionalInterfaceanotasyon). Susuriin namin ang mga ito sa Level 21. Hindi na magiging pareho ang iyong code.

Nagdagdag din ng mga stream para sa mga koleksyon, kung saan, kasabay ng mga expression ng lambda, naging posible na magsulat ng code nang mas compact. Kahit na hindi palaging mas nababasa.

7. Java 9

Inilabas ang Java 9 noong Setyembre 2017. Mula noon, nagpasya ang mga tagalikha ng Java na maglabas ng mga bagong bersyon nang mas madalas — tuwing anim na buwan. Marahil ay humanga sila sa diskarte na pinagtibay ng mga developer ng Google Chrome browser.

Ang paglabas ng Java 9 ay higit na nakatuon sa mga panloob ng Java machine. Ang pinakamahalagang bagay na dinala nito sa mga ordinaryong programmer ay ang kakayahang hatiin ang isang programa sa mga module. Ito ay napaka-maginhawa kapag mayroon kang libu-libong mga klase o kapag ang iyong code ay dynamic na nag-aalis ng mga plugin.

Ngunit ito ay malamang na walang pakinabang sa atin sa malapit na hinaharap.

8. Java 11

Anim na buwan pagkatapos ng paglabas ng Java 9, lumabas ang Java 10, at pagkaraan ng anim na buwan, lumabas ang Java 11.

Maraming maliliit na pagpapabuti ang ginawa sa panahong ito, ngunit malamang na dalawa lang ang maaalala mo:

Nagdagdag ito ng suporta para sa Unicode 10. Ngayon ay maaari ka nang gumamit ng mga emoji sa iyong mga Java program. Maaari kang magtrabaho kasama ang mga ito sa parehong paraan kung paano magtrabaho sa uri ng boolean:

Napabuti ang uri ng hinuha, at lumitaw ang varkeyword , na siguradong magugustuhan mo.

Ngayon ay maaari mong isulat ang sumusunod:

var str = "Hello";

At kino-convert ito ng compiler sa:

String str = "Hello";

Ngunit mayroon ding ilang mga pagkalugi. Inalis ng mga tagalikha ng Java ang mga aklatan tulad ng JavaFX, Java EE, at CORBA mula sa JDK 11.

9. Kahalagahan ng pagiging tugma

Kapag ang isang bagong bersyon ay inilabas, ang mga programmer ay madalas na gustong magsimula mula sa simula. Pagkatapos ng lahat, sino ang gustong ayusin ang isang bungkos ng mga lumang bug kapag sila ay ganap na positibo kung paano dapat naisulat ang code mula pa sa simula?

Ngunit hindi sinusuportahan ng kasaysayan ang gayong paraan. Sa tuwing maglalabas ang mga programmer ng bagong bersyon ng isang program, 90% ng mga user nito ay gumagamit ng lumang bersyon. Maaari nilang gamitin o balewalain ang mga bagong feature ng program, ngunit ang kinasusuklaman ng mga user ay kapag ang isang bagay na dating gumagana nang maayos ay tumigil sa paggana.

Maraming mahuhusay na produkto ang namatay nang ang mga programmer ay naglabas ng mga bagong bersyon na hindi tugma. O kapag gumawa sila ng malalaking pagbabago. Halimbawa, ang ideya ng pag-abandona sa Start button sa Windows 8 ay hindi nakakaakit sa mga user. Ibinalik ng paglabas ng Windows 10 ang kalahati ng inalis sa Window 8.

Higit pa rito, hinahayaan ka ng Windows na magpatakbo ng mga program na isinulat 20 taon na ang nakakaraan para sa Windows 95 o kahit na isinulat 30 taon na ang nakalipas para sa MS DOS 3.0 — gagana ang mga ito. Ito ang isa sa mga dahilan kung bakit nananatiling popular ang Windows.

At ang Java ay hindi magiging kasing tanyag nito kung ang mga developer nito ay walang pakialam sa compatibility. Anumang oras na mayroong bagong bersyon ng Java machine, bagong bersyon ng SDK, o malalaking pagbabago sa mga klase, ang lahat ng Java code na isinulat mula noong Enero 1996 ay patuloy na gagana.

Karaniwan itong nakakamit sa pamamagitan lamang ng pagdaragdag ng mga bagong pamamaraan, klase, at pakete, nang hindi inaalis ang anuman. Ang diskarte na ito ay may mga kalamangan at kahinaan.

Sa isang banda, ang Java ay nag-drag sa paligid ng isang grupo ng mga bagahe sa anyo ng luma, suboptimal, at hindi kinakailangang code. Sa kabilang banda, ang iyong proyektong nakasulat sa Java 11 ay palaging maaaring gumamit ng library na nakasulat sa Java 8 na gumagamit ng mga library na nakasulat sa Java 5 at Java 2. Ang hodgepodge ng code na ito ay gagana nang maayos.

Sa wikang C++, ang mga library na pinagsama-sama para sa parehong 32-bit at 64-bit na mga platform ay hindi magagamit sa parehong proyekto. At magkakaroon ka ng malaking sakit ng ulo kung bigla mong matuklasan na ang charuri na ginamit sa isang library ay gumagamit ng isang byte, habang ang isa ay gumagamit ng dalawang byte.

10. Hindi na ginagamit

Kaya, nagpasya ang mga tagalikha ng Java na huwag mag-alis ng anuman, ngunit magdagdag lamang ng mga bagong klase at pakete. Ngunit paano nila ipinapaalam sa mga programmer na mayroong isang bagong karapat-dapat na alternatibo sa isang umiiral na suboptimal na solusyon?

Upang gawin ito, nakabuo sila ng @Deprecatedanotasyon.

Kung ang ilang paraan o klase ay hindi na ginagamit, ang anotasyong ito ay idaragdag sa tabi ng deklarasyon nito. Nangangahulugan ito na ang mga programmer ay nasiraan ng loob na gamitin ang code.

Maaari ka pa ring gumamit ng hindi na ginagamit na klase o pamamaraan, ngunit hindi ito inirerekomenda.

At gaano kadalas ginagawa ng mga tao ang mga bagay na hindi inirerekomenda? Halos palagi 🙂

Maraming klase ang hindi na ginagamit sa loob ng 20 taon — ginagamit na ang mga ito at ginagamit pa rin. Ang mga tao ay pamilyar sa kanila o sila ay maginhawa lamang. Ngunit may panganib na maalis ang mga ito sa isang punto, kaya mas mahusay na huwag gamitin ang mga ito.

Ang lahat ng modernong IDE, kabilang ang IntelliJ IDEA, ay kayang hawakan ang @Deprecatedanotasyon. Ang mga pangalan ng hindi na ginagamit na mga klase at pamamaraan ay ipinapakita gamit ang strikethrough na pag-format. Isang bagay na tulad nito:

Date date = new Date();
int day = date.getDay();

Ang mga hindi na ginagamit na klase ay napakasikat at madalas na makikita sa code, kaya titingnan natin ang ilan sa mga ito sa lalong madaling panahon.