Contenu

• Une introduction rapide - C # vs Java
• Bonjour le monde! en C #
• Débuter avec C #: méthodes et classes
• En utilisant des méthodes
• Utiliser des variables
• Passer des arguments et utiliser des chaînes
• Apprenez le contrôle de flux C # et créez des quiz simples!
• La prochaine fois

Dans cet article, vous en apprendrez davantage sur la programmation C # pour Android, ainsi que sur sa place dans le grand schéma du développement Android.

Si vous souhaitez devenir développeur Android, vous avez peut-être l’impression que vous devez apprendre l’une des deux langues suivantes: Java ou Kotlin. Ce sont les deux langues officiellement prises en charge par Android Studio, et donc les deux langues sur lesquelles de nombreux guides et tutoriels se concentrent. Le développement d'Android est beaucoup plus flexible et varié que cela, et il y a beaucoup plus de façons de l'aborder. Beaucoup de ceux-ci impliquent C #.

Lis:Je veux développer des applications Android - quelles langues dois-je apprendre?

C # est le langage de programmation que vous utiliserez si vous choisissez de créer un jeu dans Unity, par exemple - qui est également le moteur de jeu le plus populaire et le plus utilisé dans le Play Store. En général, il est utile d’apprendre la programmation en C # si le développement de jeux vous intéresse.

Vous devez également apprendre la programmation C # si vous souhaitez utiliser Xamarin. Xamarin est un outil qui permet aux développeurs de créer des applications à l'aide de Visual Studio qui peuvent facilement être portées à la fois sur iOS et Android, ce qui est parfait pour les projets multiplateformes.

Cela dit, il y a certainement de bonnes raisons d'apprendre la programmation C # pour Android. Voyons ce que vous devez savoir.

Une introduction rapide - C # vs Java

C # est un langage de programmation orienté objet développé par Microsoft vers 2000, dans le but d’être moderne, simple et flexible. Comme Java (développé par Sun Microsystem en 1990), il a évolué à partir du C ++, garantissant ainsi de nombreuses similitudes entre les deux. Par exemple, les deux utilisent la même «base syntaxique», ce qui signifie qu’ils utilisent effectivement beaucoup de la même terminologie et de la même structure. Il existe quelques différences mineures, mais si vous connaissez une langue, vous devriez être capable de comprendre beaucoup de l'autre sans avoir besoin de l'avoir appris spécifiquement. Pour les débutants, beaucoup trouveront qu’il est légèrement plus facile d’apprendre la programmation C #.

En tant que langages orientés objet, C # et Java décriront les objets au travers de classes. Il s’agit d’une approche modulaire de la programmation, qui permet l’utilisation répétée de fragments de code.

Là où C # diffère de Java, c'est par son utilisation des délégués, son approche de l'écoute d'événements, ses propriétés virtuelles par rapport à ses propriétés finales, sa diffusion implicite, etc.

La bonne nouvelle: vous n’avez en fait pas besoin de savoir ce que cela signifie au début de votre apprentissage du C #. La principale conclusion est que la structure est juste un peu plus facile à apprendre en C # et a tendance à nécessiter moins de dactylographie. Cela est d'autant plus vrai que lorsque vous apprenez Java pour Android, vous devez également vous familiariser avec les nombreuses classes et API nécessaires à la création d'applications Android. Ainsi, vous pourriez également apprendre la programmation C # comme un tremplin vers Java.

Bonjour le monde! en C #

Dans le monde du codage, la tradition veut que chaque fois que vous apprenez une nouvelle langue, vous devez créer un programme simple permettant d’afficher «Hello World!» À l’écran. Cela garantit essentiellement que vous êtes capable de mettre en place les outils nécessaires et de compiler quelque chose de simple. C’est comme lire «tester, tester, 1, 2, 3» dans un microphone!

Dans ce cas, nous allons utiliser Visual Studio pour créer une application console. Donc, une fois que vous avez téléchargé Visual Studio (c'est gratuit), cliquez sur:

Fichier> Nouveau> Projet

Et alors:

Visual C #> Bureau classique Windows> Application console (.NET Framework)

Voici comment nous construisons une application qui s'exécutera dans la console Windows.

Ceci fait, la structure de votre projet apparaîtra dans la fenêtre principale. Vous serez présenté avec un code qui ressemble à ceci:

espace de noms ConsoleApp3 {class Programme {static void Main (string args) {}}}

Maintenant, ajoutez simplement deux lignes, comme ceci:

espace de noms ConsoleApp3 {class Programme {statique void Main (string args) {Console.WriteLine ("Hello World!"); Console.ReadKey (); }}}

Cela va écrire «Hello World!» À l'écran, puis attendre une pression sur une touche. Une fois que l'utilisateur a touché une touche quelconque, le programme se termine et se termine automatiquement.

Notez que ces deux lignes se terminent par un point-virgule. En effet, toute instruction en C # doit se terminer par un point-virgule, ce qui indique au C # que la ligne est terminée (la même chose en Java). La seule exception est lorsque la ligne est immédiatement suivie par un crochet ouvert, ce que nous expliquerons dans un instant.

Appuyez sur le bouton «Démarrer» en haut de l'écran. L'application devrait alors être lancée, ce qui vous permettra de voir cela en pratique.

Les classes sont des fragments de code décrivant des objets, qui sont en réalité des fragments de données.

Alors, qu'est-ce qui se passe exactement ici?

Débuter avec C #: méthodes et classes

Pour apprendre la programmation C # sur Android, vous devez comprendre les classes et les méthodes.

Les classes sont des éléments de code décrivant des objets, qui sont en réalité des éléments de données. Commencez par ne pas trop vous inquiéter à ce sujet. Sachez simplement que la page de code sur laquelle vous travaillez actuellement s'appelle une «classe» et que vous pouvez interagir avec les autres classes de votre projet. Un projet peut avoir une seule classe, avec tout votre code à partir de là, ou en avoir plusieurs.

Dans chaque classe, vous aurez également des méthodes. Ces méthodes sont des fragments de code auxquels vous pouvez faire référence à tout moment depuis cette classe - et parfois de l’extérieur.

Dans ce cas, la classe s'appelle Programme. Ceci est défini tout en haut par la ligne qui lit: programme classe. Et si vous ouvrez la fenêtre «Explorateur de solutions» à droite, vous pourrez trouver Program.cs. Le nom de la classe est toujours identique au nom du fichier.

Nous utilisons ensuite une accolade pour contenir tout le code qui suit. Les accolades nous disent que tout ce qui suit va ensemble. Ainsi, jusqu'à la fermeture du crochet, tout le code suivant fait partie de Program.

Ceci est suivi de notre première méthode, définie par la ligne suivante:

static void Main (string args)

Cela est ensuite suivi de crochets plus ouverts, ce qui signifie que le prochain bit de code fait partie de la méthode «Main» (qui est toujours dans la classe Program). Et c’est là que nous avons mis notre «Hello World».

"Static Void" nous dit essentiellement que cette méthode fait quelque chose de autonome (plutôt que de manipuler des données devant être utilisées par le programme plus large) et qu’elle ne peut pas être référencée par des classes extérieures. Le «argument de chaîne» nous permet de transmettre des informations à la méthode pour les manipuler plus tard. Celles-ci sont appelées "paramètres" et "arguments". Encore une fois, vous n’avez pas besoin de vous inquiéter pour le moment. Sachez simplement que le «vide statique» suivi d'un mot, de crochets et d'accolades marque le début d'une nouvelle méthode.

Les deux lignes suivantes sont celles que nous avons ajoutées: elles obtiennent la console, puis accèdent à ses commandes pour écrire à l'écran et attendent une pression sur une touche.

Enfin, nous fermons tous nos crochets: d'abord la méthode, ensuite la classe, puis le "namespace" qui est le nom du projet auquel la classe appartient (dans ce cas "ConsoleApp3" - j'ai créé les applications de test précédentes de cette façon) .

Confus? Ne vous inquiétez pas, cela va avoir plus de sens.

En utilisant des méthodes

Donc, les méthodes sont des paquets de code avec des noms. Pour montrer pourquoi nous utilisons des méthodes, il peut être utile de créer une nouvelle méthode et de la mettre en œuvre à titre d'exemple.

Donc, créez une nouvelle méthode qui vit dans la classe Program (elle doit donc se trouver entre ces accolades, mais en dehors des accolades appartenant à «Main»).

Appelez cette «NewMethod», puis mettez les deux lignes que vous venez d'écrire à l'intérieur. Cela devrait ressembler à ceci:

class Programme {static void Main (string args) {} voic statique NewMethod () {Console.WriteLine ("Hello World!"); Console.ReadKey (); }}

Ajoutez maintenant une référence à NewMethod dans votre méthode Main, comme suit:

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

Cela va ensuite «appeler» la méthode que vous venez de créer, en dirigeant essentiellement le programme dans cette direction. Appuyez sur Démarrer et vous verrez que la même chose se passe comme avant. Sauf que maintenant, si vous le souhaitez, vous pouvez écrire «NewMethod ();» autant de fois que vous le souhaitez et répéter sans cesse le texte sans avoir à écrire beaucoup de code.

Au cours d’un programme gigantesque, pouvoir référencer des extraits de code comme celui-ci devient incroyablement puissant. C'est l'une des choses les plus importantes à comprendre lorsque vous essayez d'apprendre la programmation C # pour Android.

Nous pouvons créer autant de méthodes que nous le souhaitons, ce qui nous permet d'avoir un code très ordonné et organisé. En même temps, nous pouvons également référencer des méthodes «intégrées» à C # et à toutes les bibliothèques que nous pourrions utiliser. "Main" est un exemple de méthode "intégrée". C’est la méthode par laquelle tous les programmes commenceront et que C # comprend qu’il doit s’exécuter en premier. Si vous ne mettez rien ici, rien ne se passera!

Les arguments inclus entre crochets dans ce cas ne sont donc nécessaires que parce que c'est ainsi que Microsoft a conçu la méthode Main. Nous étions cependant bien de laisser nos parenthèses vides.

Utiliser des variables

Il est maintenant temps de faire quelque chose d’un peu intéressant dans notre code. Plus précisément, voyons comment utiliser les variables pour rendre le programme plus dynamique. C’est l’une des choses les plus importantes à comprendre si vous souhaitez apprendre la programmation C #.

Une variable est fondamentalement un conteneur pour une donnée. Réfléchissez aux maths du lycée et vous vous souviendrez peut-être d'avoir vu des choses comme celle-ci:

10 + x = 13
Trouver x

Ici, "x" est une variable, et bien sûr la valeur qu’elle représente est "3".

C’est aussi exactement comment une variable fonctionne en programmation. Sauf qu'ici, une variable peut représenter beaucoup de types de données différents: texte compris.

Pour créer une nouvelle variable, nous devons d’abord dire à C # le type de données qu’elle va utiliser.

Donc, dans votre méthode NewMethod (), vous créerez d’abord votre variable, puis vous lui assignerez une valeur. Ensuite, nous allons l’ajouter à notre commande «WriteLine»:

int numéro; nombre = 10; Console.WriteLine ("Hello World!" + Numéro);

Nous avons utilisé un type de variable appelé «entier» qui peut être un nombre entier. En C #, nous nous référons à ceux-ci en utilisant "int". Cependant, nous aurions pu facilement utiliser un «float», par exemple, qui est une «variable à virgule flottante» et nous permet d’utiliser des décimales.

Si vous exécutez ce code, il devrait maintenant écrire «Hello World! 10 ”à l'écran. Et bien sûr, nous pourrions modifier la valeur de «nombre» à tout moment afin de modifier le.

Dans la mesure où «nombre» est créé dans NewMethod (), nous ne pouvons pas y accéder depuis un autre endroit de notre code. Mais si nous le plaçons en dehors de toutes les méthodes, il deviendra disponible globalement. Pour ce faire, nous devons nous assurer que la variable est également statique, cependant:

class Programme {static int number = 10; void statique Main (string args) {NewMethod (); } void statique NewMethod () {Console.WriteLine ("Hello World!" + numéro); Console.ReadKey (); }}

Enfin, il existe un autre moyen de transmettre ces données, à savoir l’utiliser comme argument pour les transmettre à notre méthode. Cela pourrait ressembler à ceci:

void statique Main (string args) {int number = 10; Console.WriteLine ("Bonjour, quel est ton nom?"); NewMethod (nombre); } void statique NewMethod (int number) {Console.WriteLine ("Hello World!" + numéro); Console.ReadKey (); }}

Ici, nous définissons notre méthode NewMethod comme nécessitant un argument, qui doit être un entier, et qui sera désigné dans la méthode par «nombre». Pour ce faire, nous ajoutons simplement cette information aux accolades. Ensuite, lorsque nous appelons la méthode depuis n’importe quel autre endroit du programme, nous devons «passer» cette valeur entre crochets. Vous pouvez créer des méthodes avec plusieurs paramètres, auquel cas il vous suffit de séparer les variables répertoriées par des virgules.

Il existe différents scénarios dans lesquels l’utilisation de toutes ces stratégies différentes pour jongler avec les données sera appropriée. Une bonne programmation signifie trouver le bon pour le travail!

Passer des arguments et utiliser des chaînes

Essayez d’exécuter ce prochain morceau de code et voyez ce qui se passe:

class Program {statique void Main (string args) {Console.WriteLine ("Bonjour, quel est votre nom?"); NewMethod (Console.ReadLine ()); } void statique NewMethod (String UserName) {Console.WriteLine ("Hello" + UserName); Console.ReadKey (); }}

Vous devriez constater que vous êtes invité à entrer votre nom et que la console vous en remercie. Ce simple morceau de code contient un certain nombre de leçons utiles.

Tout d'abord, nous voyons un exemple d'utilisation d'un type de variable différent, appelé chaîne. Une chaîne est une série de caractères, qui peuvent être un nom ou une histoire entière.

Donc, vous pourriez tout aussi bien écrire UserName = “Adam”. Mais au lieu de cela, nous obtenons la chaîne de la console avec l’instruction suivante: Console.ReadLine ().

Nous aurions pu écrire:

Chaîne utilisateur; Utilisateur = Console.ReadLine (); NewMethod (utilisateur);

Mais pour que notre code soit aussi soigné que possible, nous avons ignoré ces étapes et placé le «ReadLine» directement entre crochets.

Nous passons ensuite cette chaîne à notre NewMethod et nous saluons l’utilisateur en utilisant la méthode que vous connaissez déjà.

Une chaîne est une série de caractères, qui peuvent être un nom ou une histoire entière.

J'espère que vous commencez maintenant à comprendre un peu pourquoi C # est écrit tel quel et comment vous pouvez utiliser des éléments tels que des variables et des méthodes pour créer un logiciel souple et puissant.

Mais il y a un autre aspect important que vous devez savoir si vous voulez apprendre la programmation C #: le contrôle de flux.

Apprenez le contrôle de flux C # et créez des quiz simples!

Une des raisons pour lesquelles nous utilisons des variables lors du codage est que nous pouvons facilement éditer nos programmes ultérieurement. Une autre solution consiste à obtenir des informations de l'utilisateur ou à les générer de manière aléatoire.

Mais peut-être que la meilleure raison d’apprendre les variables C # est que vos programmes puissent devenir dynamiques: pour qu’ils puissent réagir différemment en fonction de leur utilisation.

À cette fin, nous avons besoin d'un «contrôle de flux» ou «d'instructions conditionnelles». Ce ne sont que des façons fantaisistes de dire que nous allons exécuter du code de plusieurs façons, en fonction de la valeur d'une variable.

Et l'un des moyens les plus puissants de le faire est d'utiliser une déclaration «si». Dans cet exemple, accueillons notre utilisateur principal différemment des autres utilisateurs en recherchant leur nom d’utilisateur.

void statique NewMethod (String UserName) {Console.WriteLine ("Hello" + UserName); if (UserName.Equals ("Adam")) {Console.WriteLine ("Bienvenue, monsieur"); } Console.ReadKey (); }

Les déclarations «Si» fonctionnent en testant la validité d'une déclaration qui ira entre crochets. Dans ce cas, nous demandons si la chaîne UserName est identique à la chaîne "Adam". Si cette instruction entre crochets est vraie (les deux chaînes sont identiques), alors le code entre les accolades suivantes sera exécuté. Si ce n’est pas le cas, ces lignes seront ignorées.

De même, nous pouvons comparer des nombres entiers et des flottants, et vérifier si l'un est plus grand que l'autre, etc. Nous pouvons même utiliser plusieurs déclarations if différentes l'une de l'autre, comme des poupées russes. Nous appelons ces «si imbriqués».

La prochaine fois

Il existe de nombreuses autres stratégies que vous pouvez utiliser pour le contrôle de flux, notamment des instructions telles que les instructions switch. Si tout va bien, vous pouvez déjà voir comment nous pourrions utiliser ces déclarations et techniques afin de commencer à faire des choses utiles. Vous pouvez déjà transformer ce code en un quiz!

Finalement, C # avec des outils comme Unity vous permettra de créer des jeux entièrement fonctionnels!

Mais pour créer des outils et des jeux impressionnants, il reste encore quelques points à explorer. Alors surprise! Il va y avoir une deuxième partie!

Dans la prochaine leçon, vous apprendrez à créer des boucles qui se répètent dans le temps, à créer de nouvelles classes et à interagir avec elles. À plus tard!