Creación de objetos con new

1. La palabra clave new

En Java, para crear un objeto de cualquier clase se utiliza la palabra clave new. Esta palabra «mágica» le pide a la JVM: reserva memoria para un nuevo objeto y llama a su constructor.

Analogía:
Si una clase es el plano de un coche, entonces new es la fábrica que, a partir de ese plano, ensambla un coche real.

Ejemplo

Person person = new Person();

Qué ocurre aquí:

1. new Person() — se crea un nuevo objeto de tipo Person (se invoca el constructor).
2. person — variable que almacena la referencia al objeto creado.

Cómo se ve en memoria

Cuando escribes Person person = new Person();, se reserva en memoria un área para los campos del objeto (por ejemplo, nombre y edad), y la variable person contiene la dirección de esa área — una referencia.

Atención:
Si te olvidas de escribir new, la variable será solo una referencia que no apunta a nada (null). Intentar acceder a los campos o métodos de ese «objeto vacío» provocará un NullPointerException.

2. Llamada al constructor: ¿cómo funciona?

Un constructor es un método especial que se invoca al crear un objeto y que inicializa sus campos, dejando la instancia lista para usarse.

Sintaxis

ClassName variableName = new ClassName(arguments);

• Si la clase tiene un constructor con parámetros, hay que pasarlos obligatoriamente.
• Si el constructor no tiene parámetros (o es el predeterminado), los paréntesis quedan vacíos.

Ejemplo: constructor con parámetros

public class Person {
    String name;
    int age;

    // Constructor con parámetros
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

Creamos un objeto:

Person person1 = new Person("Petya", 25);

Los valores "Petya" y 25 irán a los campos name y age del nuevo objeto.

Constructor sin parámetros

public Person() {
    this.name = "Sin nombre";
    this.age = 0;
}

Ahora puedes escribir:

Person mysteryMan = new Person(); // name="Sin nombre", age=0

3. Trabajo con el objeto: campos y métodos

Después de crear un objeto, puedes acceder a sus campos y métodos mediante el operador punto (.):

person1.name = "Peter";
System.out.println(person1.name); // Peter

person1.sayHello();

Si en la clase existe un método:

public void sayHello() {
    System.out.println("Hola, me llamo " + name + "!");
}

Entonces la llamada person1.sayHello(); imprimirá: Hola, me llamo Peter!

Ejemplo: clase completa

public class Person {
    String name;
    int age;

    public Person(String name, int age) { // constructor
        this.name = name;
        this.age = age;
    }

    public void sayHello() { // método
        System.out.println("Hola, me llamo " + name + "!");
    }
}

Uso:

Person person = new Person("Vasya", 30);
person.sayHello(); // Hola, me llamo Vasya!

4. Variables de referencia: ¿qué son?

Una variable de tipo clase en Java es una referencia a un objeto en memoria, no el propio objeto.

Demostración

Person person = new Person("Vasya", 30);
Person anotherVasya = person;

Ahora tanto person como anotherVasya apuntan al mismo objeto en memoria. Si cambias un campo a través de una variable, cambiará también para la otra:

anotherVasya.age = 31;
System.out.println(person.age); // 31

Punto importante:
Si creas dos objetos distintos, son independientes:

Person person1 = new Person("Petya", 25);
Person person2 = new Person("Masha", 22);

person1.age = 99;
System.out.println(person2.age); // 22 (¡no ha cambiado!)

5. Ejemplo: creación y uso de varios objetos

Añadamos varios objetos a la aplicación. Supongamos que tenemos la clase Person, y en main creamos varias personas e imprimimos sus saludos.

Clase Person

public class Person {
    String name;
    int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void sayHello() {
        System.out.println("Hola, me llamo " + name + ", tengo " + age + " años!");
    }
}

Uso en main

public class Main {
    public static void main(String[] args) {
        Person person = new Person("Vasya", 25);
        Person person1 = new Person("Petya", 27);

        person.sayHello(); // Hola, me llamo Vasya, tengo 25 años!
        person1.sayHello(); // Hola, me llamo Petya, tengo 27 años!

        // Demostración de independencia de los objetos:
        person.age = 100;
        person.sayHello(); // Hola, me llamo Vasya, tengo 100 años!
        person1.sayHello(); // Hola, me llamo Petya, tengo 27 años!
    }
}

Salida del programa:

Hola, me llamo Vasya, tengo 25 años!
Hola, me llamo Petya, tengo 27 años!
Hola, me llamo Vasya, tengo 100 años!
Hola, me llamo Petya, tengo 27 años!

6. Errores típicos al crear objetos

Error n.º 1: olvidaste escribir new

Person person;
person.name = "Vasya"; // NullPointerException!

La variable person no hace referencia a ningún objeto (null). Es imprescindible crear el objeto con new.

Error n.º 2: no pasaste los parámetros al constructor

Person person1 = new Person(); // Error de compilación si no hay un constructor sin parámetros

Si en la clase solo existe un constructor con parámetros, debes indicar esos parámetros al crear el objeto.

Error n.º 3: pensar que la variable almacena el propio objeto

Person a = new Person("Anna", 20);
Person b = a;
b.age = 99;
System.out.println(a.age); // 99, porque a y b son referencias al mismo objeto!

En Java, una variable de tipo clase es siempre una referencia, no el objeto en sí.

Error n.º 4: cambias los campos de un objeto esperando que el otro no cambie

Person x = new Person("X", 1);
Person y = x;
x.age = 42;
System.out.println(y.age); // 42

Si necesitas dos objetos independientes, ¡créalos por separado!