Acesso

Escreva uma classe Lid com um campo privado int seal, um construtor Lid(int n) que faz seal = n;, e um metodo publico int Read() que devolve seal. Em Pine, mantenha Main e construa um lid com Lid L = new Lid(9);, depois escreva L.Read(). Mantenha os dois tipos no mesmo arquivo de ensino para dotnet run continuar simples. Execute com dotnet run. A tela deve mostrar uma linha: 9. O campo fica privado a Lid. O metodo publico e como Pine obtem o numero. Mantenha a classe publica inicial chamada Pine.

Quem pode ver um membro

Na pagina static voce chamou Cup.Mark() pelo nome da classe. Aqui as palavras novas sao private e public. Um campo private e visivel so dentro da propria classe. Outras classes no mesmo arquivo — incluindo Pine — nao podem escrever L.seal quando seal e privado. Um metodo public ainda pode rodar a partir de Pine e devolver esse valor escondido.
Abra o arquivo Pine. O nome da classe inicial continua Pine. Esta pagina nao renomeia o inicializador. Apague qualquer resto Cup.Mark(); se essa demo static ainda for tudo o que voce tem em Main. Apague qualquer resto da classe Cup. Apague qualquer resto Jar. Apague qualquer linha ReadLine. O arquivo que voce mantem nao espera digitacao.
Fora das chaves de Pine — ainda no mesmo arquivo — escreva public class Lid. Dentro das chaves declare private int seal;. Escreva o construtor Lid(int n) { seal = n; }. Depois escreva public int Read() { return seal; }. Nao ha Main em Lid nesta pagina. Salve o arquivo antes de executar.
O campo precisa de private para Pine nao tocar seal pelo nome. O metodo precisa de public para Pine poder chamar Read. O tipo de retorno e int porque Read entrega o numero armazenado de volta ao chamador. Mantenha return seal; dentro do corpo do metodo.

Pine constrói um lid e chama Read

Pine mantem public static void Main(). Dentro de Main, escreva duas linhas em ordem: Lid L = new Lid(9);, depois Console.WriteLine(L.Read());. O construtor guarda 9 no campo privado. A chamada L.Read() devolve esse valor. A escrita mostra. Voce nao escreve Cup.Mark(); nesta pagina. Aquela era a licao static.

Leia o arquivo mantido do topo. using System; prepara nomes curtos. public class Pine e o inicializador. public static void Main() e onde o runtime comeca. A expressao new Lid(9) constroi um lid e guarda 9 em seal. A chamada L.Read() entra no metodo publico desse objeto. O corpo devolve seal, entao o valor 9 volta para Main. Depois Main escreve esse retorno e a tela mostra 9.
Execute com dotnet run. O programa escreve uma linha e para. Nao espera voce digitar. Se dotnet run esperar, ReadLine ainda esta no arquivo. Apague essa linha e mantenha new Lid(9) e Console.WriteLine(L.Read()); em Pine, com private int seal e public int Read() em Lid. A tela mostra 9. Se a tela mostrar 2, uma demo Cup tally restante ainda pode estar rodando. Se a build falhar em L.seal, voce tentou ler o campo privado a partir de Main — mude para L.Read().
Se voce escrever Console.WriteLine(L.seal); com seal private, a build recusa. Essa recusa e a licao. Mantenha a porta publica: L.Read(). Se deixar seal sem private, o acesso padrao nesta forma simples ainda pode compilar a partir de Pine de um jeito que esta pagina nao quer ensinar — coloque private no campo de proposito.

Comparado com Cup static e campos publicos simples

Na pagina static, Cup.tally era alcancavel pelo nome da classe depois do trabalho static. Esta pagina esconde seal de Pine e abre so Read. Um resto Cup.Mark(); Cup.Mark(); Console.WriteLine(Cup.tally); e outra licao. Nesta pagina mantenha Lid, Pine e L.Read().
Voce poderia tornar todo campo public e escrever L.seal a partir de Main. Esta licao escolhe private para o objeto donar o armazenamento e Pine pedir por um metodo. Escrever Console.WriteLine(L); sozinho nao mostra um 9 limpo. Escreva Console.WriteLine(L.Read()); para ver o numero devolvido.

Dois lids mantem seals privados separados

Cada new Lid(...) ganha seu proprio seal privado. Voce pode escrever Lid a = new Lid(3); e Lid b = new Lid(8);, depois escrever a.Read() e b.Read(). A palavra-chave private nao compartilha um seal entre objetos. Ela so bloqueia outras classes de nomear o campo.

Rode de novo com dotnet run. A tela deve mostrar 3 em uma linha e 8 na seguinte. Cada Read devolveu o campo privado daquele objeto. Se ambas as linhas mostrarem o mesmo numero, confira que voce usou duas chamadas new Lid(...) com argumentos diferentes. Se a tela ainda mostrar um unico 9, voce pode estar na demo de um lid — serve para o primeiro checkpoint; use o arquivo de dois lids quando quiser o segundo.
Se a build reclamar de Read, confirme que o cabecalho do metodo inclui public e int. Se Main ainda chama Cup.Mark(), apague esse resto static para a licao de acesso mostrar numeros de lid em vez de tally.

O que isto deixa para namespaces

Esta pagina usa private e public para uma classe esconder um campo e ainda compartilhar um valor por um metodo. Uma pagina depois — namespaces — agrupa tipos sob um nome para programas maiores ficarem organizados. Fique com acesso aqui. Nao invente um envelope namespace nesta pagina a menos que ja saiba; o objetivo da licao e private no campo e public em Read.
Nao aninhe Lid dentro das chaves de Pine. Nesta pagina as duas classes ficam irma no arquivo. Se a build nao achar Lid ao compilar Pine, confira que public class Lid esta no mesmo arquivo. Se a tela mostrar 0, o construtor pode faltar o armazenamento — mantenha Lid(int n) { seal = n; } e chame Read depois de new.

Voce pode declarar private int seal;, escrever Lid(int n) { seal = n; } e public int Read() { return seal; }, e a partir de Pine.Main rodar Lid L = new Lid(9);, depois escrever L.Read(). Execute com dotnet run. A tela mostra 9. O campo privado ficou dentro de Lid. O metodo publico entregou o numero a Pine. Pense em private como uma gaveta fechada e Read como o caminho permitido para olhar dentro. Pine continua a porta que voce abre com dotnet run. A pagina seguinte e namespaces, onde os tipos ficam sob um nome de grupo para arquivos maiores ficarem claros.
Mantenha private no campo. Mantenha public em Read. Mantenha a chamada como L.Read() em vez de L.seal. Esses tres habitos sao o checkpoint desta pagina antes de avancar. Deixe demos restantes Cup.Mark() fora de Main para a tela nao mostrar tally por engano.