Tartalom
- Osztályok és objektum-orientált programozás megértése
- Új osztály létrehozása
- Viselkedés hozzáadása
- Mint nyulak
- Fibonacci
- Hova megyünk innen? Hogyan lehet megtanulni a C # alkalmazást Androidra
A C # tanulásáról szóló Android oktató sorozat egyik részében a C # programozás abszolút alapjait vizsgáltuk meg. Lefedtük a módszereket (kódcsoportokat, amelyek meghatározott feladatokat hajtanak végre), néhány alapszintű szintaxist (például az semleges kettőspont igénye), a változókat (az adatokat tároló tárolók) és az „if utasításokat” az áramlásvezérléshez (az értéktől függő elágazó kód) változók). Láttuk azt is, hogyan lehet a változókat, például a karakterláncokat argumentumként átadni a módszerek között.
Menjen vissza, és nézzen rá, ha még nem olvasta.
Ezen a ponton képesnek kell lennie arra, hogy elkészítsen néhány alapkonzol-alkalmazást, például vetélkedõket, adattároló alkalmazásokat vagy számológépeket.
A második részben kicsit ambiciózusabbá válunk, bemutatunk még néhány alapot - például hurkokat -, és megvizsgáljuk, hogyan lehet az osztályokat létrehozni és azokkal kölcsönhatásba lépni. Ez azt jelenti, hogy képesek leszünk megfigyelni az Android fejlesztését, és megnézhetjük, hogyan lehet áthidalni ezt a rést. Folytassa az olvasást, ha valóban meg akarja tanulni a C # -ot!
Osztályok és objektum-orientált programozás megértése
Az első részben röviden elmagyaráztuk az objektum-orientált programozás alapjait, amely a nyelvek körül az „osztályok” használatával forog az „objektumok” leírására. Az objektum olyan adat, amely sok dolgot reprezentálhat. Lehet, hogy szó szerinti tárgy egy játékvilágban, mint például egy rugó, vagy valami elvontabb, például olyan menedzser, aki kezeli a játékos eredményét.
Egy osztály létrehozhat több objektumot. Így lehet, hogy írsz egy „ellenséges” osztályt, de képes lesz egy rossz szintű terepet létrehozni. Ez az objektum-orientált programozás egyik legnagyobb előnye. Ellenkező esetben az ellenségek sokaságának viselkedésének egyetlen módja az lenne, hogy sok egyedi módszert használna, amelyek mindegyike tartalmaz utasításokat arra vonatkozóan, hogy a rossz fiú hogyan viselkedjen különböző körülmények között.
Ha ez még mindig kicsit trükkös, hogy megkerülje a fejét, akkor csak annyit kell tudnia, hogy a tárgyak tulajdonságokkal és viselkedéssel bírnak. Ez olyan, mint a valódi tárgyak. Például egy nyúl olyan tulajdonságokkal rendelkezik, mint a méret, szín és név; és magatartása van, például ugrás, ülés és evés. A tulajdonságok alapvetően változók, a viselkedés módszerek.
A program, amelyet az elmúlt órában készítettünk, egy példa egy osztályra is. Az itt tárgyalt „objektum” valamilyen jelszó-ellenőrző rendszer. A tulajdonsága a UserName karakterlánc, a viselkedése pedig a NewMethod (a felhasználó nevének ellenőrzése és üdvözlés).
Ha igenmég mindig kicsit zavaró, a fejünk körüljuttatásának egyetlen módja az, ha új vagy két osztályt létrehozunk magunk!
Új osztály létrehozása
Ha C # -ot fog tanulni, akkor tudnia kell, hogyan kell új osztályokat készíteni. Szerencsére ez nagyon egyszerű. Csak kattintson a Projekt menü elemre, majd válassza a „+ Osztály hozzáadása” menüpontot.
Válassza a „C #” -ot, és nevezze „Nyúl” -nak. Ezt az osztályt fogjuk használni fogalmi nyulak készítésére. Egy pillanat alatt meglátja, mit gondolok.
Ha benézi a jobb oldali Solution Explorer alkalmazást, látni fogja, hogy egy új Rabbit.cs nevű fájlt hoztak létre közvetlenül a Program.cs alatt. Jól elvégzett - ez az egyik legfontosabb dolog, amit tudni kell, ha meg akarod tanulni a C # -ot az Androidra!
Az új Rabbit.cs fájl ugyanazzal a „kazánlemez” kóddal rendelkezik, mint korábban. Még mindig ugyanahhoz a névtérhez tartozik, és van egy osztálya, azonos nevű, mint a fájl.
névtér ConsoleApp2 {class Rabbit {}}
Most nyúlunknak adunk néhány tulajdonságot, amit „konstruktornak” hívunk.
A konstruktor egy olyan módszer egy osztályban, amely inicializálja az objektumot, lehetővé téve a tulajdonságok meghatározását az első létrehozáskor. Ebben az esetben a következőket fogjuk mondani:
névtér ConsoleApp2 {class Rabbit {nyilvános string RabbitName; nyilvános húr RabbitColor; public int RabbitAge; public int RabbitWeight; nyilvános nyúl (karakterlánc neve, karakterlánc színe, kora, súlya) {RabbitName = név; RabbitColor = szín; RabbitAge = életkor; RabbitWeight = súly; }}}
Ez lehetővé teszi számunkra, hogy új nyulat készítsünk egy másik osztályból, és a tulajdonságait úgy definiáljuk, mint mi:
Nyúl Rabbit1 = új Nyúl („Jeff”, „barna”, 1, 1);
Most rájöttem, hogy visszatekintve a súlynak valószínűleg úszónak vagy duplanak kellett lennie, hogy tizedesjegyek lehessenek, de megkapod az ötletet. A nyúlunkat a legközelebbi egész számra kerekítjük.
Látni fogja, amint kiírja a nyulat, és megkérdezi a helyes érvek átadását. Ilyen módon az osztályod szinte a kód részévé vált.
Hidd el vagy sem, ez a kód nyúlot hozott létre! Nem látod a nyuladat, mert nincs grafika, de ott van.
És ennek bizonyításához használhatja ezt a sort:
Console.WriteLine (Rabbit1.RabbitName);
Ez elmondja neked az imént létrehozott nyúl nevét!
Ugyancsak növelhetjük nyúlunk súlyát, például:
Rabbit1.RabbitWeight ++; Console.WriteLine (Rabbit1.RabbitName + "súlya" + Rabbit1.RabbitWeight + "kg");
Itt ne feledje, hogy valami végére a „++” megadásával fokozatosan növeli annak értékét (Írhat „RabbitWeight = RabbitWeight + 1”).
Mivel osztályunk annyi nyulat készíthet, amennyit csak akarunk, sok különböző nyulat készíthetünk, mindegyiknek megvan a saját tulajdonságai.
Viselkedés hozzáadása
Ezután dönthetünk úgy is, hogy a nyulainknak valamilyen magatartást tanúsítunk. Ebben az esetben engedjük enni.
Ehhez létrehozzunk egy nyilvános módszert, az úgynevezett „Eat” elnevezést, amely evő hangot ad, miközben fokozatosan növeli a nyúl súlyát:
public void Eat () {Console.WriteLine (RabbitName + ": Nibble nibble!"); RabbitWeight ++; }
Ne feledje, hogy a „nyilvános” az osztályon kívülről elérhető, az „érvénytelen” azt jelenti, hogy a módszer nem ad vissza adatot.
Ezután a Program.cs belsejéből meghívhatjuk ezt a módszert, és ez a választott nyúlnak enni fog és nagyobb lesz:
Console.WriteLine (Rabbit1.RabbitName + "súlya" + Rabbit1.RabbitWeight + "kg"); Rabbit1.Eat (); Rabbit1.Eat (); Rabbit1.Eat (); Console.WriteLine (Rabbit1.RabbitName + "súlya" + Rabbit1.RabbitWeight + "kg");
Ez azt okozza, hogy Jeff háromszor enni fog, aztán meghalljuk, és láthatjuk, hogy megnőtt! Ha újabb nyúl lenne a színpadon, akkor enni is lehessen!
Console.WriteLine (Rabbit1.RabbitName + "súlya" + Rabbit1.RabbitWeight + "kg"); Console.WriteLine (Rabbit2.RabbitName + "súlya" + Rabbit2.RabbitWeight + "kg"); Rabbit1.Eat (); Rabbit1.Eat (); Rabbit2.Eat (); Rabbit2.Eat (); Rabbit1.Eat (); Console.WriteLine (Rabbit1.RabbitName + "súlya" + Rabbit1.RabbitWeight + "kg"); Console.WriteLine (Rabbit2.RabbitName + "súlya" + Rabbit2.RabbitWeight + "kg");
Mint nyulak
Ez nem különösebben elegáns módszer sok objektum kezelésére, mivel manuálisan kell kiírnunk az egyes nyulakra vonatkozó parancsokat, és nem tudjuk dinamikusan növelni a nyulak számát, amennyire csak akarunk. Nem csak a C # -ot akarjuk megtanulni - meg akarjuk tanulni a tiszta C # -kód írását is!
Ezért használhatunk egy listát. A lista gyűjtemény; maga a változó, amely alapvetően hivatkozik más változókra. Ebben az esetben elkészíthetjük a nyulak listáját, és a jó hír az, hogy ezt nagyon könnyű megérteni:
Lista Ez létrehozza az új nyúlot, mint korábban, de ezzel egyidejűleg hozzáadja a nyulat a listához. Ugyanígy mondhatjuk ezt: Rabbit Rabbit3 = új nyúl ("Jonny", "narancs", 1, 1); RabbitList.Add (Rabbit3); Akárhogy is, létrehoztak egy objektumot, és hozzáadták a listához. A nyulakat tartalmazó listánkból kényelmesen és elegánsan is visszatérhetjük az információkat: foreach (vari Nyúl a RabbitList-ben) {Console.WriteLine (Rabbit.RabbitName + "súlya" + Rabbit.RabbitWeight + "kg"); } Mint lehet, hogy kitalálhatja, az „foreach” azt jelenti, hogy egyszer megismétel egy lépést a lista minden elemére. Az információkat a következőkből is beolvashatja a listájából: RabbitList.Eat (); Itt az „1” az index, azaz az első helyen tárolt információkra vonatkozik. Amint történik, valójában ez a második nyúl, amelyet hozzáadtál: mert a programozási listák mindig 0-nál kezdődnek. Abban az esetben, ha még nem gondolta volna, most ezeket az információkat fogjuk felhasználni Fibonacci-sorozat létrehozására. Végül is, ha az Androidon C # -ot tanul, akkor képesnek kell lennie arra, hogy valami érdekeset megcsináljon az egész elmélettel! Fibonacci
A Fibonacci sorozatban a nyulakat egy szobában zárják be és hagyják, hogy tenyésztjenek. Egy hónap elteltével szaporodhatnak, amely időpontban szexuálisan érett (nem tudom megerősíteni, hogy ez helyes-e a nyúlbiológiának). Ha az egyes nyúlpárok havonta egyszer képesek termelni két utódot, az alábbiak szerint néz ki:
1,1,2,3,5,8,13,21,34
Varázslatosan a sorozatban szereplő számok az előző két szám összesített értéke. A tudomány szerint ez nagyszerű dolog.
A remek dolog, hogy megismételhetjük ezt.
Először be kell vezetnünk egy új koncepciót: a hurkot. Ez egyszerűen újra és újra megismétli ugyanazt a kódot, amíg egy feltétel teljesül. A „for” hurok lehetővé teszi, hogy ezt úgy hozzuk létre, hogy létrehozunk egy változót, beállítjuk a feltételeket, amelyeknek megfelelnünk akarunk, majd működtetjük rajta - mind a belső zárójelben megadva:
(int hónapok = 0; hónapok <100; hónapok ++) {// Csinálj valamit}
Tehát létrehozunk egy egész számot, amelyet hónapoknak hívunk, és addig hurkoljuk, amíg 100-ig nem lesz. Akkor növeljük a hónapok számát egyvel.
Szeretné megtudni, hogy ez hogyan válhat Fibonacci szekvenciává? Íme:
névtér ConsoleApp2 {osztály Program {statikus void Fő (karakterláncok) {Lista Oké, ez nehezebb volt, mint gondoltam! Nem megyek mindezen keresztül, de a már megtanultak alapján képesnek kell lennie arra, hogy megújítsd. Határozottan elegánsabb módon lehet ezt megtenni - nem vagyok matematikus. Úgy gondolom azonban, hogy ez egy elég szórakoztató gyakorlat, és ha egyszer megteheti, készen áll a nagy időre. Nagyon szeretném látni bármilyen más megközelítést! Az öv alatti ismeretekkel készen állsz nagyobb dolgokra. Különösen készen áll arra, hogy megbeszélje az Android programozását a C # segítségével Xamarinban vagy a Unity-ban.Hova megyünk innen? Hogyan lehet megtanulni a C # alkalmazást Androidra
Ez azért különbözik, mert a Google, a Microsoft és a Unity által biztosított osztályokat fogja használni. Amikor valami olyat ír, mint a „RigidBody2D.velocity”, akkor az az tulajdonság elérése, amelyet egy osztály hívott RigidBody2D. Ez ugyanúgy működik, az egyetlen különbség az, hogy nem látja a RigidBody2D-t, mert nem saját maga készítette el.
Ha ezt a C # -ot az öved alatt készen állsz arra, hogy ugorj be ezen lehetőségek egyikébe, és nagy előnyt kell kapnod a dolgok megértésekor:
- Hogyan készítsünk egy Android alkalmazást a Xamarin segítségével
- Készítsd el legelső Android játékod 7 perc alatt az Unity segítségével
Egy közelgő leckében azt is megvizsgáljuk, hogyan lehet felfordulni, és hogyan használhatja ehelyett a Windows alkalmazásokat!
