Inhoud

• Een snelle introductie - C # vs Java
• Hallo Wereld! in C #
• Aan de slag met C #: methoden en klassen
• Methoden gebruiken
• Variabelen gebruiken
• Argumenten doorgeven en tekenreeksen gebruiken
• Leer C # flow control en bouw eenvoudige quizzen!
• De volgende keer

In dit bericht leer je over C # programmeren voor Android, en waar het past in het grote schema van Android-ontwikkeling.

Als u geïnteresseerd bent om een ​​Android-ontwikkelaar te worden, kunt u de indruk hebben dat u een van twee talen moet leren: Java of Kotlin. Dit zijn de twee talen die officieel worden ondersteund door Android Studio, en daarom richten de twee talen zich op veel handleidingen en tutorials. Android-ontwikkeling is veel flexibeler en gevarieerder dan dat, en er zijn veel meer manieren om het te benaderen. Veel van deze hebben betrekking op C #.

Lezen:Ik wil Android-apps ontwikkelen - welke talen moet ik leren?

C # is de programmeertaal die u zult gebruiken als u ervoor kiest om bijvoorbeeld een game in Unity te bouwen - wat ook de populairste en meest gebruikte game-engine in de Play Store is. Over het algemeen is het handig om C # -programmering te leren als je überhaupt geïnteresseerd bent in game-ontwikkeling.

Je moet ook C # programmeren als je Xamarin wilt gebruiken. Xamarin is een tool waarmee ontwikkelaars apps kunnen bouwen met behulp van Visual Studio die gemakkelijk kan worden overgezet naar zowel iOS als Android, perfect voor cross-platformprojecten.

Dus, met dat gezegd, er is absoluut een goede reden om C # -programmering voor Android te leren. Laten we eens kijken wat u moet weten.

Een snelle introductie - C # vs Java

C # is een objectgeoriënteerde programmeertaal die rond 2000 door Microsoft is ontwikkeld met als doel modern, eenvoudig en flexibel te zijn. Net als Java (ontwikkeld door Sun Microsystem in 1990), is het oorspronkelijk geëvolueerd uit C ++, waardoor er veel overeenkomsten tussen de twee zijn. Beide gebruiken bijvoorbeeld dezelfde "syntactische basis", wat betekent dat ze in feite veel van dezelfde terminologie en structuur gebruiken. Er zijn een paar kleine verschillen, maar als je bekend bent met de ene taal, dan zou je veel van de andere moeten kunnen begrijpen zonder het specifiek te hoeven leren. Voor beginners zullen velen echter merken dat het iets gemakkelijker is om C # -programmering te leren.

Als objectgeoriënteerde talen zullen zowel C # als Java objecten beschrijven via klassen. Dit is een modulaire benadering van programmeren, waarmee codefragmenten steeds opnieuw kunnen worden gebruikt.

Waar C # echter verschilt van Java, is het in het gebruik van gedelegeerden, de benadering van het luisteren naar evenementen, virtuele versus definitieve eigenschappen, impliciete casting en meer.

Het goede nieuws: u hoeft eigenlijk niet te weten wat dit allemaal betekent als u voor het eerst C # begint te leren. Het belangrijkste is dat de structuur net iets gemakkelijker te leren is in C # en vaak minder typen vereist. Dit is vooral het geval omdat je, wanneer je Java voor Android leert, ook bekend moet zijn met de vele klassen en API's die nodig zijn om Android-apps te bouwen. Zo kun je ook C # programmeren leren als een opstap naar Java.

Hallo Wereld! in C #

Traditie in de wereld van codering is dat wanneer je een nieuwe taal leert, je een eenvoudig programma moet maken om "Hallo wereld!" Op het scherm weer te geven. Dit zorgt er in principe voor dat u de benodigde tools in gebruik kunt nemen en iets eenvoudigs kunt compileren. Het is alsof je 'testen, testen, 1, 2, 3' in een microfoon leest!

In dit geval gaan we Visual Studio gebruiken om een ​​console-app te maken. Dus zodra u doorgaat en Visual Studio heeft gedownload (het is gratis), klikt u op:

Bestand> Nieuw> Project

En toen:

Visual C #> Windows Classic Desktop> Console-app (.NET Framework)

Zo bouwen we een app die wordt uitgevoerd in de Windows-console.

Als dat gedaan is, verschijnt de kale bottenstructuur van uw project in het hoofdvenster. U krijgt de code te zien die er als volgt uitziet:

namespace ConsoleApp3 {class Program {static void Main (string args) {}}}

Voeg nu eenvoudig twee regels toe, zoals:

namespace ConsoleApp3 {class Program {static void Main (string args) {Console.WriteLine ("Hallo wereld!"); Console.ReadKey (); }}}

Dit gaat "Hallo wereld!" Op het scherm schrijven en wacht vervolgens op een toetsdruk. Zodra de gebruiker op een toets drukt, wordt het programma beëindigd en wordt het automatisch afgesloten.

Merk op dat beide regels eindigen op een puntkomma. Dit komt omdat elke instructie in C # moet eindigen met een puntkomma, die aan C # communiceert dat de regel is voltooid (het is hetzelfde in Java). De enige uitzondering is wanneer de regel onmiddellijk wordt gevolgd door een open haakje, wat we zo meteen zullen uitleggen.

Druk op de knop "Start" bovenaan het scherm, en dan zou de app moeten starten, zodat u dit in de praktijk kunt zien.

Klassen zijn stukjes code die objecten beschrijven, die in feite stukjes gegevens zijn

Wat is hier precies aan de hand?

Aan de slag met C #: methoden en klassen

Om C # programmeren voor Android te leren, moet je lessen en methoden begrijpen.

Klassen zijn stukjes code die objecten beschrijven, die in feite stukjes gegevens zijn. U hoeft zich hier in eerste instantie niet al te veel zorgen over te maken: weet alleen dat de codepagina waarmee u nu werkt een 'klasse' wordt genoemd en dat u met andere klassen binnen uw project kunt communiceren. Een project kan slechts één klasse hebben, met al uw code die daar werkt, of het kan meerdere hebben.

Binnen elke klas heb je ook methoden. Deze methoden zijn codefragmenten waarnaar u op elk gewenst moment kunt verwijzen vanuit die klasse - en soms van daarbuiten.

In dit geval wordt de klasse genoemd Programma. Dit wordt bovenaan bovenaan gedefinieerd door de regel die luidt: class Program. En als u het venster "Solution Explorer" aan de rechterkant opent, kunt u Program.cs vinden. De naam van de klasse is altijd hetzelfde als de bestandsnaam.

We gebruiken dan een accolade om alle volgende code te bevatten. Krullende haakjes vertellen ons dat alles wat volgt bij elkaar hoort. Dus, totdat de haak sluit, maakt alle volgende code deel uit van het programma.

Dit wordt gevolgd door onze eerste methode, gedefinieerd door de volgende regel:

statische leegte Main (string args)

Dit wordt gevolgd door meer open haakjes, wat betekent dat het volgende stukje code deel uitmaakt van de methode "Main" (die zich nog in de klasse Program bevindt). En dat is waar we onze "Hallo wereld" hebben geplaatst.

"Statische leegte" vertelt ons in wezen dat deze methode iets op zichzelf doet (in plaats van het manipuleren van gegevens die door het bredere programma moeten worden gebruikt) en dat er niet naar kan worden verwezen door externe klassen. De "string args" dingen laten ons toe informatie door te geven aan de methode om later te manipuleren. Dit worden "parameters" en "argumenten" genoemd. Nogmaals, u hoeft zich hierover nog geen zorgen te maken. Weet alleen dat "statische leegte" gevolgd door een woord, haakjes en accolades het begin is van een nieuwe methode.

De volgende twee regels zijn degene die we hebben toegevoegd: ze krijgen de console en hebben vervolgens toegang tot de opdrachten om naar het scherm te schrijven en te wachten op een toetsdruk.

Ten slotte sluiten we al onze haakjes: eerst de methode, vervolgens de klasse en vervolgens de "naamruimte", de naam van het project waartoe de klasse behoort (in dit geval "ConsoleApp3" - ik heb op deze manier eerdere test-apps gemaakt) .

Verward? Maak je geen zorgen, het gaat zinniger worden.

Methoden gebruiken

Methoden zijn dus codebundels met namen. Om aan te tonen waarom we methoden gebruiken, kan het nuttig zijn om een ​​nieuwe te maken en deze als voorbeeld te gebruiken.

Maak dus een nieuwe methode die binnen de programmaklasse leeft (dus deze moet tussen die accolades staan, maar buiten de accolades die bij 'Main' horen).

Noem dit "NewMethod" en plaats dan de twee regels die u hier net hebt geschreven. Dit zou er zo uit moeten zien:

class Programma {static void Main (string args) {} static void NewMethod () {Console.WriteLine ("Hallo wereld!"); Console.ReadKey (); }}

Voeg nu een verwijzing naar NewMethod toe aan uw hoofdmethode, als volgt:

statische void Main (string args) {ar ​​NewMethod (); }

Dit gaat dan de zojuist gecreëerde methode "aanroepen", in wezen het programma in die richting leiden. Druk op Start en je ziet hetzelfde als voorheen. Behalve nu als je zou willen, zou je “NewMethod ();” zo vaak kunnen schrijven als je wilde en de tekst blijven herhalen zonder veel code te hoeven schrijven.

In de loop van een enorm programma wordt het ongelooflijk krachtig om naar dergelijke codefragmenten te kunnen verwijzen. Dit is een van de belangrijkste dingen om te begrijpen als je probeert C # -programmering voor Android te leren.

We kunnen op deze manier zoveel methoden maken als we willen en op die manier een heel netjes en georganiseerd stuk code hebben. Tegelijkertijd kunnen we ook verwijzen naar methoden die zijn 'ingebouwd' in C # en alle bibliotheken die we mogelijk gebruiken. "Main" is een voorbeeld van een "ingebouwde" methode. Dit is de methode waarmee alle programma's beginnen en waarvan C # begrijpt dat deze eerst moet worden uitgevoerd. Als je hier niets in stopt, gebeurt er niets!

De argumenten die in dit geval tussen de haakjes staan, zijn daarom alleen nodig omdat Microsoft zo de hoofdmethode heeft ontworpen. We waren echter prima om onze beugels leeg te laten.

Variabelen gebruiken

Nu is het tijd om iets interessants te doen in onze code. Laten we met name eens kijken hoe u variabelen zou gebruiken om het programma dynamischer te maken. Dit is een van de belangrijkste dingen om te begrijpen als u C # -programmering wilt leren.

Een variabele is in feite een container voor een stuk gegevens. Denk terug aan wiskunde op de middelbare school en je herinnert je misschien dit soort dingen:

10 + x = 13
Zoek x

Hier is "x" een variabele en natuurlijk is de waarde die het vertegenwoordigt "3".

Dit is ook precies hoe een variabele werkt bij het programmeren. Behalve hier kan een variabele veel verschillende soorten gegevens vertegenwoordigen: inclusief tekst.

Om een ​​nieuwe variabele te maken, moeten we eerst C # vertellen welk type gegevens het gaat bevatten.

In uw NewMethod () -methode maakt u dus eerst uw variabele en vervolgens wijst u deze een waarde toe. Dan gaan we het toevoegen aan onze "WriteLine" -opdracht:

int nummer; nummer = 10; Console.WriteLine ("Hallo wereld!" + Nummer);

We hebben een type variabele gebruikt die een 'geheel getal' wordt genoemd, wat elk geheel getal kan zijn. In C # verwijzen we hiernaar met behulp van “int”. We hadden echter bijvoorbeeld gewoon een "float" kunnen gebruiken, wat een "floating point-variabele" is waarmee we decimalen kunnen gebruiken.

Als u deze code uitvoert, moet deze nu 'Hallo wereld! 10 ”naar het scherm. En natuurlijk kunnen we de waarde van "nummer" op elk moment wijzigen om de.

Omdat 'nummer' is gemaakt binnen NewMethod (), kunnen we het niet ergens anders in onze code openen. Maar als we het buiten alle methoden plaatsen, wordt het wereldwijd beschikbaar. Om dat te doen, moeten we ervoor zorgen dat de variabele echter ook statisch is:

klasse Programma {statisch int. nummer = 10; static void Main (string args) {NewMethod (); } statische nietig NewMethod () {Console.WriteLine ("Hello World!" + nummer); Console.ReadKey (); }}

Ten slotte is er nog een manier waarop we deze gegevens kunnen doorgeven, en dat zou zijn om het als argument te gebruiken, waardoor het in onze methode wordt doorgegeven. Dit kan er zo uitzien:

static void Main (string args) {int number = 10; Console.WriteLine ("Hallo daar, hoe heet je?"); NewMethod (nummer); } statische nietig NewMethod (int nummer) {Console.WriteLine ("Hello World!" + nummer); Console.ReadKey (); }}

Hier definiëren we onze NewMethod-methode als één argument nodig, dat een geheel getal moet zijn, en waarnaar binnen de methode wordt verwezen als "nummer". We doen dit door die informatie eenvoudig aan de accolades toe te voegen. Als we de methode vervolgens ergens anders in het programma aanroepen, moeten we die waarde tussen haakjes 'doorgeven'. U kunt methoden met meerdere parameters maken. In dat geval scheidt u de vermelde variabelen met komma's.

Er zijn verschillende scenario's waarbij het gebruik van al deze verschillende strategieën om met gegevens te jongleren geschikt is. Goed programmeren betekent de juiste vinden voor de klus!

Argumenten doorgeven en tekenreeksen gebruiken

Probeer dit volgende stuk code uit te voeren en kijk wat er gebeurt:

class Program {static void Main (string args) {Console.WriteLine ("Hallo, wat is uw naam?"); NewMethod (Console.ReadLine ()); } statische nietig NewMethod (String Gebruikersnaam) {Console.WriteLine ("Hallo" + Gebruikersnaam); Console.ReadKey (); }}

U zult merken dat u wordt gevraagd uw naam in te voeren en dat de console u er vervolgens mee begroet. Dit eenvoudige stukje code bevat een aantal nuttige lessen.

Eerst zien we een voorbeeld van het gebruik van een ander type variabele, een String genoemd. Een tekenreeks is een reeks tekens, die een naam kan zijn of een heel verhaal kan zijn.

U kunt dus net zo gemakkelijk UserName = "Adam" schrijven. Maar in plaats daarvan krijgen we de tekenreeks van de console met de instructie: Console.ReadLine ().

We hadden kunnen schrijven:

String gebruiker; Gebruiker = Console.ReadLine (); NewMethod (User);

Maar om onze code zo netjes mogelijk te houden, hebben we die stappen overgeslagen en de "ReadLine" direct tussen haakjes geplaatst.

We geven die string vervolgens door aan onze NewMethod en we begroeten de gebruiker met behulp van de methode die u al kent.

Een tekenreeks is een reeks tekens, die een naam kan zijn of een heel verhaal kan zijn.

Hopelijk begin je nu een beetje te begrijpen waarom C # is geschreven zoals het is en hoe je dingen zoals variabelen en methoden kunt gebruiken om flexibele en krachtige software te maken.

Maar er is nog een belangrijk aspect dat u moet weten als u C # -programmering wilt leren: stroomregeling.

Leer C # flow control en bouw eenvoudige quizzen!

Een van de redenen dat we bij het coderen variabelen gebruiken, is dat we onze programma's vervolgens eenvoudig kunnen bewerken. Een andere is zodat u informatie van de gebruiker kunt krijgen of willekeurig kunt genereren.

Maar misschien is de beste reden om C # -variabelen te leren, zodat uw programma's dynamisch kunnen worden: zodat ze anders kunnen reageren, afhankelijk van hoe ze worden gebruikt.

Daartoe hebben we "flow control" of "voorwaardelijke verklaringen" nodig. Dit zijn eigenlijk gewoon mooie manieren om te zeggen dat we code op meer dan één manier gaan uitvoeren, afhankelijk van de waarde van een variabele.

En een van de krachtigste manieren om dat te doen, is met een 'als'-verklaring. Laten we in dit voorbeeld onze hoofdgebruiker anders begroeten dan de anderen door op hun gebruikersnaam te letten.

statische void NewMethod (String Gebruikersnaam) {Console.WriteLine ("Hallo" + gebruikersnaam); if (UserName.Equals ("Adam")) {Console.WriteLine ("Welkom terug mijnheer"); } Console.ReadKey (); }

"Als" -instructies werken door de geldigheid van een verklaring te testen, die tussen haakjes staat. In dit geval vragen we of de tekenreeks Gebruikersnaam hetzelfde is als de tekenreeks 'Adam'. Als die verklaring tussen haakjes waar is - de twee strings zijn hetzelfde - dan wordt de code tussen de volgende accolades uitgevoerd. Als dit niet het geval is, worden die regels overgeslagen.

Evenzo kunnen we gehele getallen en praalwagens vergelijken en kunnen we testen of de ene groter is dan de andere, enz. We kunnen zelfs meerdere verschillende if-statements in elkaar gebruiken zoals Russische poppen. We noemen dit "geneste ifs".

De volgende keer

Er zijn nog veel meer strategieën die u kunt gebruiken voor flow control - inclusief dingen zoals schakelinstructies. Hopelijk kun je echter al zien hoe we deze verklaringen en technieken kunnen gebruiken om een ​​aantal nuttige dingen te beginnen. Je zou deze code gemakkelijk al in een quiz kunnen veranderen!

Uiteindelijk kun je met C # met tools zoals Unity volledig functionele spellen bouwen!

Maar om echt indrukwekkende tools en games te maken, zijn er nog een paar dingen die we moeten onderzoeken. Dus verrassing! Er komt een deel twee!

In de volgende les zul je ontdekken hoe je loops kunt maken die na verloop van tijd herhalen, en hoe je nieuwe klassen kunt maken en ermee kunt communiceren. Zie je dan!