Nilalaman
- Pag-unawa sa mga klase at oriented na pag-programming ng object
- Lumilikha ng isang bagong klase
- Pagdaragdag ng mga pag-uugali
- Sa mga ito tulad ng mga kuneho
- Fibonacci
- Saan tayo pupunta galing dito? Paano matutunan ang C # para sa Android
Sa bahagi ng isa sa seryeng ito ng Android tutorial sa pag-aaral ng C #, tiningnan namin ang ganap na mga pangunahing kaalaman ng C # programming. Sinakop namin ang mga pamamaraan (mga pangkat ng code na nagsasagawa ng mga tukoy na gawain), ilang mga pangunahing syntax (tulad ng pangangailangan para sa mga semi colon), variable (mga lalagyan na nag-iimbak ng data), at "kung ang mga pahayag" para sa control flow (branching code na nakasalalay sa mga halaga ng mga variable). Nakita din namin kung paano ipasa ang mga variable tulad ng mga string bilang mga argumento sa pagitan ng mga pamamaraan.
Dapat kang bumalik at tingnan kung hindi mo pa ito nabasa.
Sa puntong ito, dapat kang gumawa ng ilang mga pangunahing apps ng console, tulad ng mga pagsusulit, mga app na nag-iimbak ng data, o mga calculator.
Sa bahagi ng dalawa, makakakuha tayo ng kaunting mapaghangad, na sumasakop sa ilang higit pang mga pangunahing kaalaman - tulad ng mga loop - at paggalugad kung paano lumikha at makihalubilo sa mga klase. Nangangahulugan ito na magsisimula kaming magsaksak sa pag-unlad ng Android at makita kung paano tulay ang puwang na iyon. Magpatuloy sa pagbabasa kung nais mong tunay na malaman ang C #!
Pag-unawa sa mga klase at oriented na pag-programming ng object
Sa madaling sabi sa bahagi ng isa, ipinaliwanag namin ang mga pangunahing kaalaman ng Programa ng Object Orient Programming, na umiikot sa mga wika gamit ang "mga klase" upang ilarawan ang "mga bagay." Ang isang bagay ay isang piraso ng data, na maaaring kumakatawan sa maraming mga bagay. Maaari itong maging isang literal na bagay sa isang mundo ng laro tulad ng tagsibol, o maaaring maging isang bagay na mas abstract, tulad ng isang tagapamahala na humahawak sa marka ng manlalaro.
Ang isang solong klase ay maaaring lumikha ng maraming mga bagay. Kaya maaari mong isulat ang isang "kaaway" na klase, ngunit magagawang makabuo ng isang buong antas na puno ng mga masasamang tao. Ito ay isa sa mga malaking benepisyo ng paggamit ng object oriented programming. Kung hindi, ang tanging paraan upang mahawakan ang pag-uugali ng maraming mga kaaway ay ang paggamit ng maraming mga indibidwal na pamamaraan, ang bawat isa ay naglalaman ng mga tagubilin para sa kung paano dapat kumilos ang masamang tao sa iba't ibang mga pangyayari.
Kung ito ay medyo mahirap hawakan upang mapalingon ang iyong ulo, ang kailangan mo lang malaman ay ang mga bagay ay may mga katangian at pag-uugali. Ito ay tulad ng mga tunay na bagay. Halimbawa, ang isang kuneho ay may mga katangian tulad ng laki, kulay, at pangalan; at mayroon itong pag-uugali, tulad ng paglukso, pag-upo, at pagkain. Mahalaga, ang mga katangian ay mga variable at pag-uugali ay mga pamamaraan.
Ang program na binuo natin sa huling aralin ay isang halimbawa din ng isang klase. Ang "object" na inilalarawan namin dito ay ilang uri ng system ng control ng password. Ang pag-aari nito ay ang stringNgName, at ang pag-uugali nito ay ang NewMethod (pagsusuri sa pangalan ng gumagamit at batiin sila).
Kung iyonpa rin medyo nakalilito, ang tanging paraan upang mapunta ang ating mga ulo sa paligid ay lumikha ng isang bagong klase o dalawa sa ating sarili!
Lumilikha ng isang bagong klase
Kung matututunan mo ang C #, kailangan mong malaman kung paano gumawa ng mga bagong klase. Sa kabutihang palad, ito ay napakadali. I-click lamang ang item ng menu ng Proyekto at pagkatapos ay piliin ang "+ Magdagdag ng Klase."
Piliin ang "C #" at tawagan itong "Kuneho." Gagamitin namin ang klase na ito upang lumikha ng mga kuneho ng konsepto. Makikita mo kung ano ang ibig kong sabihin.
Kung tseke mo sa iyong Solution Explorer sa kanan, makikita mo na ang isang bagong file na tinatawag na Rabbit.cs ay nilikha mismo sa ilalim ng Program.cs. Magaling - iyon ang isa sa mga pinakamahalagang bagay na malaman kung nais mong malaman ang C # para sa Android!
Ang bagong file ng Rabbit.cs ay may ilan sa parehong parehong "boilerplate" code tulad ng dati. Ito ay kabilang pa rin sa parehong namespace, at mayroon itong isang klase na may parehong pangalan ng file.
namespace ConsoleApp2 {klase Kuneho {}}
Ngayon ay bibigyan namin ang aming mga kuneho ng ilang mga pag-aari sa tinatawag naming "tagabuo."
Ang isang tagapagtayo ay isang pamamaraan sa isang klase na paunang paunang bagay, na nagpapahintulot sa amin na tukuyin ang mga katangian nito kapag una nating nilikha ito. Sa kasong ito, narito ang sasabihin namin:
namespace ConsoleApp2 {class Rabbit {public string RabbitName; pampublikong string RabbitColor; pampublikong int RabbitAge; pampublikong int RabbitWeight; pampublikong Kuneho (String name, String color, int age, int weight) {RabbitName = pangalan; RabbitColor = kulay; RabbitAge = edad; RabbitWeight = bigat; }}}
Pinapayagan kaming lumikha ng isang bagong kuneho mula sa ibang klase, at tukuyin ang mga katangian nito tulad ng ginagawa namin:
Kuneho Kuneho1 = bagong Kuneho ("Jeff", "kayumanggi", 1, 1);
Ngayon napagtanto ko sa pagbabalik ng timbang ay marahil ay naging isang float o isang doble upang payagan ang mga decimals, ngunit nakuha mo ang ideya. Kami ay iikot ang aming kuneho sa pinakamalapit na buong bilang.
Makikita mo habang isinusulat mo ang iyong kuneho, sasabihan ka na ipasa ang mga tamang argumento. Sa ganitong paraan, ang iyong klase ay naging isang bahagi ng code halos.
Maniwala ka man o hindi, ang code na ito ay lumikha ng isang kuneho! Hindi mo makita ang iyong kuneho dahil wala kaming mga graphic, ngunit nariyan ito.
At upang mapatunayan ito, maaari mo na ngayong gamitin ang linyang ito:
Console.WriteLine (Rabbit1.RabbitName);
Sasabihin nito sa iyo ang pangalan ng kuneho na nilikha mo lang!
Maaari rin nating madagdagan ang bigat ng ating Kuneho, tulad ng:
Rabbit1.RabbitWeight ++; Console.WriteLine (Rabbit1.RabbitName + "may timbang" + Rabbit1.RabbitWeight + "kg");
Tandaan dito na ang pagdaragdag ng "++" sa pagtatapos ng isang bagay ay madadagdagan ang pagtaas ng halaga nito sa pamamagitan ng isa (Maaari mo ring isulat ang "RabbitWeight = RabbitWeight + 1").
Dahil ang aming klase ay maaaring gumawa ng maraming mga rabbits na gusto namin, maaari kaming lumikha ng maraming iba't ibang mga rabbits, bawat isa ay may sariling mga pag-aari.
Pagdaragdag ng mga pag-uugali
Maaari din nating piliin na bigyan ang aming mga kuneho ng ilang uri ng pag-uugali. Sa kasong ito, hayaan silang kumain.
Upang gawin ito, gagawa kami ng isang pampublikong pamamaraan na tinatawag na "Kumain," at gagawa ito ng tunog ng pagkain, habang dinadagdagan ang pagtaas ng bigat ng kuneho:
pampublikong walang bisa Kumain () {Console.WriteLine (RabbitName + ": Nibble nibble!"); RabbitWeight ++; }
Tandaan, "publiko" ay nangangahulugang maa-access mula sa labas ng klase, at "walang bisa" ay nangangahulugang ang pamamaraan ay hindi ibabalik ang anumang data.
Pagkatapos, mula sa loob ng Program.cs, magagawa naming tawagan ang pamamaraang ito at gagawin nitong kunin ang aming pinili na kumain at mas malaki:
Console.WriteLine (Rabbit1.RabbitName + "may timbang" + Rabbit1.RabbitWeight + "kg"); Rabbit1.Eat (); Rabbit1.Eat (); Rabbit1.Eat (); Console.WriteLine (Rabbit1.RabbitName + "may timbang" + Rabbit1.RabbitWeight + "kg");
Iyon ang magiging dahilan upang kumain si Jeff ng tatlong beses, pagkatapos ay maririnig natin ito at makita na mas malaki ang nakuha niya! Kung mayroon kaming ibang kuneho sa eksena, makakain din sila!
Console.WriteLine (Rabbit1.RabbitName + "may timbang" + Rabbit1.RabbitWeight + "kg"); Console.WriteLine (Rabbit2.RabbitName + "may timbang" + Rabbit2.RabbitHusay + "kg"); Rabbit1.Eat (); Rabbit1.Eat (); Rabbit2.Eat (); Rabbit2.Eat (); Rabbit1.Eat (); Console.WriteLine (Rabbit1.RabbitName + "may timbang" + Rabbit1.RabbitWeight + "kg"); Console.WriteLine (Rabbit2.RabbitName + "may timbang" + Rabbit2.RabbitHusay + "kg");
Sa mga ito tulad ng mga kuneho
Hindi ito isang partikular na matikas na paraan upang mahawakan ang maraming mga bagay, dahil kailangan nating isulat ang mga utos para sa bawat kuneho nang manu-mano at hindi dinadagdagan ang bilang ng mga rabbits hangga't gusto natin. Hindi lamang namin nais na malaman C # - nais naming malaman kung paano magsulat ng malinis na C # code!
Ito ang dahilan kung bakit maaari nating gamitin ang isang listahan. Ang isang listahan ay isang koleksyon; variable mismo na karaniwang naglalaman ng mga sanggunian sa iba pang mga variable. Sa kasong ito, maaari kaming gumawa ng isang listahan ng mga Kuneho, at ang mabuting balita ay napakadaling maunawaan:
Listahan Lumilikha ito ng bagong kuneho tulad ng dati, ngunit sabay-sabay na nagdaragdag ng kuneho sa listahan. Pareho, maaari nating sabihin ito: Kuneho Kuneho3 = bagong Kuneho ("Jonny", "orange", 1, 1); RabbitList.Add (Rabbit3); Alinmang paraan, ang isang bagay ay nilikha at idinagdag sa listahan. Maaari din naming maginhawa at matikas na ibalik ang impormasyon mula sa aming listahan ng mga rabbits sa ganitong paraan: noo (var Kuneho sa RabbitList) {Console.WriteLine (Rabbit.RabbitName + "timbang" + Kuneho.RabbitWeight + "kg"); } Tulad ng maaari mong malaman, "nauna" ay nangangahulugang ulitin mo ang isang hakbang minsan para sa bawat item sa listahan. Maaari mo ring makuha ang impormasyon mula sa iyong listahan tulad nito: RabbitList.Eat (); Narito ang "1" ay ang index, ibig sabihin ay tinutukoy mo ang impormasyong nakaimbak sa posisyon ng isa. Tulad ng nangyari, iyon talaga pangalawa kuneho na iyong idinagdag kahit na: dahil ang mga listahan sa programming ay laging nagsisimula sa 0. Kung hindi mo pa nahulaan, gagamitin namin ngayon ang lahat ng impormasyong ito upang lumikha ng pagkakasunud-sunod ng Fibonacci. Pagkatapos ng lahat, Kung natututo ka ng C # para sa Android, dapat mong talagang gumawa ng isang bagay na kawili-wili sa lahat ng teorya na iyon! Fibonacci
Sa pagkakasunud-sunod ng Fibonacci, ang mga rabbits ay nakasara sa isang silid at iniwan upang mag-breed. Maaari silang magparami pagkatapos ng isang buwan, kung saan sila ay sekswal na may edad (hindi ko makumpirma kung tama ang Rabbology biology). Kung ang bawat mag-asawa na kuneho ay maaaring makagawa ng isang beses bawat buwan mula noon, paggawa ng dalawang anak, narito ang hitsura ng pagkakasunud-sunod:
1,1,2,3,5,8,13,21,34
Napakaganda, ang bawat numero sa pagkakasunud-sunod ay ang halaga ng nakaraang dalawang numero na idinagdag nang magkasama. Ayon sa agham, ito ay uri ng isang malaking pakikitungo.
Ang cool na bagay, maaari naming kopyahin iyon.
Una, kailangan nating ipakilala ang isang bagong konsepto: ang loop. Paulit-ulit nitong paulit-ulit ang parehong code hanggang sa matugunan ang isang kondisyon. Ang "para sa" loop ay nagbibigay-daan sa amin na gawin ito sa pamamagitan ng paglikha ng isang variable, pagtatakda ng mga kondisyon na nais naming matugunan, at pagkatapos ay operating sa ito - lahat ng tinukoy sa loob ng mga bracket:
para sa (int buwan = 0; buwan <100; buwan ++) {// Gumawa ng isang bagay}
Kaya lumilikha kami ng isang integer na tinatawag na mga buwan, at pag-loop hanggang sa katumbas ito ng 100. Pagkatapos ay dagdagan namin ang bilang ng mga buwan ng isa.
Nais mong makita kung paano ito maaaring maging isang pagkakasunud-sunod ng Fibonacci? Narito:
namespace ConsoleApp2 {Program Program {static void Main (string args) {Listahan Okay, iyon ay mahirap kaysa sa naisip ko! Hindi ko na madadaan ang lahat ng ito, ngunit gamit ang natutunan mo, dapat mong baligtarin ang inhinyero. Mayroong talagang mas matikas na paraan ng paggawa nito - Hindi ako matematiko. Gayunpaman, sa palagay ko ito ay isang medyo masaya na ehersisyo, at sa oras na magawa mo ito, handa ka na sa malaking oras. Gusto kong makita ang anumang iba pang mga diskarte, sa pamamagitan ng paraan! Sa lahat ng kaalamang ito sa ilalim ng iyong sinturon, handa ka nang magsimula sa mas malalaking bagay. Sa partikular, handa kang kumuha ng saksak sa pag-programming ng Android na may C # sa Xamarin o Unity.Saan tayo pupunta galing dito? Paano matutunan ang C # para sa Android
Iba ito dahil gumagamit ka ng mga klase na ibinigay ng Google, Microsoft, at Pagkakaisa. Kapag nagsulat ka ng isang bagay tulad ng "RigidBody2D.velocity" kung ano ang iyong ginagawa ay pag-access ng isang ari-arian mula sa isang klase tinawag RigidBody2D. Pareho lang ito gumagana, ang pagkakaiba-iba lamang ay hindi mo makita ang RigidBody2D dahil hindi mo ito mismo itinayo.
Sa ilalim ng C # sa ilalim ng iyong sinturon, dapat kang maging handa na tumalon sa alinman sa mga pagpipiliang ito at magkaroon ng isang malaking pagsisimula sa ulo pagdating sa pag-unawa sa kung ano ang nangyayari:
- Paano gumawa ng isang Android app na may Xamarin
- Buuin ang iyong pinakaunang laro ng Android sa 7 minuto kasama ang Unity
Sa paparating na aralin, titingnan din namin kung paano ka makakapag-U-turn at gamitin ito upang bumuo ng mga Windows apps sa halip!
