Innehåll
- En snabb introduktion - C # vs Java
- Hej världen! i C #
- Komma igång med C #: metoder och klasser
- Använda metoder
- Använda variabler
- Vidarebefordra argument och använda strängar
- Lär dig C # flödeskontroll och bygg enkla frågesporter!
- Nästa gång
I det här inlägget kommer du att lära dig om C # -programmering för Android, samt var det passar in i det stora schemat för Android-utveckling.
Om du är intresserad av att bli en Android-utvecklare kanske du känner att du behöver lära dig ett av två språk: Java eller Kotlin. Dessa är de två språken som officiellt stöds av Android Studio, och därför fokuserar de två språk som många guider och handledning har. Android-utvecklingen är mycket mer flexibel och varierad än så, och det finns många fler sätt att närma sig den. Många av dessa involverar C #.
Läsa:Jag vill utveckla Android-appar - vilka språk ska jag lära mig?
C # är det programmeringsspråk du kommer att använda om du väljer att bygga ett spel till exempel i Unity - vilket också är den mest populära och mest använda spelmotorn i Play Store. I allmänhet är det användbart att lära sig C # -programmering om du alls är intresserad av spelutveckling.
Du bör också lära dig C # -programmering om du vill använda Xamarin. Xamarin är ett verktyg som gör det möjligt för utvecklare att bygga appar med Visual Studio som enkelt kan portas till både iOS och Android, perfekt för plattformsprojekt.
Så med det sagt finns det definitivt goda skäl att lära sig C # -programmering för Android. Låt oss titta på vad du behöver veta.
En snabb introduktion - C # vs Java
C # är ett objektorienterat programmeringsspråk som utvecklades av Microsoft cirka 2000 med målet att vara modernt, enkelt och flexibelt. Liksom Java (utvecklats av Sun Microsystem 1990) utvecklades det ursprungligen från C ++, vilket säkerställer att det finns många likheter mellan de två. Till exempel använder båda samma "syntaktiska bas", vilket innebär att de effektivt använder mycket av samma terminologi och struktur. Det finns några mindre skillnader, men om du känner till ett språk, bör du kunna förstå en hel del av det andra utan att behöva lära dig det specifikt. För nybörjare kommer dock många att finna att det är lite lättare att lära sig C # -programmering.
Som objektorienterade språk kommer både C # och Java att beskriva objekt genom klasser. Detta är ett modulärt tillvägagångssätt för programmering som gör att kodstycken kan användas om och om igen.
Där C # emellertid skiljer sig från Java, är i dess användning av delegater, dess inställning till händelse lyssnande, virtuella vs slutliga egenskaper, implicit casting och mer.
Den goda nyheten: du behöver faktiskt inte veta vad det mesta av detta betyder när du börjar lära dig C #. Den viktigaste takeaway är att strukturen bara är lite lättare att lära sig i C # och tenderar att kräva mindre maskinskrivning. Detta är särskilt sant med tanke på att när du lär dig Java för Android, måste du också bekanta dig med de många klasser och API: er som krävs för att bygga Android-appar. Således kan du också lära dig C # -programmering som ett steg till Java.
Hej världen! i C #
Traditionen i kodningsvärlden är att varje gång du lär dig ett nytt språk bör du skapa ett enkelt program för att visa "Hello World!" På skärmen. Detta säkerställer i princip att du kan få de nödvändiga verktygen igång och att sammanställa något enkelt. Det är som att läsa "testa, testa, 1, 2, 3" i en mikrofon!
I det här fallet kommer vi att använda Visual Studio för att skapa en konsolapp. Så när du har gått och laddat ner Visual Studio (det är gratis) klickar du på:
Arkiv> Nytt> Projekt
Och då:
Visual C #> Windows Classic Desktop> Console App (.NET Framework)
Så här bygger vi en app som kommer att köras i Windows-konsolen.
När det är gjort kommer projektets nakna ben att visas i huvudfönstret. Du får en kod som ser ut så här:
namespace ConsoleApp3 {class Program {static void Main (string args) {}}}
Lägg bara till två rader, så här:
namespace ConsoleApp3 {class Program {static void Main (string args) {Console.WriteLine ("Hello World!"); Console.ReadKey (); }}}
Detta kommer att skriva "Hej världen!" Till skärmen och vänta sedan på en knapptryckning. När användaren trycker på valfri knapp kommer programmet att avslutas och kommer automatiskt att avsluta.
Observera att båda dessa linjer slutar med en semikolon. Det beror på att alla uttalanden i C # måste sluta med en semikolon, som kommunicerar till C # att linjen är klar (det är samma i Java). Det enda undantaget är när linjen omedelbart följs av en öppen konsol, vilket vi förklarar på ett ögonblick.
Tryck på "Start" -knappen längst upp på skärmen, och det bör starta appen, så att du kan se detta i praktiken.
Klasser är kodkoder som beskriver objekt, som faktiskt är data
Så, vad exakt händer här?
Komma igång med C #: metoder och klasser
För att lära dig C # -programmering för Android måste du förstå klasser och metoder.
Klasser är kodkoder som beskriver objekt, som faktiskt är data. Du behöver inte oroa dig för mycket till att börja med: bara veta att den sida med kod du arbetar med just nu kallas en "klass" och att du kan interagera med andra klasser inom ditt projekt. Ett projekt kan ha bara en klass, där alla dina koder fungerar därifrån, eller det kan ha flera.
Inom varje klass kommer du också ha metoder. Dessa metoder är kodavsnitt som du kan hänvisa till när som helst inom den klassen - och ibland utanför den.
I detta fall kallas klassen Program. Detta definieras längst upp av raden som läser: klass Program. Och om du öppnar fönstret "Solution Explorer" till höger kommer du att kunna hitta Program.cs. Klassens namn är alltid samma som filnamnet.
Vi använder sedan en lockig konsol för att innehålla alla följande koder. Lockiga parenteser säger att allt som följer hör samman. Så tills konsolen stängs är all följande kod en del av Programmet.
Detta följs av vår första metod, definierad av följande rad:
statisk tomgång Huvud (sträng args)
Därefter följs mer öppna parenteser, vilket innebär att nästa kodkod är en del av "Main" -metoden (som fortfarande finns inom programklassen). Och det är där vi har lagt "Hello World".
"Statisk tomgång" berättar i huvudsak att den här metoden gör något fristående (snarare än att manipulera data som ska användas av det bredare programmet) och att det inte kan refereras till av externa klasser. "Sträng args" grejer gör det möjligt för oss att skicka information till metoden för att manipulera senare. Dessa kallas "parametrar" och "argument". Återigen behöver du inte oroa dig för något av det ännu. Vet bara att "statisk tomrum" följt av ett ord, parenteser och lockiga parenteser markerar början på en ny metod.
De nästa två raderna är de vi har lagt till: de får konsolen och kommer sedan åt kommandona för att skriva till skärmen och vänta på en knapptryckning.
Slutligen stänger vi alla våra parenteser: först metoden, sedan klassen och sedan "namnområdet" som är namnet på projektet klassen tillhör (i detta fall "ConsoleApp3" - Jag har gjort tidigare testappar på detta sätt) .
Förvirrad? Oroa dig inte, det handlar om att vara mer meningsfullt.
Använda metoder
Så metoder är paket med kod med namn. För att visa varför vi använder metoder kan det vara bra att skapa en ny och använda den som ett exempel.
Så skapa en ny metod som lever inom programklassen (så den måste vara inom de lockiga parenteserna, men utanför de lockiga parenteserna som tillhör “Main”).
Kalla den här "NewMethod" och lägg sedan de två raderna som du just skrev här inne. Detta ska se ut så:
klass Program {static void Main (string args) {} static void NewMethod () {Console.WriteLine ("Hello World!"); Console.ReadKey (); }}
Lägg till en referens till NewMethod i din huvudmetod, så här:
static void Main (string args) {ar NewMethod (); }
Detta kommer då att "kalla" den metod du just skapade, väsentligen riktar programmet i den riktningen. Tryck på Start så ser du att samma sak händer som tidigare. Förutom nu om du ville, kan du skriva "NewMethod ();" så många gånger som du ville och fortsätta att upprepa texten utan att behöva skriva massor med kod.
Under loppet av ett enormt program blir det oerhört kraftfullt att kunna referera kodavsnitt som detta. Detta är en av de viktigaste sakerna att förstå när du försöker lära dig C # -programmering för Android.
Vi kan skapa så många metoder som vi gillar på det här sättet och på det sättet har en väldigt snygg och organiserad kod. Samtidigt kan vi också referera till metoder som är ”inbyggda” till C # och alla bibliotek som vi kan använda. "Main" är ett exempel på en "inbyggd" metod. Detta är den metod som alla program kommer att börja med, och att C # förstår att det bör köras först. Om du inte lägger något här, kommer ingenting att hända!
De argument som ingår i parenteserna i detta fall behövs därför bara eftersom det är så som Microsoft utformade Main-metoden. Vi var dock bra att lämna våra parenteser tomma.
Använda variabler
Nu är det dags att faktiskt göra något lite intressant i vår kod. Låt oss ta en titt på hur du använder variabler för att göra programmet mer dynamiskt. Detta är en av de viktigaste sakerna att förstå om du vill lära dig C # -programmering.
En variabel är i grunden en behållare för en datamängd. Kasta ditt sinne tillbaka till gymnasiet matematik, och du kanske kommer ihåg att du såg saker som detta:
10 + x = 13
Hitta x
Här är "x" en variabel, och naturligtvis är värdet som det representerar "3".
Det är också exakt hur en variabel fungerar i programmering. Förutom här kan en variabel representera många olika typer av data: inklusive text.
För att skapa en ny variabel måste vi först berätta för C # vilken typ av data den kommer att användas för att innehålla.
Så inuti din NewMethod () -metod skapar du först din variabel och sedan tilldelar du den ett värde. Sedan kommer vi att lägga till det i vårt "WritLine" -kommando:
int-nummer; antal = 10; Console.WriteLine ("Hello World!" + Nummer);
Vi har använt en typ av variabel som kallas ett "heltal" som kan vara valfritt heltal. I C # hänvisar vi till dessa med ”int”. Men vi kunde bara ha använt en "float" till exempel, som är en "flytande punktvariabel" och tillåter oss att använda decimaler.
Om du kör denna kod bör den nu skriva ”Hej världen! 10 ”till skärmen. Och naturligtvis kan vi ändra värdet på "antal" när som helst för att ändra.
Eftersom "nummer" skapas i NewMethod () kan vi inte få tillgång till det från någon annanstans i vår kod. Men om vi placerar det utanför alla metoder, kommer det att bli tillgängligt globalt. För att göra det måste vi se till att variabeln också är statisk:
klass Program {statisk int-nummer = 10; static void Main (string args) {NewMethod (); } statisk tomgång NewMethod () {Console.WriteLine ("Hej världen!" + nummer); Console.ReadKey (); }}
Slutligen finns det ytterligare ett sätt vi kan överföra denna information, och det skulle vara att använda dem som ett argument och därmed överföra dem till vår metod. Det här kan se ut så:
statisk tomgång Huvud (sträng args) {int nummer = 10; Console.WriteLine ("Hej, vad heter du?"); NewMethod (nummer); } statisk tomgång NewMethod (int-nummer) {Console.WriteLine ("Hej världen!" + nummer); Console.ReadKey (); }}
Här definierar vi vår NewMethod-metod som behov av ett argument, som bör vara ett heltal, och som inom metoden kallas ”nummer”. Vi gör detta genom att helt enkelt lägga till den informationen i de lockiga parenteserna. Sedan, när vi kallar metoden från någon annanstans i programmet, måste vi "passera" det värdet inom parenteserna. Du kan skapa metoder med flera parametrar, i vilket fall du bara separerar de listade variablerna med kommatecken.
Det finns olika scenarier där det är lämpligt att använda alla dessa olika strategier för att jonglera data. Bra programmering innebär att hitta rätt för jobbet!
Vidarebefordra argument och använda strängar
Försök köra nästa kodkod och se vad som händer:
klass Program {static void Main (string args) {Console.WriteLine ("Hej, vad heter du?"); NewMethod (Console.ReadLine ()); } statisk tomgång NewMethod (String UserName) {Console.WriteLine ("Hej" + Användarnamn); Console.ReadKey (); }}
Du bör upptäcka att du blir ombedd att ange ditt namn och att konsolen sedan fångar dig av det. Denna enkla kod innehåller ett antal användbara lektioner.
Först ser vi ett exempel på hur man använder en annan typ av variabel, kallad en sträng. En sträng är en serie karaktärer, som kan vara ett namn, eller kan vara en hel historia.
Så du kan lika lätt skriva UserName = “Adam”. Men istället får vi strängen från konsolen med uttalandet: Console.ReadLine ().
Vi kunde ha skrivit:
Stränganvändare; Användare = Console.ReadLine (); NewMethod (Användare);
Men för att hålla vår kod så snygg som möjligt har vi hoppat över dessa steg och placerat ”ReadLine” direkt inom parenteserna.
Vi skickar sedan den strängen till vår NewMethod och vi hälsar användaren med den metod som du redan är bekant med.
En sträng är en serie karaktärer, som kan vara ett namn, eller kan vara en hel historia.
Förhoppningsvis börjar du nu förstå lite om varför C # skrivs som det är, och hur du kan använda saker som variabler och metoder för att skapa flexibel och kraftfull programvara.
Men det är en viktigare aspekt du borde veta om du vill lära dig C # -programmering: flödeskontroll.
Lär dig C # flödeskontroll och bygg enkla frågesporter!
En av orsakerna till att vi använder variabler vid kodning är att vi enkelt kan redigera våra program därefter. En annan är så att du kan få information från användaren eller generera den slumpmässigt.
Men kanske är det bästa skälet till att lära sig C # -variabler, så att dina program kan bli dynamiska: så att de kan reagera olika beroende på hur de används.
För detta ändamål behöver vi "flödeskontroll" eller "villkorade uttalanden". Det här är egentligen bara snygga sätt att säga att vi kommer att köra kod på mer än ett sätt, beroende på värdet på en variabel.
Och ett av de mest kraftfulla sätten att göra det är med ett ”if” -uttalande. Låt oss i det här exemplet hälsa vår huvudanvändare annorlunda än de andra genom att leta efter deras användarnamn.
statisk tomrum NewMethod (String UserName) {Console.WriteLine ("Hej" + Användarnamn); if (UserName.Equals ("Adam")) {Console.WriteLine ("Välkommen tillbaka sir"); } Console.ReadKey (); }
”If” -uttalanden fungerar genom att testa giltigheten för ett uttalande, vilket kommer att gå in inom parentes. I det här fallet frågar vi om strängen Användarnamn är densamma som strängen "Adam". Om det påståendet i parenteserna är sant - de två strängarna är desamma - kommer koden i följande lockiga parenteser att köras. Om det inte är det kommer de raderna att hoppas över.
På samma sätt kan vi jämföra heltal och flyter, och vi kan testa för att se om det ena är större än det andra, etc. Vi kan till och med använda flera olika om uttalanden i varandra som ryska dockor. Vi kallar dessa "kapslade ifs".
Nästa gång
Det finns många fler strategier du kan använda för flödeskontroll - inklusive saker som switch-uttalanden. Förhoppningsvis kan du redan se hur vi kan använda dessa uttalanden och tekniker för att börja göra några användbara saker. Du kan enkelt förvandla den här koden till en frågesport redan!
Så småningom kan C # med verktyg som Unity låta dig bygga fullt funktionella spel!
Men för att verkligen göra imponerande verktyg och spel finns det några fler saker vi behöver utforska. Så överraskning! Det kommer att bli en del två!
I nästa lektion kommer du att upptäcka hur man skapar slingor som upprepas över tid, samt hur man skapar nya klasser och interagerar med dem. Vi ses då!
