Unang ipinakilala noong 1995, ang Java ay naging isa sa pinakamalawak na ginagamit na mga programming language. Ang tagumpay na ito ay makatwiran dahil ang Java ay isang platform-independent na wika na tumatakbo sa mahigit 3 bilyong device na may iba't ibang operating system. Sa iba pang matibay na punto, ang Java ay umaakit sa pagiging simple nito. Bilang resulta, ang Java ay medyo madaling matutunan at i-deploy kumpara sa maraming iba pang mga programming language. Bilang karagdagan, ang Java ay palakaibigan sa mga nagsisimula, na mabilis matuto kung magsisikap ka. Gayunpaman, kahit na ang pinaka-masigasig na mga mag-aaral ay maaaring humarap sa mga paghihirap. Ang mga pinaka-mapaghamong paksa at ang pinakamahusay na paraan upang "madaig" ang mga ito ay inilarawan sa ibaba.
Bakit Mukhang Mahirap ang Java para sa Mga Nagsisimula?
Kung mayroon ka nang ilang teknikal na background, ang pag-aaral ng Java ay maaaring isang piraso ng cake para sa iyo. Gayunpaman, maaari mong mahanap na mahirap maunawaan kung ikaw ay isang ganap na baguhan. Ang bagay ay ang Java syntax ay isang statically-typed na machine language na may malawak na iba't ibang mga feature at frameworks, hindi pa banggitin na maaari itong isama sa ilang mga platform. Kaya, ano ang mga "pinakamainit" na paksa para sa mga nagsisimula?
Variable Visibility
Ang mga lokal na variable ay maaaring maging isang kaunting pagmamadali para sa kumpletong mga baguhan (bagaman madali para sa mga batikang mag-aaral). Sa Java, ang mga lokal na variable ay higit na nakakatulong kapag kailangan namin ng isang pansamantalang variable upang hawakan ang mga halaga sa loob ng block, at hindi namin kailangan ang (mga) variable na iyon para sa iba pang mga pamamaraan. Parang nakakalito? Hindi ka nag-iisa! Iyon ang dahilan kung bakit mayroon kaming isang aralin na nakatuon sa mga lokal na variable:
Ano ang mga pakinabang ng paggamit ng mga pamamaraan? Para sa isa, ito ay code reusability at para sa dalawa, ito ay ang katotohanan na ang mga pamamaraan ay ginagawang mas nababasa at mas madaling i-debug ang code. Gayunpaman, malamang na alam mo na na ang pamamaraan ay maaaring bumalik sa code. Nangyayari ito sa tatlong mga kaso:
kapag nakumpleto nito ang lahat ng mga pahayag sa pamamaraan,
kapag naghagis ito ng eksepsiyon (saklaw sa ibang pagkakataon),
kapag umabot ito sa isang return statement.
Kung malito ka ng mga aspetong ito, magiging kapaki-pakinabang sa iyo ang aming leksiyon tungkol sa mga return statement:
Siyempre, nagbibigay ang Java ng mga paunang natukoy na pamamaraan, ngunit kung gagawa ka ng iyong mga pamamaraan, magbubukas ka ng isang bagong uniberso kung saan maaari kang magsagawa ng ilang partikular na pagkilos na naaayon sa iyong mga pangangailangan. Sa sumusunod na tutorial, matututunan mo ang higit pa tungkol sa mga pamamaraan ng Java (kung paano tukuyin at gamitin ang mga ito) pati na rin kung paano likhain ang iyong mga pamamaraan na may pinakamababang pagsisikap at oras na inilaan dito:
Sa madaling salita, ang mga parameter ay mga variable na tinukoy sa loob ng pamamaraan. Maaaring ipasa ang impormasyon sa mga pamamaraan bilang mga parameter, na maaaring kabilang ang mga primitive na uri gaya ng int, float, boolean, at iba pa (pati na rin ang mga hindi primitive o mga uri ng object gaya ng array, String, atbp.). Upang malaman ang higit pa tungkol sa paksang ito, maaari kang sumangguni sa sumusunod na panayam:
Ang isa pang kumplikadong paksa para sa mga bagong mag-aaral ay ArrayList. Bilang bahagi ng balangkas ng koleksyon , ang ArrayList ay ginagamit sa Java upang mag-imbak ng isang koleksyon ng mga elemento na may dynamic na laki. Ito ay isang elemento ng balangkas ng koleksyon ng Java na nagpapatupad ng interface ng Listahan ng Java. Upang maging pamilyar sa paksang ito, maaari kang sumangguni sa aming panayam:
Ang susunod na paksa na maaaring mabigo sa iyo ay ang klase ng Arrays at ang paggamit nito. Ang klase ng Arrays ay isang bahagi ng Java Collection Framework. Ang klase na ito ay naglalaman ng iba't ibang pamamaraan para sa pagmamanipula ng mga arrays (pag-uuri at paghahanap). Gayundin, kabilang dito ang isang static na pabrika na nagbibigay-daan sa mga array na matingnan bilang mga listahan. Ang klase ng mga array ay binubuo lamang ng mga static na pamamaraan at mga pamamaraan ng klase ng Bagay. Ang nakatuong artikulo kasama ang aralin , ay gagawing mas madali at mas mauunawaan ang mga bagay para sa iyo.
Mga Bagay at Klase
Ang isang entity na may estado, pag-uugali, at pagkakakilanlan ay isang bagay sa Java. Ang isang bagay ay isang halimbawa ng isang klase. Ang klase ay isang pangkat ng mga bagay na may mga karaniwang katangian. Ito ay isang template kung saan nilikha ang mga bagay. Samakatuwid, ang isang bagay ay ang halimbawa (resulta) ng isang klase. Parang kakaiba? Hindi ka nag-iisa. Ang mga sumusunod na aralin ay maaaring makatulong sa pagbibigay liwanag sa mga paraan upang simulan ang mga bagay, kung paano lumikha ng mga bagay sa Java, at marami pa:
Sa pangkalahatan, ang mga constructor sa Java ay maaaring nahahati sa No-Arg constructors, Parameterized constructors, at Default na constructor. Ang mga konstruktor na ito ay maaaring o walang anumang mga parameter (mga argumento) na katulad ng mga pamamaraan. Bilang karagdagan, ang ilan sa kanila ay maaari ring tumanggap ng isa o higit pang mga parameter. Hindi nakakagulat na ang paksang ito ay maaaring hindi kapani-paniwalang nakakalito para sa mga nagsisimula. Samakatuwid, mayroon kaming ilang mga aralin na naka-target sa mga konstruktor at sa kanilang mga partikular na tampok:
Ang inheritance ay isang mabisang tool para sa paglikha ng mga istruktura ng OO. Ito ay isang mahalagang mekanismo sa Java, na nagpapahintulot sa iyo na magmana ng mga tampok ng isa pang klase (mga patlang at pamamaraan). Gayunpaman, kapag hindi ginamit nang maayos, maaari itong lumikha ng isang napakahigpit na pinagsamang code at mahirap mapanatili. Ang mana ay nakakuha ng medyo nakakatakot na reputasyon dahil dito. At upang matulungan ang mga mag-aaral na masanay sa paggamit nito nang tama, naghanda kami ng malawak na aralin at artikulo:
Hindi nang walang dahilan, maraming bagong mag-aaral ang natigil sa mga Static na klase, Static na pamamaraan, at Static Variable. Bakit itinuturing na masama ang mga static na variable ? Samantalang ang ilan ay naniniwala na "Sila ay salungat sa object-oriented paradigm. Sa partikular, nilalabag nito ang prinsipyo na ang data ay naka-encapsulated sa mga bagay (na maaaring pahabain, pagtatago ng impormasyon, atbp.)" samantalang ang iba ay naniniwala na "Ang mga static na variable ay kumakatawan sa pandaigdigang estado. Iyan ay mahirap mangatwiran at mahirap subukan" . Ang aming mga komprehensibong paksa ay tutulong sa iyo na malampasan ang mga paghihirap sa mga static na variable at gawin mong mahalin ang mga ito, hindi mapoot:
Iyon pa lang, ang ilang iba pang mga konsepto ay maaaring matunaw ang iyong utak. Halimbawa, ang Generics ay lumilitaw na isa sa mga pinaka-nakakaiyak na bahagi para sa maraming mag-aaral. Binabanggit ng iba na ang mga multi-thread na konsepto, katutubong interface, polymorphism, Apt na pagpapatupad ng Pag-synchronize at Serialization, at paggamit ng Vectors at Matrix ay ang mga aspeto din na malamang na pagagalitan mo.
Konklusyon
Ang Java ay malawak, at maaaring mayroong maraming aspeto na maaaring nanliligalig sa isang tao. Ngunit, kasama nito, ang Java ay nababaluktot, at maraming paraan upang malutas ang parehong hamon. Kaya, kung natigil ka, subukang mag-isip tungkol sa iba pang mga hakbang upang malutas ang problema. Ang Java ay masaya, at ang mga hamon sa code nito ay makakatulong sa iyong maging mas mahusay at may tiwala sa sarili. Tandaan na kung ikaw ay isang ganap na baguhan sa mundo ng IT, ang pag-aaral ng mga pangunahing kaalaman sa Java ay ang unang hakbang. Ngunit ang isa pang magandang hakbang ay ang kumonekta sa mga batikang developer at kapwa nag-aaral ng Java na tulad mo. Syempre, tutulungan ka ng CodeGym na dumaan sa mga pinaka-mapaghamong paksa, ngunit kung natamaan mo ang isang dead-end, maaaring maging kapaki-pakinabang ang mga komunidad ng Java. At sa wakas, ang huling bahagi ng matagumpay na pag-aaral ay pagsasanay. Kung gusto mong matuto ng Java programming nang mabilis at madali, ang pagkuha ng maraming pagsasanay sa coding ay higit na nakakatulong. Para sa isang dedikadong tao (na walang paunang karanasan sa programming), maaaring tumagal lamang ng 9-12 buwan upang maunawaan ang Java at ganap na magsimulang magsulat ng mga programa. Kaya, bumaba na tayo para magpraktis!
Gayunpaman, kahit na ang pinaka-masigasig na mga mag-aaral ay maaaring humarap sa mga paghihirap. Ang mga pinaka-mapaghamong paksa at ang pinakamahusay na paraan upang "madaig" ang mga ito ay inilarawan sa ibaba.
GO TO FULL VERSION