Bumara? Pinaka Mahirap na Bahagi ng Pag-aaral ng Java at Paano Malalampasan ang mga Ito

Tulad ng alam mo, inirerekumenda namin ang mga nagsisimula sa pag-coding upang simulan ang pag-aaral ng mga programming language gamit ang Java, at ang CodeGym ay mayroon ng lahat upang gawing natutunaw ang proseso ng pag-aaral ng Java kahit na para sa mga pinaka-hindi handa na mga mag-aaral. Ngunit kasing dami ng mga elemento ng gamification, madaling pag-usapan ang kuwento at mga nakakatawang character na nakakatulong upang mapagaan ang prosesong ito, ang pag-aaral ng mga pangunahing kaalaman ng Java sa kabuuan nito ay bihirang walang hamon para sa karamihan ng mga bagong mag-aaral. Ngayon ay titingnan natin ang ilan sa mga pinakamahirap na lugar sa Java programming fundamentals, sinusubukang unawain kung bakit maraming tao ang nahihirapan sa kanila at kung mayroon kang gagawin tungkol dito.

1. Generics

Ang mga generic sa Java ay mga uri na may parameter. Kapag gumagawa ng generic na uri, tinukoy mo hindi lamang isang uri, kundi pati na rin ang uri ng data kung saan gagana ito. Ang mga generic ay madalas na binabanggit ng mga nag-aaral ng Java bilang isa sa pinakamahirap na bahagi ng Java para maunawaan nila. "Ang pangunahing isyu ko ay ang pakikitungo sa Generics. Ito ay mas madali kapag mayroon kang mga pamamaraan na may mga parameter na susundan, ngunit nakakalito kapag kailangan mong magsulat ng iyong sarili,” sabi ng isang hindi kilalang nag-aaral ng Java.

Mga tip at rekomendasyon

Narito ang isang opinyon tungkol sa Generics sa Java mula kay Ravi Reddy, isang bihasang programmer at propesor sa unibersidad: “Ang Java Generics ay gumagawa ng isang bagay na hindi ginagawa ng mga template ng C++ — ipatupad ang uri ng kaligtasan. Ang pagpapatupad ng mga template ng C++ ay isang simpleng pre-processor trick at hindi sinisiguro ang kaligtasan ng uri. Ang mga generic sa Java ay tulad ng mga template ng C++ ngunit may karagdagang kaligtasan ng uri. At IMHO, ang uri ng kaligtasan ay isang mahalagang katangian ng anumang magandang kapaligiran sa pag-unlad. At oo! Maaari silang maging nakalilito dahil sa aming mga pagbabago sa isip sa pagitan ng mga parameter at mga uri. Ngunit naniniwala ako na ang paggugol ng oras upang makabisado ang mga ito ay nagkakahalaga ng pagsisikap. Dahil natagpuan ko ang aking sarili na "nag-iisip" nang mas mahusay sa Java sa sandaling naunawaan ko ang mga interface at Generics."

2. Multithreading

Ang multithreading sa Java ay isang proseso ng pagpapatupad ng dalawa o higit pang mga thread nang sabay-sabay upang makamit ang maximum na paggamit ng CPU ng application. Nalulutas ng multithreading ang mga napakahalagang gawain at maaaring gawing mas mabilis ang aming mga programa. Kadalasan maraming beses na mas mabilis. Ngunit ito ay itinuturing na isa sa mga paksa kung saan maraming mga bagong mag-aaral ng Java ang madalas na natigil. Lahat dahil ang multithreading ay maaari ding lumikha ng mga problema sa halip na lutasin ang mga ito. Mayroong dalawang partikular na problema na maaaring lumikha ng multithreading: deadlock at mga kondisyon ng lahi. Ang deadlock ay isang sitwasyon kung saan maraming mga thread ang naghihintay para sa mga mapagkukunang hawak ng bawat isa, at wala sa mga ito ang maaaring magpatuloy na tumakbo. Ang kundisyon ng lahi ay isang error sa disenyo sa isang multithreaded system o application, kung saan ang pagpapatakbo ng system o application ay depende sa pagkakasunud-sunod kung saan ang mga bahagi ng code ay isinasagawa.

Mga tip at rekomendasyon

Narito ang isang magandang rekomendasyonsa kung paano haharapin ang multithreading mula sa S.Lott, isang software architect at aktibong user ng StackExchange, isang sikat na Q&A website: “Ang multi-threading ay simple. Ang pag-coding ng isang application para sa multi-threading ay napakadali. Mayroong isang simpleng trick, at ito ay ang paggamit ng isang mahusay na dinisenyo na pila ng mensahe (huwag i-roll ang iyong sarili) upang ipasa ang data sa mga thread. Ang mahirap na bahagi ay sinusubukan na magkaroon ng maraming mga thread na mahiwagang i-update ang isang nakabahaging bagay sa ilang paraan. Iyon ay kapag ito ay nagiging error-prone dahil hindi binibigyang pansin ng mga tao ang mga kondisyon ng lahi na naroroon. Maraming mga tao ang hindi gumagamit ng mga pila ng mensahe at sinusubukang i-update ang mga nakabahaging bagay at lumikha ng mga problema para sa kanilang sarili. Ang nagiging mahirap ay ang pagdidisenyo ng algorithm na gumagana nang maayos kapag nagpapasa ng data sa ilang mga pila. mahirap yan.

3. Mga isyu sa classpath

Ang mga error sa classpath ay itinuturing din na isa sa mga pinaka inirereklamong problema na kinakaharap ng mga developer ng Java sa kanilang pang-araw-araw na gawain. “Ang mga problema sa classpath ay maaaring magtagal sa pag-debug at malamang na mangyari sa pinakamasamang posibleng mga oras at lugar: bago ilabas, at madalas sa mga kapaligiran kung saan kakaunti o walang access ang development team. Maaari rin itong mangyari sa antas ng IDE at maging mapagkukunan ng pinababang produktibidad," sabi ni Vasco Ferreira, isang may karanasan na developer ng Java/Javascript at may-akda ng mga tutorial na nauugnay sa programming.

Mga tip at rekomendasyon

"Ang mga problema sa classpath ay hindi ganoon kababa o hindi malapitan na tila sa una. Ang lahat ay tungkol sa mga zip file (mga garapon) na naroroon / hindi naroroon sa ilang mga direktoryo, kung paano hanapin ang mga direktoryo na iyon, at kung paano i-debug ang classpath sa mga kapaligiran na may limitadong pag-access. Sa pamamagitan ng pag-alam ng limitadong hanay ng mga konsepto tulad ng Class Loaders, ang Class Loader Chain at Parent First / Parent Last na mga mode, ang mga problemang ito ay maaaring matugunan nang epektibo," paliwanag ng eksperto.

4. Polymorphism at wastong paggamit nito

Pagdating sa mga prinsipyo ng OOP, maraming tao ang nagsasabi na nahihirapan silang maunawaan ang polymorphism. Ang polymorphism ay ang kakayahan ng isang programa na tratuhin ang mga bagay na may parehong interface sa parehong paraan, nang walang impormasyon tungkol sa partikular na uri ng bagay. Sa kabila ng Polymorphism ay isang pangunahing paksa, ito ay medyo malawak at bumubuo ng isang magandang bahagi ng pundasyon ng Java. Para sa maraming mga mag-aaral, ang polymorphism ay isang unang kahirapan sa pag-aaral ng Java. Lahat dahil may iba't ibang anyo ng polymorphism na ginagamit sa iba't ibang konteksto, na maaaring nakakalito.

Mga tip at rekomendasyon

Walang ibang paraan upang harapin ang polymorphism maliban sa pag-aaral nito. Narito kung paano nagpapaliwanag si Torben Mogensen, na nagtuturo ng programming sa The University of Copenhagenang konseptong ito: “Simple overloading: + ay maaaring mangahulugan ng parehong integer addition, floating point addition at (sa ilang wika) string concatenation. Subtype polymorphism: Kung ang B ay isang subtype ng (nagmana mula sa) A, ang anumang halaga ng uri B ay maaaring gamitin sa isang konteksto na umaasa ng isang halaga ng uri A. Parametric polymorphism: Ang isang uri ay maaaring i-parameter gamit ang mga parameter ng uri, upang ikaw ay nasa ang iba't ibang konteksto ay maaaring magbigay ng iba't ibang uri ng mga argumento, kaya't i-instantiate mo ang naka-parameter na uri sa iba't ibang kongkretong uri. Tinatawag din itong "mga template" o "generics" at nasa mga wikang OO na karaniwang tinutukoy gamit ang mga angle bracket (gaya ng T<A>). Interface polymorphism. Ito ay karaniwang isang mekanismo kung saan nililimitahan mo ang subtype polymorphism sa mga subtype na nagpapatupad ng isang partikular na interface o parametric polymorphism upang mag-type ng mga parameter na nagpapatupad ng isang partikular na interface."

5. Pagninilay

Ang pagninilay ay isang mekanismo upang tuklasin ang data tungkol sa isang programa habang ito ay tumatakbo. Hinahayaan ka ng Reflection na tuklasin ang impormasyon tungkol sa mga field, pamamaraan, at constructor ng klase. Nagbibigay-daan din ito sa iyo na magtrabaho sa mga uri na wala sa oras ng pag-compile, ngunit naging available sa oras ng pagtakbo. Ang pagmuni-muni at isang lohikal na pare-parehong modelo para sa pagbibigay ng impormasyon ng error ay ginagawang posible na lumikha ng tamang dynamic na code. Ngunit para sa maraming tao, hindi ganoon kadaling malaman kung paano gamitin ang Reflection.

Mga tip at rekomendasyon

“Sa kaso ng reflection at Java, ang reflection ay nagbibigay-daan sa Java, na idinisenyo upang maging statically type, na dynamic na ma-type. Ang dynamic na pag-type ay hindi likas na masama. Oo, pinapayagan nito ang programmer na sirain ang ilang mga prinsipyo ng OOP, ngunit kasabay nito ay nagbibigay-daan ito sa maraming makapangyarihang feature tulad ng runtime proxying at dependency injection. Oo, hinahayaan ka ng Java na kunan ang iyong sarili sa paa gamit ang reflection. Gayunpaman, kailangan mong tahasan ang pagtutok ng baril sa iyong paa, alisin ang kaligtasan at hilahin ang gatilyo,” paliwanag ni Jayesh Lalwani, isang makaranasang Java programmer at application architect.

6. Input/Output stream

Hinahayaan ka ng mga stream na magtrabaho kasama ang anumang data source: ang Internet, ang file system ng iyong computer, o iba pa. Ang mga stream ay isang unibersal na tool. Pinapayagan nila ang isang programa na makatanggap ng data mula sa kahit saan (mga stream ng input) at ipadala ito kahit saan (mga stream ng output). Ang kanilang gawain ay pareho: kumuha ng data mula sa isang lugar at ipadala ito sa isa pa. Mayroong dalawang uri ng stream: input stream (ginagamit para tumanggap ng data) at output stream (para sa pagpapadala ng data). Ang nagpapahirap sa maraming tao na maunawaan ang paggamit ng mga stream ay ang katotohanan na ang Java ay may maraming mga klase ng stream ng I/O.

Mga tip at rekomendasyon

"Ang Java ay may napakaraming klase ng stream ng I/O higit sa lahat dahil sa dalawang nag-aambag na salik. Una ay legacy. Ang ilang mga klase ay naroroon pa rin para sa makasaysayang mga kadahilanan at ang mga ito ay hindi pinahinto dahil hindi sila itinuturing na nakakapinsala. Pangalawa, flexibility. Ang iba't ibang mga application ay may iba't ibang mga kinakailangan at sa gayon, mayroon kang maraming mga pagpipilian depende sa iyong mga kinakailangan. Ang mga kapaki-pakinabang na abstraction ay nagdudulot ng kalinawan kapag binasa mo ito at sa kaunting linya ng code ay marami kang magagawa,” sabi ni Jonas Mellin, isang dalubhasa sa Java mula sa Sweden. Anong mga aspeto ng Java ang nakita mong pinakamahirap na maunawaan o natigil sa loob ng ilang panahon? Ibahagi ang iyong mga karanasan sa mga komento.