How do classes, objects and constructors work?

Question

IT Interview Practice · Accepted Answer

A **class** is a blueprint; an **object** is an instance created from it. A **constructor** is a special method that initializes a new object. Together they're the foundation of Java's object-oriented model.

## Defining a class with a 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;
    }
}
```

The constructor runs when you create an object, setting up its initial state. `this` refers to the current object, disambiguating fields from parameters of the same name.

## Creating objects

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

The `new` keyword allocates memory on the heap and invokes the constructor; `p` holds a reference to the new object.

## Constructor overloading and chaining

```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)
    }
}
```

You can have **multiple constructors** with different parameter lists (overloading), and one can call another with `this(...)` to avoid duplicating initialization.

## The default constructor

```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
```

If you write no constructor, Java supplies a no-argument default. As soon as you define any constructor, that default disappears (you must add it explicitly if needed).

## Why it matters

Classes, objects, and constructors are the absolute foundation of Java programming — everything you build is composed of objects created from classes.

Understanding how constructors initialize state (`this`, the `new` keyword's role, constructor overloading and chaining for flexible creation, and the default-constructor rule) is essential for correctly creating and initializing objects.

These concepts underpin all OOP work in Java, and constructor behavior (especially the disappearing default and chaining) is a common source of both interview questions and real bugs.

Defining a class with a constructor

Creating objects

Constructor overloading and chaining

The default constructor

Why it matters

Related questions