¿Cómo funcionan las clases, los objetos y los constructores?

Question

IT Interview Practice · Accepted Answer

Una **clase** es un plano; un **objeto** es una instancia creada a partir de ella. Un **constructor** es un método especial que inicializa un nuevo objeto. Juntos, son la base del modelo orientado a objetos de Java.

## Definición de una clase con un constructor

```java
public class Person {
    private String name;        // fields (instance variables)
    private int age;

// CONSTRUCTOR — same name as the class, no return type
    public Person(String name, int age) {
        this.name = name;       // `this` distinguishes field from parameter
        this.age = age;
    }

public String greet() {     // method
        return "Hi, I'm " + name;
    }
}
```

El constructor se ejecuta cuando creas un objeto, estableciendo su estado inicial. `this` se refiere al objeto actual, diferenciando campos de parámetros con el mismo nombre.

## Creación de objetos

```java
Person p = new Person("Ann", 30);   // `new` allocates the object + calls the constructor
p.greet();                           // "Hi, I'm Ann"
```

La palabra clave `new` asigna memoria en el heap e invoca el constructor; `p` mantiene una referencia al nuevo objeto.

## Sobrecarga de constructores y encadenamiento

```java
public class Person {
    private String name;
    private int age;

public Person(String name, int age) {   // primary constructor
        this.name = name;
        this.age = age;
    }
    public Person(String name) {             // overloaded — different parameters
        this(name, 0);                        // calls the other constructor (chaining)
    }
}
```

Puedes tener **múltiples constructores** con diferentes listas de parámetros (sobrecarga), y uno puede llamar a otro con `this(...)` para evitar duplicar la inicialización.

## El constructor predeterminado

```java
public class Empty {
    // no constructor defined → Java provides an implicit no-arg constructor
}
Empty e = new Empty();   // works
// BUT: once you define ANY constructor, the implicit one is gone
```

Si no escribes un constructor, Java proporciona uno predeterminado sin argumentos. Tan pronto como definas cualquier constructor, ese predeterminado desaparece (debes añadirlo explícitamente si es necesario).

## Por qué es importante

Las clases, los objetos y los constructores son la base absoluta de la programación Java — todo lo que construyas está compuesto por objetos creados a partir de clases.

Comprender cómo los constructores inicializan el estado (`this`, el papel de la palabra clave `new`, la sobrecarga de constructores y el encadenamiento para una creación flexible, y la regla del constructor predeterminado) es esencial para crear e inicializar correctamente los objetos.

Estos conceptos sustentan todo el trabajo OOP en Java, y el comportamiento del constructor (especialmente la desaparición del predeterminado y el encadenamiento) es una fuente común tanto de preguntas de entrevista como de errores reales.

Definición de una clase con un constructor

Creación de objetos

Sobrecarga de constructores y encadenamiento

El constructor predeterminado

Por qué es importante

Preguntas relacionadas