Construtores

Escreva uma classe Box com um campo int chamado size e um construtor Box(int n) que faz size = n;. Em Pine, mantenha Main e construa uma box com Box b = new Box(4);, depois escreva b.size. Mantenha os dois tipos no mesmo arquivo de ensino para dotnet run continuar simples. Execute com dotnet run. A tela deve mostrar uma linha: 4. O número que você passa a new chega ao construtor, e o construtor o guarda no objeto antes de Main continuar. Definir o campo na construção — dentro do construtor — é o que esta página ensina. Mantenha a classe pública inicial chamada Pine.

Um método que roda quando new constrói

Um construtor tem o mesmo nome da classe. Não tem tipo de retorno void nem outro tipo de retorno. Quando Main escreve new Box(4), C# constrói o objeto e executa aquele construtor com 4 como n. Depois que o construtor termina, a variável guarda o objeto pronto. Esse é o trabalho inteiro desta página: passar um valor a new, deixar o construtor guardá-lo no campo, depois escrever o campo para ver que a guarda funcionou.
Abra o arquivo Pine. O nome da classe inicial permanece Pine. Esta página não renomeia o iniciador. Apague qualquer resto c.fill = 3; se essa atribuição Cup ainda for tudo o que você tem em Main. Apague qualquer resto de classe Cup. Apague qualquer linha ReadLine. O arquivo que você guarda não espera digitação.
Fora das chaves de Pine — ainda no mesmo arquivo — escreva public class Box. Dentro das chaves declare int size;. Depois escreva o construtor: Box(int n) { size = n; }. Use um nome de parâmetro diferente de size nesta página para a atribuição ficar clara sem a palavra this. Não há Main em Box nesta página. Salve o arquivo antes de executar.
A linha do campo sozinha não coloca 4 no objeto. O corpo do construtor faz esse trabalho quando new o chama. Se você pular o construtor e só declarar o campo, um new Box(4) depois não vai corresponder, e a compilação vai reclamar da chamada. Mantenha as duas peças em Box: o campo e o construtor que escreve nele.

Pine passa 4 para new Box

Pine mantém public static void Main(). Dentro de Main, escreva Box b = new Box(4); depois Console.WriteLine(b.size);. O argumento 4 entra no parâmetro do construtor n. Você não precisa de uma linha separada b.size = 4; nesta página — o construtor já guardou o valor. A linha de escrita está aí para você confiar no que o construtor fez sem adivinhar. Você não escreve c.fill = 3; nesta página. Essa era a lição de campos.

Leia o arquivo guardado de cima. using System; prepara nomes curtos. public class Pine é o iniciador. public static void Main() é onde o runtime começa. A expressão new Box(4) constrói um Box e chama Box(int n) com n igual a 4. O corpo escreve size = n, então o size daquele objeto vira 4. Depois Main escreve b.size e a tela mostra 4. Nada mais deve imprimir.
Execute com dotnet run. O programa escreve uma linha e para. Não espera você digitar. Se dotnet run esperar, ReadLine ainda está no arquivo. Apague essa linha e mantenha new Box(4) mais a escrita em Pine, com o construtor em Box. A tela mostra 4. Se a tela mostrar 3, um caminho restante c.fill = 3; ainda está rodando. Se a tela mostrar ok, uma demo Chip antiga pode ainda estar no arquivo. Você não reinstala o SDK .NET por uma tela que mostra a linha errada.
Se você escrever new Box() sem argumento enquanto o único construtor precisa de um int, a compilação recusa. Combine a chamada com a lista de parâmetros do construtor. Se você acrescentar void antes do nome do construtor, vira um método comum, não um construtor, e new Box(4) não vai executar aquele corpo do jeito que esta página espera. O cabeçalho deve parecer Box(int n), não void Box(int n), e não static int Box(int n).

Comparado com atribuir depois de new

Na página de campos você escrevia c.fill = 3; depois de new Cup(). Isso ainda funciona. Esta página move a guarda para dentro do construtor para o valor ser definido enquanto o objeto é construído. Uma demo Cup restante com c.fill = 3; é outra lição. Para esta página mantenha Box e Pine e new Box(4). Se Pine ainda tem c.fill = 3; e este arquivo não tem classe Cup, remova essa linha. A compilação não inventa um Cup para você.
Escrever só Console.WriteLine(b); não mostra um 4 limpo. Escreva Console.WriteLine(b.size); para ver o número guardado. A referência do objeto sozinha não é o valor do campo. Você já aprendeu esse padrão na página de campos; mantenha-o aqui ao checar o trabalho do construtor.
Você ainda pode atribuir um campo depois de new em outros programas. Esta lição simplesmente escolhe o caminho do construtor para o primeiro valor útil chegar na construção. Não misture os dois estilos na mesma demo Pine nesta página. Um caminho claro basta: argumento para new, guarda no construtor, escrita do campo.

Duas boxes, dois sizes

Cada new Box(...) executa o construtor de novo para um objeto separado. Você pode escrever Box a = new Box(2); e Box b = new Box(9);, depois escrever os dois campos size. A primeira chamada guarda 2 num objeto. A segunda chamada guarda 9 noutro objeto. Os dois objetos não compartilham um único espaço size.

Execute de novo com dotnet run. A tela deve mostrar 2 numa linha e 9 na seguinte. Cada chamada de construtor guardou o próprio argumento no próprio objeto. Escrever Box b = a; não constrói um segundo objeto — use duas chamadas new Box(...) quando quiser dois sizes. Copiar uma referência não é o mesmo que chamar o construtor duas vezes.
Se as duas linhas mostrarem o mesmo número, confira que cada new passa um argumento diferente e que você escreve a.size e b.size nessa ordem. Se a compilação parar no segundo new, procure um parêntese faltando ou um nome de classe errado de uma forma antiga. Erros pequenos na segunda chamada são comuns quando você cola a primeira linha e esquece de mudar o argumento.

O que isto deixa para this

Esta página usa size = n; com nomes diferentes. Uma página depois — this — mostra como falar do campo próprio do objeto quando os nomes colidem. Fique aqui com o nome de parâmetro claro n. Não invente this.size nesta página a menos que já saiba; o objetivo da lição é a chamada do construtor a partir de new. A palavra this é o próximo tópico, não um requisito para guardar n em size hoje.
Não aninhe Box dentro das chaves de Pine. Nesta página as duas classes ficam irmãs no arquivo. Se a compilação não achar Box ao compilar Pine, confira que public class Box está no mesmo arquivo. Se a tela mostrar 0, o construtor pode estar sem a atribuição, ou Main ainda usa uma forma sem argumento que nunca define size — mantenha Box(int n) { size = n; } e new Box(4). Um zero na tela costuma significar que o campo ficou no padrão porque a guarda não rodou.

Você pode declarar int size;, escrever Box(int n) { size = n; }, e construir com Box b = new Box(4); a partir de Pine.Main. Execute com dotnet run. A tela mostra 4. O construtor roda quando new constrói o objeto. Você passou o número na construção, o construtor guardou no campo, e a escrita provou a guarda. Pense no construtor como a preparação que roda antes de Main continuar depois de new. Pine continua a porta que você abre com dotnet run. A próxima página é this, onde você aprende outro jeito de nomear os campos próprios do objeto dentro dos seus métodos e construtores.
Mantenha o cabeçalho do construtor sem void. Mantenha o argumento em new. Mantenha a escrita em b.size. Esses três hábitos são o ponto de verificação desta página antes de seguir.