Zugriff

Schreibe eine Klasse Lid mit einem privatem Feld int seal, einem Konstruktor Lid(int n), der seal = n; setzt, und einer public-Methode int Read(), die seal zurückgibt. In Pine behältst du Main und baust einen Deckel mit Lid L = new Lid(9);, dann schreibst du L.Read(). Halte beide Typen in derselben Lehrdatei, damit dotnet run einfach bleibt. Starte mit dotnet run. Der Bildschirm sollte eine Zeile zeigen: 9. Das Feld bleibt privat zu Lid. Die public-Methode ist, wie Pine die Zahl bekommt. Behalte den öffentlichen Startklassennamen Pine.

Wer ein Mitglied sieht

Auf der static-Seite hast du Cup.Mark() über einen Klassennamen aufgerufen. Hier sind die neuen Wörter private und public. Ein private-Feld ist nur in seiner eigenen Klasse sichtbar. Andere Klassen in derselben Datei — einschließlich Pine — können L.seal nicht schreiben, wenn seal private ist. Eine public-Methode kann trotzdem aus Pine laufen und den verborgenen Wert zurückgeben.
Öffne die Pine-Datei. Der Startklassenname bleibt Pine. Diese Seite benennt den Starter nicht um. Lösche ein Cup.Mark();-Überbleibsel, falls die static-Demo noch alles in Main ist. Lösche jedes Cup-Klassen-Überbleibsel. Lösche jedes Jar-Überbleibsel. Lösche jede ReadLine-Zeile. Die Datei, die du behältst, wartet nicht auf Tippen.
Außerhalb der geschweiften Klammern von Pine — noch in derselben Datei — schreibst du public class Lid. Innerhalb der Klammern deklarierst du private int seal;. Schreibe den Konstruktor Lid(int n) { seal = n; }. Dann schreibst du public int Read() { return seal; }. In Lid gibt es auf dieser Seite kein Main. Speichere die Datei vor dem Lauf.
Das Feld braucht private, damit Pine seal nicht beim Namen anfasst. Die Methode braucht public, damit Pine Read aufrufen kann. Der Rückgabetyp ist int, weil Read die gespeicherte Zahl an den Aufrufer übergibt. Behalte return seal; im Methodenkörper.

Pine baut einen Deckel und ruft Read auf

Pine behält public static void Main(). Innerhalb von Main schreibst du zwei Zeilen der Reihe nach: Lid L = new Lid(9);, dann Console.WriteLine(L.Read());. Der Konstruktor speichert 9 im privaten Feld. Der Aufruf L.Read() gibt diesen Wert zurück. Die Ausgabe zeigt ihn. Du schreibst auf dieser Seite kein Cup.Mark();. Das war die static-Lektion.

Lies die behaltene Datei von oben. using System; bereitet Kurznamen vor. public class Pine ist der Starter. public static void Main() ist, wo die Laufzeit startet. Der Ausdruck new Lid(9) baut einen Deckel und speichert 9 in seal. Der Aufruf L.Read() betritt die public-Methode auf diesem Objekt. Der Körper gibt seal zurück, also kommt der Wert 9 nach Main zurück. Dann schreibt Main den Rückgabewert und der Bildschirm zeigt 9.
Starte mit dotnet run. Das Programm schreibt eine Zeile und stoppt. Es wartet nicht, bis du tippst. Wenn dotnet run wartet, ist ReadLine noch in der Datei. Lösche diese Zeile und behalte new Lid(9) und Console.WriteLine(L.Read()); in Pine, mit private int seal und public int Read() in Lid. Der Bildschirm zeigt 9. Zeigt er 2, läuft vielleicht noch eine Cup-tally-Demo. Schlägt der Build bei L.seal fehl, hast du das private Feld aus Main gelesen — wechsle zu L.Read().
Wenn du Console.WriteLine(L.seal); schreibst, während seal private ist, verweigert der Build. Diese Verweigerung ist die Lektion. Behalte die öffentliche Tür: L.Read(). Lässt du seal ohne private, kann der Standardzugriff in dieser einfachen Form aus Pine noch kompilieren — setze private absichtlich auf das Feld.

Im Vergleich zu static Cup und zu schlicht public Feldern

Auf der static-Seite war Cup.tally nach static-Arbeit über den Klassennamen erreichbar. Diese Seite verbirgt seal vor Pine und öffnet nur Read. Ein Überbleibsel Cup.Mark(); Cup.Mark(); Console.WriteLine(Cup.tally); ist eine andere Lektion. Für diese Seite behältst du Lid, Pine und L.Read().
Du könntest jedes Feld public machen und L.seal aus Main schreiben. Diese Lektion wählt private, damit das Objekt den Speicher besitzt und Pine über eine Methode fragt. Console.WriteLine(L); allein zeigt keine saubere 9. Schreibe Console.WriteLine(L.Read());, um die zurückgegebene Zahl zu sehen.

Zwei Deckel mit getrennten privaten seals

Jedes new Lid(...) bekommt sein eigenes privates seal. Du kannst Lid a = new Lid(3); und Lid b = new Lid(8); schreiben, dann a.Read() und b.Read(). Das Schlüsselwort private teilt kein seal über Objekte. Es blockiert nur andere Klassen beim Benennen des Felds.

Starte erneut mit dotnet run. Der Bildschirm sollte 3 in einer Zeile und 8 in der nächsten zeigen. Jedes Read gab das eigene private Feld dieses Objekts zurück. Zeigen beide Zeilen dieselbe Zahl, prüfe zwei new Lid(...)-Aufrufe mit verschiedenen Argumenten. Zeigt der Bildschirm noch eine einzelne 9, bist du vielleicht noch bei der Ein-Deckel-Demo — das reicht für den ersten Checkpoint; nimm die Zwei-Deckel-Datei für die zweite Prüfung.
Beschwert sich der Build über Read, bestätige public und int in der Methodenkopfzeile. Ruft Main noch Cup.Mark() auf, lösche dieses static-Überbleibsel, damit die Zugriffslektion Deckelzahlen statt tally zeigt.

Was für namespaces übrig bleibt

Diese Seite nutzt private und public, damit eine Klasse ein Feld verbergen und einen Wert trotzdem über eine Methode teilen kann. Eine spätere Seite — namespaces — gruppiert Typen unter einem Namen, damit größere Programme ordentlich bleiben. Bleib hier bei Zugriff. Erfinde auf dieser Seite keinen Namespace-Wrapper, es sei denn, du kennst ihn schon; das Lernziel ist private am Feld und public an Read.
Verschachtele Lid nicht in Pines Klammern. Auf dieser Seite sitzen die zwei Klassen als Geschwister in der Datei. Findet der Build Lid beim Kompilieren von Pine nicht, prüfe, dass public class Lid in derselben Datei steht. Zeigt der Bildschirm 0, fehlt vielleicht das Speichern im Konstruktor — behalte Lid(int n) { seal = n; } und rufe Read nach new auf.

Du kannst private int seal; deklarieren, Lid(int n) { seal = n; } und public int Read() { return seal; } schreiben und aus Pine.Main Lid L = new Lid(9); ausführen, dann L.Read() schreiben. Starte mit dotnet run. Der Bildschirm zeigt 9. Das private Feld blieb in Lid. Die public-Methode gab die Zahl an Pine weiter. Denk an private als geschlossene Schublade und an Read als den erlaubten Blick hinein. Pine bleibt die Tür, die du mit dotnet run öffnest. Die nächste Seite ist namespaces, wo Typen unter einem Gruppennamen sitzen, damit größere Dateien klar bleiben.
Behalte private am Feld. Behalte public an Read. Behalte den Aufruf als L.Read() statt L.seal. Diese drei Gewohnheiten sind der Checkpoint vor dem Weitergehen. Lass Cup.Mark()-Überbleibsel aus Main, damit der Bildschirm nicht versehentlich tally zeigt.