Tartalom

• Gyors bevezetés - C # vs Java
• Helló Világ! a C #
• Az első lépések a C # módszerrel és osztályokkal
• Módszerek használata
• A változók használata
• Érvek átadása és karakterláncok használata
• Tanulja meg a C # áramlásszabályozást és készítsen egyszerű vetélkedőket!
• Legközelebb

Ebben a bejegyzésben megismerheti az Android C # programozását, valamint azt, hogy hol illeszkedik az Android fejlesztés nagy rendszeréhez.

Ha szeretne Android-fejlesztővé válni, akkor az a benyomásod támadhat, hogy meg kell tanulnia a két nyelv egyikét: Java vagy Kotlin. Ez az a két nyelv, amelyet az Android Studio hivatalosan támogat, ezért a két nyelvre sok útmutató és oktatóanyag összpontosít. Az Android fejlesztése sokkal rugalmasabb és változatosabb, és sokkal többféle módon lehet megközelíteni. Ezek közül sokban tartalmaz C # -et.

Olvas:Fejleszteni akarok Android-alkalmazásokat - mely nyelveket kell megtanulnom?

A C # az a programozási nyelv, amelyet akkor használ, ha úgy dönt, hogy játékot épít a Unity-ban - ami szintén a Play Store áruház legnépszerűbb és legszélesebb körben alkalmazott játékmotorja. Általában hasznos megtanulni a C # programozást, ha egyáltalán érdekli a játék fejlesztése.

A C # programozást is meg kell tanulnia, ha Xamarint szeretne használni. A Xamarin egy olyan eszköz, amely lehetővé teszi a fejlesztőknek, hogy a Visual Studio segítségével olyan alkalmazásokat készítsenek, amelyeket könnyen át lehet vinni iOS-ra és Android-ra egyaránt, tökéletes platformok közötti projektekhez.

Tehát, amivel ezt mondhatjuk, határozottan indokolt megtanulni a C # programozást az Androidra. Vessen egy pillantást arra, amit tudnia kell.

Gyors bevezetés - C # vs Java

A C # objektum-orientált programozási nyelv, amelyet a Microsoft 2000 körül fejlesztett ki azzal a céllal, hogy modern, egyszerű és rugalmas legyen. A Javahoz hasonlóan (amelyet a Sun Microsystem fejlesztett ki 1990-ben), eredetileg a C ++ -ból alakult ki, biztosítva, hogy sok hasonlóság legyen a kettő között. Például, mindkettő ugyanazt a „szintaktikai alapot” használja, ami azt jelenti, hogy ténylegesen ugyanazt a terminológiát és szerkezetet használják. Van néhány kisebb különbség, de ha ismeri az egyik nyelvet, akkor képesnek kell lennie a sok más nyelv megértésére anélkül, hogy kifejezetten meg kellett volna tanulnia. A kezdők számára azonban sokan úgy találják, hogy a C # programozás kissé könnyebb megtanulni.

Objektum-orientált nyelvként mind a C #, mind a Java leírja az objektumokat osztályokon keresztül. Ez egy moduláris megközelítés a programozáshoz, amely lehetővé teszi a kódrészletek újra és újra használatát.

Ahol a C # eltér a Java-tól, a küldöttek használata, az eseményhallgatáshoz való megközelítése, a virtuális és a végső tulajdonságok, az implicit casting stb.

A jó hír: valójában nem kell tudnia, hogy mit jelent ez a legtöbb, amikor először kezdi el tanulni a C # -ot. A fő elvitel az, hogy a szerkezet csak egy kicsit könnyebb megtanulni a C # -ben, és általában kevesebb gépelést igényel. Ez különösen igaz, ha figyelembe vesszük a Java for Android használatát, akkor meg kell ismerkednünk az Android alkalmazások elkészítéséhez szükséges számos osztálytal és API-vel. Így megtanulhatja a C # programozást is, mint egy lépést a Java felé.

Helló Világ! a C #

A kódolás világában az a hagyomány, hogy minden alkalommal, amikor új nyelvet tanul, el kell készítenie egy egyszerű programot, amely a „Hello World!” Feliratot jeleníti meg a képernyőn. Ez alapvetően biztosítja, hogy képes legyen a szükséges eszközök üzembe helyezésére és futtatására, valamint valami egyszerű összeállítására. Olyan, mintha a „tesztelés, tesztelés, 1, 2, 3” olvasása a mikrofonba lenne!

Ebben az esetben a Visual Studio használatával fogjuk létrehozni egy konzol alkalmazást. Tehát, ha már előre lépett és letöltötte a Visual Studio alkalmazást (ingyenes), kattintson:

Fájl> Új> Projekt

És akkor:

Visual C #> Windows Classic Desktop> Konzol alkalmazás (.NET-keretrendszer)

Így építhetünk egy alkalmazást, amely futni fog a Windows konzolon.

Ha ez megtörténik, akkor a projekt csupasz csontok szerkezete megjelenik a főablakban. A következő kóddal látják el Önt:

névtér ConsoleApp3 {osztály Program {statikus érvénytelen Fő (karakterlánc) {}}}

Most egyszerűen adjon hozzá két sort, például így:

névtér ConsoleApp3 {osztályprogram {statikus érvénytelen Fő (karakterlánc) {Console.WriteLine ("Hello World!"); Console.ReadKey (); }}}

Ez a „Hello World!” Szöveget írja a képernyőre, majd megvárja a gomb megnyomását. Amint a felhasználó megérinti bármelyik gombot, a program véget ér, és automatikusan kilép.

Vegye figyelembe, hogy mindkét sor pontosvesszővel ér véget. Ennek oka az, hogy a C # -ben szereplő bármely állítás pontosvesszővel végződik, amely a C # -val közli, hogy a sor befejeződött (ugyanaz a Java-ban). Az egyetlen kivétel az, amikor a sort közvetlenül egy nyitott zárójel követi, amelyet egy pillanat alatt elmagyarázunk.

Nyomja meg a képernyő tetején található „Start” gombot, és ennek el kell indítania az alkalmazást, lehetővé téve ezzel a gyakorlatban történő megjelenést.

Az osztályok olyan kóddarabok, amelyek leírják az objektumokat, és amelyek ténylegesen adatdarabok

Szóval, mi folyik itt pontosan?

Az első lépések a C # módszerrel és osztályokkal

A C # programozás megtanulásához Androidon meg kell értenie az osztályokat és a módszereket.

Az osztályok olyan kóddarabok, amelyek leírják az objektumokat, és amelyek ténylegesen adatdarabok. Ezért nem kell sokat aggódnia ennél: csak tudd, hogy a jelenleg használt kódoldalt „osztálynak” nevezik, és a projektben más osztályokkal is kapcsolatba léphet. A projektnek csak egy osztálya lehet, az összes kódja innen működik, vagy több is lehet.

Mindegyik osztályon belül módszerekkel is rendelkezik. Ezek a módszerek olyan kódrészletek, amelyekre bármikor hivatkozhatunk az osztályon belül - és néha az osztályon kívül is.

Ebben az esetben az osztályt hívják Program. Ezt közvetlenül a tetején határozza meg a sor: „Program Program”. És ha kinyitja a jobb oldalon található „Megoldáskezelő” ablakot, akkor megtalálja a Program.cs fájlt. Az osztály neve mindig megegyezik a fájlnévvel.

Ezután egy göndör zárójelet használunk, hogy az összes következő kódot tartalmazza. A göndör zárójelek azt mondják, hogy minden, ami követi, összetartozik. Így mindaddig, amíg a konzol bezáródik, az összes alábbi kód a Program része.

Ezt követi az első módszerünk, amelyet a következő sor határoz meg:

statikus érvénytelen Fő (karakterlánc)

Ezt követõen nyitottabb zárójelek követik, ami azt jelenti, hogy a következõ kódrész a „Main” módszer részét képezi (amely továbbra is a Program osztályon belül van). És oda állítottuk a "Hello World" -et.

A „statikus érvénytelenség” lényegében azt mondja nekünk, hogy ez a módszer valami önmagát hajtja végre (ahelyett, hogy az adatokat manipulálnánk, hogy a tágabb program használja), és hogy a külső osztályok nem hivatkozhatnak rá. A „string args” cucc lehetővé teszi számunkra, hogy információkat továbbítsunk a módszerbe, hogy később manipuláljuk. Ezeket „paramétereknek” és „argumentumoknak” nevezzük. Még egyszer nem kell aggódnia ezek miatt. Csak tudd, hogy a „statikus üresség”, amelyet egy szó, zárójelek és göndör zárójelek követnek, jelzi az új módszer kezdetét.

A következő két sort hozzáadjuk: megkapják a konzolt, majd elérik a parancsokat, hogy írjanak a képernyőre, és megvárják a gombnyomást.

Végül lezárjuk az összes zárójelünket: először a módszert, aztán az osztályt, majd a „névteret”, amely a projekt neve, amelyhez az osztály tartozik (ebben az esetben „ConsoleApp3” - ilyen módon készítettem korábbi tesztalkalmazásokat) .

Zavaros? Ne aggódjon, ennek inkább értelme van.

Módszerek használata

Tehát a módszerek kódcsomagok és nevek. Annak bemutatására, hogy miért használunk módszereket, hasznos lehet egy új módszer létrehozása és példaként történő felhasználása.

Tehát hozzon létre egy új módszert, amely a Program osztályon belül él (tehát ennek a göndör zárójelben kell lennie, de a „Main” göndör zárójelén kívül kell lennie).

Hívja ezt „NewMethod” -nek, majd helyezze ide az éppen írt két sort. Ennek így kell kinéznie:

osztály Program {statikus void Fő (karakterláncok) {} statikus érvénytelen NewMethod () {Console.WriteLine ("Hello World!"); Console.ReadKey (); }}

Most adjunk hozzá egy hivatkozást a NewMethod elemre a fő módszerben, például:

statikus érvénytelen Fő (karakterlánc) {ar ​​NewMethod (); }

Ez azután hívja fel az ön által létrehozott módszert, lényegében a programot abban az irányba irányítva. Nyomja meg a Start gombot, és látni fogja, hogy ugyanaz történik, mint korábban. Most, kivéve, ha szeretné, írhatott a „NewMethod ();” -szel annyiszor, amennyit csak akarta, és ismételje meg a szöveget anélkül, hogy sok kódot kellene írni.

Egy hatalmas program során az ilyen kódrészletek hivatkozása hihetetlenül hatalmassá válik. Ez az egyik legfontosabb dolog, amelyet meg kell érteni, amikor megpróbálja megtanulni a C # programozást az Androidra.

Annyi módszert tudunk létrehozni, amennyit csak szeretünk, és így van egy nagyon ügyes és szervezett kódrészlet. Ugyanakkor hivatkozhatunk a „beépített” módszerekre a C # -ra és az esetlegesen használt könyvtárakra is. A „Main” a „beépített” módszer egyik példája. Ez az a módszer, amellyel minden program elindul, és hogy a C # megérti, hogy ezt először végre kell hajtania. Ha nem tesz ide semmit, akkor semmi sem történik!

A zárójelben szereplő érvekre tehát csak azért van szükség, mert így fejlesztették ki a Microsoft a fő módszert. Mindamellett rendben volt, hogy a zárójeleinket üresen hagytuk.

A változók használata

Itt az ideje, hogy valójában csináljunk egy kicsit érdekes kódot. Pontosabban, nézzük meg, hogyan használná a változókat a program dinamikusabbá tételéhez. Ez az egyik legfontosabb dolog, amit meg kell érteni, ha meg akarod tanulni a C # programozást.

A változó alapvetően egy adattároló. Vedd vissza a középiskolai matematikát, és emlékszel, hogy láttam ilyen dolgokat:

10 + x = 13
Keresse meg az x-et

Itt az „x” egy változó, és természetesen az ábrázolt érték „3”.

Pontosan így működik egy változó a programozásban. Kivéve itt, a változó sok különféle típusú adatot képviselhet: szöveget is.

Egy új változó létrehozásához először el kell mondanunk a C #-nak, hogy milyen típusú adatokat fog használni.

Tehát a NewMethod () metódusban először létrehozza a változót, majd hozzárendel egy értéket. Akkor hozzá fogjuk adni azt a „WriteLine” parancshoz:

int szám; szám = 10; Console.WriteLine ("Hello World!" + Szám);

Olyan változót használtunk, amelyet „egész számnak” hívunk, amely bármilyen egész szám lehet. A C #-ban ezekre az „int” kifejezéssel hivatkozunk. Ugyanakkor egyszerűen használhattunk volna például egy „lebegőpontot”, amely „lebegőpontos változó”, és lehetővé teszi számunkra a tizedesjegyeket.

Ha futtatja ezt a kódot, akkor most írnia kell: „Hello World! 10 ”képernyőre. És természetesen bármikor megváltoztathatjuk a „szám” értékét annak érdekében, hogy megváltoztassuk.

Mivel a „szám” a NewMethod () -ban jön létre, ezért kódunk másutt nem érhető el. De ha az összes módszeren kívül hagyjuk, akkor globálisan elérhetővé válik. Ehhez meg kell győződnünk arról, hogy a változó statikus is:

osztály Program {statikus int szám = 10; statikus érvénytelen Fő (karakterláncok) {NewMethod (); } statikus érvénytelen NewMethod () {Console.WriteLine ("Hello World!" + szám); Console.ReadKey (); }}

Végül, van még egy módja annak, hogy továbbadjuk ezeket az adatokat, és az lenne, ha érvként használnánk őket, és ezáltal átadnánk a módszerünkhöz. Ez így néz ki:

statikus érvénytelen Fő (karakterláncok) {int szám = 10; Console.WriteLine ("Üdvözöllek, mi a neved?"); NewMethod (szám); } statikus érvénytelen NewMethod (int szám) {Console.WriteLine ("Hello World!" + szám); Console.ReadKey (); }}

Itt definiáljuk a NewMethod módszert úgy, hogy egyetlen argumentumra van szükség, amelynek egész számnak kell lennie, és amelyet a módszerben „számnak” nevezünk. Ezt úgy végezzük, hogy egyszerűen hozzáadjuk ezt az információt a göndör zárójelbe. Ezután, amikor a metódust bárhol a programból meghívjuk, ezt az értéket „át kell adnunk” a zárójelben. Megalkothat több paraméterrel rendelkező módszereket, ebben az esetben a felsorolt ​​változókat vesszővel választja el.

Különböző forgatókönyvek léteznek, amikor az említett különféle stratégiák az adatok zsonglőrésére használhatók. A jó programozás azt jelenti, hogy megtalálják a munkához a megfelelőt!

Érvek átadása és karakterláncok használata

Próbáld meg futtatni ezt a következő kóddarabot, és nézd meg, mi történik:

osztály Program {statikus void Fő (karakterlánc) {Console.WriteLine ("Üdvözöllek, mi a neved?"); NewMethod (Console.ReadLine ()); } statikus érvénytelen NewMethod (karakterlánc felhasználónév) {Console.WriteLine ("Hello" + felhasználónév); Console.ReadKey (); }}

Meg kell találnia, hogy felkérést kap a nevének megadására, és a konzol ezután rámegy téged. Ez az egyszerű kóddarab számos hasznos leckét tartalmaz.

Először látunk egy példát egy különféle típusú változó, az úgynevezett karakterlánc használatára. A Karakterlánc egy karakter sorozat, amely lehet név vagy egy teljes történet.

Tehát ugyanolyan könnyen megírhatja a UserName = “Adam” nevet. Ehelyett inkább a konzolból kapjuk a karakterláncot a Console.ReadLine () kifejezéssel.

Írta volna:

Karakterlánc felhasználó; Felhasználó = Console.ReadLine (); NewMethod (Felhasználó);

Annak érdekében, hogy a kódot a lehető legtisztábbban tartsuk, kihagytuk ezeket a lépéseket, és közvetlenül a zárójelbe tettük a „ReadLine” elemet.

Ezután ezt a karakterláncot átadjuk a NewMethod-nak, és üdvözöljük a felhasználót a már ismert módszerrel.

A Karakterlánc egy karakter sorozat, amely lehet név vagy egy teljes történet.

Remélhetőleg most már egy kicsit megérti, hogy a C # miért van írva olyan, ahogyan van, és hogyan lehet például változók és módszerek felhasználásával rugalmas és hatékony szoftvert létrehozni.

De van még egy fontos szempont, amelyet tudnia kell, ha meg akarja tanulni a C # programozást: áramlásvezérlés.

Tanulja meg a C # áramlásszabályozást és készítsen egyszerű vetélkedőket!

Az egyik ok, amiért kódolóként változókat használunk, az az, hogy a későbbiekben könnyen szerkeszthetjük programokat. Egy másik lehetőség az, hogy információkat szerezzen a felhasználótól, vagy véletlenszerűen generáljon.

De a C # változó megtanulásának legmegfelelőbb oka az, hogy a programjai dinamikussá válnak: hogy a felhasználásuktól függően eltérően reagáljanak.

Ennek érdekében „áramlásszabályozásra” vagy „feltételes kijelentésekre” van szükségünk. Ez valóban csak képzeletbeli módja annak, hogy azt mondjuk, hogy egy kódot egy változó értékétől függően egynél több módon fogunk végrehajtani.

És ennek egyik legerősebb módja egy „ha” kijelentés. Ebben a példában üdvözöljük főfelhasználóinkat, mint a többieket, és figyeljük meg a felhasználónevüket.

statikus érvénytelen NewMethod (karakterlánc felhasználói név) {Console.WriteLine ("Hello" + felhasználónév); if (UserName.Equals ("Adam")) {Console.WriteLine ("Welcome back uram"); } Console.ReadKey (); }

A „if” utasítások úgy működnek, hogy tesztelik egy utasítás érvényességét, amely zárójelbe kerül. Ebben az esetben azt kérdezzük, hogy a UserName karakterlánc megegyezik-e az „Adam” karakterlánccal. Ha a zárójelben szereplő állítás igaz - a két karakterlánc azonos -, akkor a következő göndörű zárójelben szereplő kód kerül végrehajtásra. Ha nem, akkor ezeket a sorokat átugorja.

Hasonlóképpen összehasonlíthatjuk az egész számokat és az úszásokat, és tesztelhetjük, hogy az egyik nagyobb-e, mint a másik, stb. Többféle különféle nyilatkozatot is használhatunk, mint például az orosz babák. Ezt nevezzük „beágyazott if-knek”.

Legközelebb

Sokkal több stratégia használható az áramlásvezérléshez - ideértve a kapcsoló utasításokat is. Remélhetőleg már láthatja, hogyan használhatjuk ezeket az állításokat és technikákat annak érdekében, hogy elindítsunk néhány hasznos dolgot. Ezt a kódot könnyedén kvízré alakíthatja!

Végül a C # olyan eszközökkel, mint a Unity, lehetővé teszi a teljesen funkcionális játékok felépítését!

De ahhoz, hogy valóban lenyűgöző eszközöket és játékokat készítsünk, még néhány dolgot meg kell vizsgálnunk. Tehát meglepetés! Lesz a második rész!

A következő leckében megtudhatja, hogyan lehet hurkokat létrehozni, amelyek idővel iterálnak, valamint hogyan lehet új osztályokat létrehozni és velük együttműködni. Majd találkozunk!