Objetos

Escribe una clase llamada Chip con un método beep que escriba ok. El método no es static en esta página. En Pine, conserva Main y construye un chip con Chip c = new Chip();, luego llama c.beep();. Mantén ambos tipos en el mismo archivo de enseñanza para que dotnet run siga siendo simple. Ejecuta con dotnet run. La pantalla debería mostrar una línea: ok. La palabra new construye un objeto desde la clase. La variable c guarda ese objeto. Llamas beep en c, no en el nombre de clase solo. Ese objeto construido — y la llamada que lo usa — es lo que enseña esta página. Mantén el nombre de la clase pública de inicio Pine.

Un objeto desde la clase

Una clase sigue siendo el tipo con nombre. Un objeto es un valor construido desde ese tipo. La línea new Chip() pide a C# que construya ese valor. Lo guardas en una variable cuyo tipo es Chip y usas la variable para alcanzar métodos que pertenecen a cada objeto.
Abre el archivo Pine. El nombre de la clase de inicio sigue siendo Pine. Esta página no renombra el iniciador. Borra cualquier resto de Badge.show(); si esa llamada static es todo lo que aún tienes en Main. Borra cualquier resto de recursión down. Borra cualquier línea ReadLine. El archivo que guardas no espera escritura.
Fuera de las llaves de Pine — todavía en el mismo archivo — escribe public class Chip. Dentro de Chip, escribe void beep() — sin la palabra static en este encabezado. El cuerpo es una línea de escritura: Console.WriteLine("ok");. Mantén void. El método no devuelve un número. En esta página no hay Main dentro de Chip. Guarda el archivo antes de ejecutar.
El primer programa en caja muestra Chip solo para que leas el tipo con claridad. Los programas en caja posteriores son las formas guardadas con Pine construyendo un chip, luego dos.

Pine construye el chip y luego llama beep

Pine conserva public static void Main(). Dentro de Main, escribe dos líneas: primero Chip c = new Chip();, luego c.beep();. La primera línea declara una variable c de tipo Chip y la llena con un objeto nuevo. La segunda línea llama beep en ese objeto. El punto va después del nombre de la variable, no después del nombre de la clase solo. En esta página no escribes Badge.show();. Esa fue la llamada static de la lección de clases.

Lee el archivo guardado desde arriba. using System; prepara nombres cortos. public class Pine es el iniciador. public static void Main() es donde arranca el tiempo de ejecución. La expresión new Chip() construye un objeto. Ese objeto se guarda en c. La llamada c.beep() entra en beep para ese objeto. El método escribe ok y vuelve. Luego termina Pine. La palabra en la pantalla vino del método del objeto, después de que new creó el objeto.
Ejecútalo con dotnet run. El programa escribe una línea y para. No espera a que tú escribas. Si dotnet run espera, ReadLine sigue en el archivo. Borra esa línea y mantén en Pine Chip c = new Chip(); más c.beep();, con beep en Chip. La pantalla muestra ok. Si la pantalla muestra ready, aún corre una llamada sobrante Badge.show();. Si la pantalla muestra las letras Chip, una línea de escritura tiene comillas: Console.WriteLine("Chip");. No reinstales el SDK de .NET por una pantalla que muestra la línea incorrecta.
Recorre la ejecución una vez más en orden. C# empieza en Pine.Main. La primera sentencia construye un objeto con new Chip() y lo guarda en c. La segunda sentencia llama c.beep(). Dentro de beep, WriteLine escribe ok. Luego termina beep y en Main no queda nada, así que el programa termina. En esta página no pusiste Console.WriteLine("ok"); dentro de Pine. Lo pusiste bajo Chip y lo pediste a través de la variable del objeto.
Piensa en la clase como el plano en el archivo y en el objeto como una pieza construida en memoria para esta ejecución. Cada new Chip() construye otra pieza. La variable nombra la pieza para que las líneas posteriores la alcancen. Sin ese nombre, la pieza construida no tiene asa para beep en esta página.

Por qué la llamada usa c, no Chip solo

En la página de clases, un método static podía llamarse como Badge.show() con el nombre del tipo. Aquí beep no tiene la palabra static. C# espera primero un objeto. Escribir Chip.beep(); sin un objeto no encaja con esta forma para principiantes. Construye con new, guarda el resultado en una variable y luego llama a través de esa variable.
Si escribes solo new Chip(); y nunca lo guardas, igual construiste un objeto, pero no te queda un nombre para llamar beep. En esta página mantén la variable: Chip c = new Chip(); luego c.beep();. La variable es cómo alcanzas el objeto después de que new termina.
Una demo static sobrante puede confundir Main. Un archivo que aún llama Badge.show(); es la forma de la lección anterior. Para esta página mantén Chip y Pine y la línea new. Aquí no necesitas Badge.

Dos objetos, dos beeps

Puedes construir más de un objeto desde la misma clase. Cada new Chip() hace un objeto aparte. Cada objeto puede ejecutar beep por su cuenta. El texto de la clase es compartido; los objetos no son el mismo valor.

Ejecuta de nuevo con dotnet run. La pantalla debería mostrar dos líneas: ok, luego ok. La primera línea vino de a. La segunda vino de b. Ambas usaron el mismo texto del método beep en Chip, pero cada llamada corrió en un objeto distinto construido con new.
Si la pantalla muestra solo un ok, comprueba que ambas llamadas estén presentes y que ambas variables se construyeran con new. Escribir Chip b = a; no construye un segundo objeto; hace que b se refiera al mismo objeto que a. Esa idea espera páginas posteriores. En esta página usa dos expresiones new Chip() cuando quieras dos objetos.
Puedes renombrar la variable de c a unit si quieres: Chip unit = new Chip(); luego unit.beep();. La pantalla sigue en ok mientras el cuerpo del método escriba esa palabra. El nombre de la variable es tuyo; el nombre del tipo Chip y la expresión new Chip() deben seguir coincidiendo.

Lo que esta página deja para los campos

Esta página aún no guarda un número ni una palabra dentro del chip. Los campos — nombres que guardan datos en cada objeto — son la página siguiente. Aquí el objeto existe después de new, y el método de instancia beep solo escribe. Eso basta para ver la separación entre la clase como tipo y un objeto como valor construido.
No anides Chip dentro de las llaves de Pine. En esta página las dos clases se sientan como hermanas en el archivo. Los métodos de Chip viven dentro de Chip. Main vive dentro de Pine. Puedes cambiar la palabra escrita dentro de beep a ping y ejecutar de nuevo. La pantalla debería seguir la cadena que pusiste en Chip. La forma de new y la llamada en Pine se mantiene.
Si la compilación no encuentra Chip al traducir Pine, comprueba que public class Chip esté en el mismo archivo y que la línea de clase diga de verdad Chip. Si la ejecución no escribe nada, confirma que Main aún llama c.beep(); después de la línea new, y que beep todavía contiene el WriteLine.

Puedes escribir Chip con void beep(), construir un objeto con Chip c = new Chip(); y llamar c.beep(); desde Pine.Main. Ejecuta con dotnet run. La pantalla muestra ok. Un segundo new Chip() construye otro objeto que puede hacer beep por su cuenta. Piensa en Chip como el plano y en cada new Chip() como una pieza construida que puedes nombrar. Pine sigue siendo la puerta que abres con dotnet run. La página siguiente son los campos, donde cada objeto empieza a guardar sus propios datos almacenados.