Creando objetos usando el operador new

1. Cómo crear un objeto correctamente

El operador new en C# es como un botón mágico que convierte un "plano" (nuestra clase) en una instancia real (objeto) con la que puedes trabajar. Dicho de otra forma: la clase define qué puede hacer el objeto y qué propiedades tiene, y new crea ese objeto en la memoria del ordenador.

Sin el operador new, nuestras clases serían como planos sin edificios: puedes mirarlos, discutirlos, pero ni saltar ni derramar té en el sillón de alcántara vas a poder.

Si la clase es la receta de una pizza, el operador new es el cocinero que, siguiendo esa receta, crea una pizza real y sabrosa. El objeto es el resultado: la pizza en la caja, lista para comer.

Sintaxis

Veamos cómo usar este todopoderoso new. Aquí tienes la sintaxis básica si tienes una clase Contact:

Contact cont = new Contact();

• Contact a la izquierda — es el tipo de variable que estamos creando.
• cont — el nombre de la variable (elige nombres con sentido si no quieres sufrir haciendo debug en el futuro).
• new Contact() — llamada al operador new, que crea un objeto del tipo Contact.

En la memoria

Cuando se ejecuta este código, el sistema operativo reserva un trozo de memoria para el nuevo objeto y devuelve una referencia (dirección) donde ese objeto "vive". Esa referencia se guarda en la variable cont.

Esquema

+------------------+             +--------------------+
|  variable cont   | --------->  |   Objeto Contact   |
+------------------+             +--------------------+
          |
          |       (contiene nombre, teléfono, email, ...)
          |
         dirección

2. Creamos objetos de contactos

En los ejemplos anteriores inventamos esta clase:

public class Contact
{
    public string Name;
    public string Phone;
    public string Email;
}

Ahora vamos a crear un nuevo objeto del tipo Contact:

Contact friend = new Contact();
friend.Name = "Ivan Ivanov";
friend.Phone = "+1-999-123-45-67";
friend.Email = "ivan@example.com";

Console.WriteLine($"Nombre: {friend.Name}, Teléfono: {friend.Phone}, Email: {friend.Email}");

¿Qué pasa aquí?

1. Creamos el objeto usando new Contact().
2. Asignamos valores a sus campos.
3. Mostramos los datos por pantalla.

Ejemplo 2:

Vamos a trabajar con varios contactos — creamos otro objeto más:

Contact boss = new Contact();
boss.Name = "Anastasia Sergeevna";
boss.Phone = "+1-888-765-43-21";
boss.Email = "nastya@company.com";

Console.WriteLine($"Jefa: {boss.Name}, Teléfono: {boss.Phone}");

¿No te recuerda a rellenar un formulario para cada colega? Así funcionan los objetos: cada instancia creada tiene sus propios valores únicos y los guarda aparte de los demás.

3. Usando un array de objetos

Si necesitas guardar no uno ni dos, sino, por ejemplo, diez contactos, tiene sentido ponerlos en un array:

Contact[] contacts = new Contact[3];           // array para 3 objetos

contacts[0] = new Contact();
contacts[0].Name = "Denis";
contacts[0].Phone = "+7-911-111-22-33";

contacts[1] = new Contact();
contacts[1].Name = "Maria";
contacts[1].Phone = "+7-915-123-45-67";

contacts[2] = new Contact();
contacts[2].Name = "Petr";
contacts[2].Phone = "+7-921-543-21-00";

// Mostramos todos por pantalla
for (int i = 0; i < contacts.Length; i++)
{
    Console.WriteLine($"Contacto {i+1}: {contacts[i].Name}, {contacts[i].Phone}");
}

Importante: usamos new para cada elemento del array. Solo crear el array no crea los objetos, solo prepara el espacio para las referencias.

4. El operador new y el valor por defecto

A veces surge la pregunta — ¿y si solo declaro una variable del tipo Contact pero no le asigno un objeto con new, qué pasa?

Contact someContact;
someContact.Name = "Error";    // ¡Error de compilación!

Si escribes:

Contact someContact = null;

entonces si intentas acceder a someContact.Name tu programa va a "petar" con la famosa excepción:

System.NullReferenceException: La referencia al objeto no apunta a una instancia de objeto.

Para evitar esto, siempre inicializa los objetos usando new antes de usarlos.

5. Llamando al constructor

Cuando escribes new Contact(), en ese momento se llama a un método especial — el constructor. Por ahora nuestra clase no tiene constructores definidos, así que se usa el constructor implícito (por defecto), que crea el objeto y pone todos los campos a sus valores por defecto (null para tipos referencia y cero para los numéricos).

En la próxima lección aprenderás a crear tus propios constructores — por ejemplo, para pasar el nombre y el teléfono directamente. Por ahora solo tenemos el constructor sin parámetros.

Ejemplos de la vida real

Trabajar con objetos usando el operador new es el pan de cada día de cualquier desarrollador de C#. Imagina que:

• Creas un usuario en una web — en el código aparece un nuevo objeto User.
• Abres un pedido en una tienda online — aparece un nuevo Order.
• Guardas datos de un libro — nuevo objeto Book.

En cualquier programa moderno en C# vas a ver miles de líneas con el operador new.

Memoria antes de crear el objeto

            Contact firstContact; // Variable, pero no apunta a nada

+--------------------------+
|   firstContact           |---->  null (¡nada!)
+--------------------------+

Después de crear el objeto

Contact firstContact = new Contact();

+--------------------------+                 +----------------------+
|   firstContact           |---------------->|   Objeto Contact     |
+--------------------------+                 +----------------------+

6. Ejemplo práctico

Supón que quieres permitir al usuario crear nuevos contactos escribiendo desde el teclado:

Console.WriteLine("Introduce el nombre:");
string name = Console.ReadLine();

Console.WriteLine("Introduce el teléfono:");
string phone = Console.ReadLine();

Contact newContact = new Contact();
newContact.Name = name;
newContact.Phone = phone;

Console.WriteLine($"Contacto guardado: {newContact.Name}, {newContact.Phone}");

Ahora cada entrada del usuario va a crear su propio objeto único en memoria, que puedes guardar, modificar, mostrar — ¡hacer lo que quieras con él!

7. Errores típicos y trampas divertidas

Error nº1: olvidaste llamar a new antes de trabajar con el objeto.
Si declaras una variable pero no la inicializas, te arriesgas a tener un error de compilación o un NullReferenceException en tiempo de ejecución. Es un clásico: declaras el objeto — créalo enseguida con new si de verdad lo necesitas.

Error nº2: creaste un array de objetos, pero no creaste los objetos.
Aquí una trampa común: creas un array del tipo Contact[], pero olvidas que dentro solo hay null. Si intentas acceder a contacts[0].Name va a petar. Primero tienes que inicializar cada elemento del array por separado: contacts[i] = new Contact();.

Error nº3: confundir método con propiedad.
A veces los que empiezan creen que un método se puede usar como un campo: escriben student.GetName en vez de student.GetName(). Esto funciona si no intentas usar el resultado enseguida — pero el compilador se quejará si intentas meter el "método" donde se espera un valor. Siempre revisa: un método se llama con paréntesis, aunque no tenga parámetros.