Acceso

Escribe una clase Lid con un campo privado int seal, un constructor Lid(int n) que pone seal = n; y un metodo publico int Read() que devuelve seal. En Pine conserva Main y construye una tapa con Lid L = new Lid(9);, luego escribe L.Read(). Mantén ambos tipos en el mismo archivo de enseñanza para que dotnet run siga siendo simple. Ejecuta con dotnet run. La pantalla deberia mostrar una linea: 9. El campo queda privado a Lid. El metodo publico es como Pine obtiene el numero. Conserva el nombre de la clase publica inicial Pine.

Quien ve un miembro

En la pagina static llamaste Cup.Mark() a traves del nombre de la clase. Aqui las palabras nuevas son private y public. Un campo private solo se ve dentro de su propia clase. Otras clases en el mismo archivo — incluida Pine — no pueden escribir L.seal cuando seal es privado. Un metodo public aun puede ejecutarse desde Pine y devolver ese valor oculto.
Abre el archivo Pine. El nombre de la clase inicial sigue siendo Pine. Esta pagina no renombra el inicio. Borra cualquier sobrante Cup.Mark(); si la demo static es todo lo que tienes en Main. Borra cualquier sobrante de la clase Cup. Borra cualquier sobrante Jar. Borra cualquier linea ReadLine. El archivo que conservas no espera que escribas.
Fuera de las llaves de Pine — aun en el mismo archivo — escribe public class Lid. Dentro de las llaves declara private int seal;. Escribe el constructor Lid(int n) { seal = n; }. Luego escribe public int Read() { return seal; }. No hay Main en Lid en esta pagina. Guarda el archivo antes de ejecutar.
El campo necesita private para que Pine no toque seal por nombre. El metodo necesita public para que Pine pueda llamar Read. El tipo de retorno es int porque Read entrega el numero almacenado al llamador. Manten return seal; dentro del cuerpo del metodo.

Pine construye una tapa y llama Read

Pine conserva public static void Main(). Dentro de Main escribe dos lineas en orden: Lid L = new Lid(9);, luego Console.WriteLine(L.Read());. El constructor guarda 9 en el campo privado. La llamada L.Read() devuelve ese valor. La escritura lo muestra. No escribes Cup.Mark(); en esta pagina. Esa fue la leccion static.

Lee el archivo conservado desde arriba. using System; prepara nombres cortos. public class Pine es el inicio. public static void Main() es donde arranca el runtime. La expresion new Lid(9) construye una tapa y guarda 9 en seal. La llamada L.Read() entra al metodo public en ese objeto. El cuerpo devuelve seal, asi el valor 9 vuelve a Main. Luego Main escribe el valor de retorno y la pantalla muestra 9.
Ejecuta con dotnet run. El programa escribe una linea y se detiene. No espera que escribas. Si dotnet run espera, ReadLine sigue en el archivo. Borra esa linea y conserva new Lid(9) y Console.WriteLine(L.Read()); en Pine, con private int seal y public int Read() en Lid. La pantalla muestra 9. Si muestra 2, puede seguir corriendo una demo sobrante de Cup tally. Si la compilacion falla en L.seal, intentaste leer el campo privado desde Main — cambia a L.Read().
Si escribes Console.WriteLine(L.seal); mientras seal es private, la compilacion se niega. Esa negativa es la leccion. Conserva la puerta publica: L.Read(). Si dejas seal sin private, el acceso por defecto en esta forma simple aun puede compilar desde Pine de formas que esta pagina no quiere ensenar — pon private en el campo a proposito.

Comparado con Cup static y con campos public simples

En la pagina static, Cup.tally era alcanzable por el nombre de la clase tras el trabajo static. Esta pagina oculta seal de Pine y abre solo Read. Un sobrante Cup.Mark(); Cup.Mark(); Console.WriteLine(Cup.tally); es otra leccion. Para esta pagina conserva Lid, Pine y L.Read().
Podrias hacer cada campo public y escribir L.seal desde Main. Esta leccion elige private para que el objeto posea el almacen y Pine pregunte por un metodo. Escribir Console.WriteLine(L); solo no muestra un 9 limpio. Escribe Console.WriteLine(L.Read()); para ver el numero devuelto.

Dos tapas con sellos privados separados

Cada new Lid(...) obtiene su propio seal privado. Puedes escribir Lid a = new Lid(3); y Lid b = new Lid(8);, luego escribir a.Read() y b.Read(). La palabra private no comparte un seal entre objetos. Solo bloquea a otras clases al nombrar el campo.

Ejecuta de nuevo con dotnet run. La pantalla deberia mostrar 3 en una linea y 8 en la siguiente. Cada Read devolvio el campo privado de ese objeto. Si ambas lineas muestran el mismo numero, revisa que usaste dos llamadas new Lid(...) con argumentos distintos. Si la pantalla sigue mostrando un solo 9, quizas sigues en la demo de una tapa — esta bien para el primer checkpoint; usa el archivo de dos tapas cuando quieras la segunda comprobacion.
Si la compilacion se queja de Read, confirma que la cabecera del metodo incluye public e int. Si Main aun llama Cup.Mark(), borra ese sobrante static para que la leccion de acceso muestre numeros de tapa en lugar de tally.

Lo que esto deja para namespaces

Esta pagina usa private y public para que una clase pueda ocultar un campo y aun compartir un valor por un metodo. Una pagina posterior — namespaces — agrupa tipos bajo un nombre para que programas mayores sigan ordenados. Quédate con acceso aqui. No inventes un envoltorio de namespace en esta pagina a menos que ya lo conozcas; el objetivo es private en el campo y public en Read.
No anides Lid dentro de las llaves de Pine. En esta pagina las dos clases son hermanas en el archivo. Si la compilacion no encuentra Lid al compilar Pine, revisa que public class Lid este en el mismo archivo. Si la pantalla muestra 0, el constructor puede faltar el guardado — conserva Lid(int n) { seal = n; } y llama Read tras new.

Puedes declarar private int seal;, escribir Lid(int n) { seal = n; } y public int Read() { return seal; }, y desde Pine.Main ejecutar Lid L = new Lid(9);, luego escribir L.Read(). Ejecuta con dotnet run. La pantalla muestra 9. El campo privado se quedo dentro de Lid. El metodo publico entrego el numero a Pine. Piensa en private como un cajon cerrado y en Read como la forma permitida de mirar dentro. Pine sigue siendo la puerta que abres con dotnet run. La pagina siguiente es namespaces, donde los tipos viven bajo un nombre de grupo para que archivos mayores queden claros.
Conserva private en el campo. Conserva public en Read. Conserva la llamada como L.Read() en lugar de L.seal. Esos tres habitos son el checkpoint antes de seguir. Deja fuera de Main las demos sobrantes Cup.Mark() para que la pantalla no muestre tally por error.