Objets

Écrivez une classe nommée Chip avec une méthode beep qui écrit ok. La méthode n'est pas static sur cette page. Dans Pine, gardez Main et construisez une puce avec Chip c = new Chip();, puis appelez c.beep();. Gardez les deux types dans le même fichier d'enseignement pour que dotnet run reste simple. Lancez avec dotnet run. L'écran doit montrer une ligne : ok. Le mot new construit un objet à partir de la classe. La variable c tient cet objet. Vous appelez beep sur c, pas sur le nom de classe seul. Cet objet construit — et l'appel qui l'utilise — est ce que cette page enseigne. Gardez la classe publique de démarrage nommée Pine.

Un objet à partir de la classe

Une classe reste le type nommé. Un objet est une valeur construite à partir de ce type. La ligne new Chip() demande à C# de construire cette valeur. Vous la stockez dans une variable dont le type est Chip, puis vous utilisez la variable pour atteindre les méthodes qui appartiennent à chaque objet.
Ouvrez le fichier Pine. Le nom de la classe de démarrage reste Pine. Cette page ne renomme pas le démarreur. Supprimez tout reste Badge.show(); si cet appel static est encore tout ce que vous avez dans Main. Supprimez tout reste de récursion down. Supprimez toute ligne ReadLine. Le fichier que vous gardez n'attend pas de frappe.
Hors des accolades de Pine — toujours dans le même fichier — écrivez public class Chip. À l'intérieur de Chip, écrivez void beep() — pas de mot static sur cet en-tête. Le corps est une seule ligne d'écriture : Console.WriteLine("ok");. Gardez void. La méthode ne renvoie pas un nombre. Il n'y a pas de Main dans Chip sur cette page. Enregistrez le fichier avant de lancer.
Le premier programme encadré montre Chip seul pour que vous puissiez lire le type clairement. Les programmes encadrés suivants sont les formes conservées avec Pine qui construit une puce, puis deux.

Pine construit la puce, puis appelle beep

Pine garde public static void Main(). À l'intérieur de Main, écrivez deux lignes : d'abord Chip c = new Chip();, puis c.beep();. La première ligne déclare une variable c de type Chip et la remplit avec un nouvel objet. La seconde ligne appelle beep sur cet objet. Le point se place après le nom de variable, pas après le nom de classe seul. Vous n'écrivez pas Badge.show(); sur cette page. C'était l'appel static de la leçon sur les classes.

Relisez le fichier conservé depuis le haut. using System; prépare les noms courts. public class Pine est le démarreur. public static void Main() est l'endroit où le runtime commence. L'expression new Chip() construit un objet. Cet objet est stocké dans c. L'appel c.beep() entre dans beep pour cet objet. La méthode écrit ok et revient. Pine se termine ensuite. Le mot à l'écran vient de la méthode de l'objet, après que new a créé l'objet.
Lancez avec dotnet run. Le programme écrit une ligne et s'arrête. Il n'attend pas que vous tapiez. Si dotnet run attend, ReadLine est encore dans le fichier. Supprimez cette ligne et gardez Chip c = new Chip(); plus c.beep(); dans Pine, avec beep dans Chip. L'écran montre ok. Si l'écran montre ready, un appel Badge.show(); restant tourne encore. Si l'écran montre les lettres Chip, une ligne d'écriture a des guillemets : Console.WriteLine("Chip");. Vous ne réinstallez pas le SDK .NET pour un écran qui montre la mauvaise ligne.
Parcourez encore une fois l'exécution dans l'ordre. C# démarre à Pine.Main. La première instruction construit un objet avec new Chip() et le stocke dans c. La seconde instruction appelle c.beep(). À l'intérieur de beep, WriteLine écrit ok. Puis beep se termine, et Main n'a plus rien, donc le programme s'arrête. Vous n'avez pas mis Console.WriteLine("ok"); à l'intérieur de Pine sur cette page. Vous l'avez mis sous Chip et vous l'avez demandé par la variable d'objet.
Pensez à la classe comme au plan dans le fichier et à l'objet comme à une pièce construite en mémoire pour cette exécution. Chaque new Chip() construit une autre pièce. La variable nomme la pièce pour que les lignes suivantes puissent l'atteindre. Sans ce nom, la pièce construite n'a pas de poignée pour beep sur cette page.

Pourquoi l'appel utilise c, pas Chip seul

Sur la page des classes, une méthode static pouvait s'appeler Badge.show() avec le nom du type. Ici beep n'a pas le mot static. C# attend d'abord un objet. Écrire Chip.beep(); sans objet ne correspond pas à cette forme débutant. Construisez avec new, gardez le résultat dans une variable, puis appelez par cette variable.
Si vous écrivez seulement new Chip(); et ne le stockez jamais, vous avez quand même construit un objet, mais il ne reste aucun nom pour appeler beep. Sur cette page gardez la variable : Chip c = new Chip(); puis c.beep();. La variable est le moyen d'atteindre l'objet après que new a fini.
Une démo static restante peut embrouiller Main. Un fichier qui appelle encore Badge.show(); est la forme de la leçon précédente. Pour cette page gardez Chip et Pine et la ligne new. Vous n'avez pas besoin de Badge ici.

Deux objets, deux beep

Vous pouvez construire plus d'un objet à partir de la même classe. Chaque new Chip() fait un objet séparé. Chaque objet peut exécuter beep pour lui-même. Le texte de la classe est partagé ; les objets ne sont pas la même valeur.

Lancez encore avec dotnet run. L'écran doit montrer deux lignes : ok, puis ok. La première ligne vient de a. La seconde vient de b. Les deux ont utilisé le même texte de méthode beep dans Chip, mais chaque appel a tourné sur un objet différent construit avec new.
Si l'écran montre un seul ok, vérifiez que les deux appels sont présents et que les deux variables ont été construites avec new. Écrire Chip b = a; ne construit pas un second objet ; cela fait que b désigne le même objet que a. Cette idée attend les pages suivantes. Sur cette page utilisez deux expressions new Chip() quand vous voulez deux objets.
Vous pouvez renommer la variable de c en unit si vous voulez : Chip unit = new Chip(); puis unit.beep();. L'écran reste ok quand le corps de la méthode écrit encore ce mot. Le nom de variable est à vous ; le nom de type Chip et l'expression new Chip() doivent encore s'accorder.

Ce que cette page laisse pour les champs

Cette page ne stocke pas encore un nombre ou un mot à l'intérieur de la puce. Les champs — des noms qui tiennent des données sur chaque objet — sont la page suivante. Ici l'objet existe après new, et la méthode d'instance beep écrit seulement. Cela suffit pour voir la séparation entre la classe comme type et un objet comme valeur construite.
Ne nichez pas Chip à l'intérieur des accolades de Pine. Sur cette page les deux classes siègent comme sœurs dans le fichier. Les méthodes de Chip siègent à l'intérieur de Chip. Main siège à l'intérieur de Pine. Vous pouvez changer le mot écrit à l'intérieur de beep en ping et relancer. L'écran doit suivre la chaîne que vous avez mise dans Chip. Pine garde la même forme new et appel.
Si la compilation ne trouve pas Chip en compilant Pine, vérifiez que public class Chip siège dans le même fichier et que la ligne de classe dit vraiment Chip. Si l'exécution n'écrit rien, confirmez que Main appelle encore c.beep(); après la ligne new, et que beep contient encore le WriteLine.

Vous pouvez écrire Chip avec void beep(), construire un objet avec Chip c = new Chip();, et appeler c.beep(); depuis Pine.Main. Lancez avec dotnet run. L'écran montre ok. Un second new Chip() construit un autre objet qui peut bipper pour lui-même. Pensez à Chip comme au plan et à chaque new Chip() comme à une pièce construite que vous pouvez nommer. Pine reste la porte que vous ouvrez avec dotnet run. La page suivante porte sur les champs, où chaque objet commence à tenir ses propres données stockées.