Accès

Écrivez une classe Lid avec un champ privé int seal, un constructeur Lid(int n) qui fait seal = n;, et une méthode publique int Read() qui renvoie seal. Dans Pine, gardez Main et construisez un lid avec Lid L = new Lid(9);, puis écrivez L.Read(). 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 : 9. Le champ reste privé à Lid. La méthode publique est la façon dont Pine obtient le nombre. Gardez la classe publique de démarrage nommée Pine.

Qui peut voir un membre

Sur la page static vous avez appelé Cup.Mark() par le nom de la classe. Ici les mots nouveaux sont private et public. Un champ private est visible seulement dans sa propre classe. Les autres classes du même fichier — y compris Pine — ne peuvent pas écrire L.seal quand seal est privé. Une méthode public peut quand même tourner depuis Pine et renvoyer cette valeur cachée.
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 Cup.Mark(); si cette démo static est encore tout ce que vous avez dans Main. Supprimez tout reste de classe Cup. Supprimez tout reste Jar. Supprimez toute ligne ReadLine. Le fichier que vous gardez n'attend pas de frappe.
En dehors des accolades de Pine — toujours dans le même fichier — écrivez public class Lid. Dans les accolades déclarez private int seal;. Écrivez le constructeur Lid(int n) { seal = n; }. Puis écrivez public int Read() { return seal; }. Il n'y a pas de Main dans Lid sur cette page. Enregistrez le fichier avant d'exécuter.
Le champ a besoin de private pour que Pine ne touche pas seal par son nom. La méthode a besoin de public pour que Pine puisse appeler Read. Le type de retour est int parce que Read renvoie le nombre stocké à l'appelant. Gardez return seal; dans le corps de la méthode.

Pine construit un lid et appelle Read

Pine garde public static void Main(). Dans Main, écrivez deux lignes dans l'ordre : Lid L = new Lid(9);, puis Console.WriteLine(L.Read());. Le constructeur stocke 9 dans le champ privé. L'appel L.Read() renvoie cette valeur. L'écriture l'affiche. Vous n'écrivez pas Cup.Mark(); sur cette page. C'était la leçon static.

Relisez le fichier gardé depuis le haut. using System; prépare les noms courts. public class Pine est le démarreur. public static void Main() est là où le runtime commence. L'expression new Lid(9) construit un lid et stocke 9 dans seal. L'appel L.Read() entre dans la méthode publique sur cet objet. Le corps renvoie seal, donc la valeur 9 revient à Main. Puis Main écrit cette valeur de retour et l'écran montre 9.
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 new Lid(9) et Console.WriteLine(L.Read()); dans Pine, avec private int seal et public int Read() dans Lid. L'écran montre 9. Si l'écran montre 2, une démo Cup tally restante peut encore tourner. Si la build échoue sur L.seal, vous avez essayé de lire le champ privé depuis Main — passez à L.Read().
Si vous écrivez Console.WriteLine(L.seal); alors que seal est private, la build refuse. Ce refus fait la leçon. Gardez la porte publique : L.Read(). Si vous laissez seal sans private, l'accès par défaut dans cette forme simple peut encore compiler depuis Pine d'une façon que cette page ne veut pas enseigner — mettez private sur le champ à dessein.

Comparé à Cup static et aux champs publics simples

Sur la page static, Cup.tally était atteignable par le nom de la classe après le travail static. Cette page cache seal de Pine et n'ouvre que Read. Un reste Cup.Mark(); Cup.Mark(); Console.WriteLine(Cup.tally); est une autre leçon. Sur cette page gardez Lid et Pine et L.Read().
Vous pourriez rendre chaque champ public et écrire L.seal depuis Main. Cette leçon choisit private pour que l'objet possède le stockage et Pine demande par une méthode. Écrire Console.WriteLine(L); seul ne montre pas un 9 net. Écrivez Console.WriteLine(L.Read()); pour voir le nombre renvoyé.

Deux lids gardent des seals privés séparés

Chaque new Lid(...) obtient son propre seal privé. Vous pouvez écrire Lid a = new Lid(3); et Lid b = new Lid(8);, puis écrire a.Read() et b.Read(). Le mot-clé private ne partage pas un seul seal entre les objets. Il bloque seulement les autres classes qui nommeraient le champ.

Relancez avec dotnet run. L'écran doit montrer 3 sur une ligne et 8 sur la suivante. Chaque Read a renvoyé le champ privé de cet objet. Si les deux lignes montrent le même nombre, vérifiez que vous avez utilisé deux appels new Lid(...) avec des arguments différents. Si l'écran montre encore un seul 9, vous êtes peut-être encore sur la démo à un lid — c'est bien pour le premier point de contrôle ; utilisez le fichier à deux lids quand vous voulez le second contrôle.
Si la build se plaint de Read, confirmez que l'en-tête de méthode inclut public et int. Si Main appelle encore Cup.Mark(), supprimez ce reste static pour que la leçon d'accès puisse montrer les nombres du lid au lieu d'un tally.

Ce que cela laisse pour namespaces

Cette page utilise private et public pour qu'une classe puisse cacher un champ et quand même partager une valeur par une méthode. Une page plus tard — namespaces — regroupe les types sous un nom pour que les grands programmes restent organisés. Restez sur l'accès ici. N'inventez pas d'enveloppe namespace sur cette page sauf si vous le savez déjà ; le but de la leçon est private sur le champ et public sur Read.
Ne imbriquez pas Lid dans les accolades de Pine. Sur cette page les deux classes sont sœurs dans le fichier. Si la build ne trouve pas Lid en compilant Pine, vérifiez que public class Lid est dans le même fichier. Si l'écran montre 0, le constructeur peut manquer le stockage — gardez Lid(int n) { seal = n; } et appelez Read après new.

Vous pouvez déclarer private int seal;, écrire Lid(int n) { seal = n; } et public int Read() { return seal; }, et depuis Pine.Main lancer Lid L = new Lid(9);, puis écrire L.Read(). Lancez avec dotnet run. L'écran montre 9. Le champ privé est resté dans Lid. La méthode publique a remis le nombre à Pine. Voyez private comme un tiroir fermé et Read comme la façon autorisée de regarder dedans. Pine reste la porte que vous ouvrez avec dotnet run. La page suivante est namespaces, où les types se placent sous un nom de groupe pour que les fichiers plus grands restent clairs.
Gardez private sur le champ. Gardez public sur Read. Gardez l'appel en L.Read() au lieu de L.seal. Ces trois habitudes sont le point de contrôle de cette page avant d'avancer. Laissez les démos restantes Cup.Mark() hors de Main pour que l'écran ne montre pas un tally par erreur.