A constructor in Java is a special method used to initialize objects. It is automatically called when an object is created. The main purpose of a constructor is to assign initial values to the object's fields.
Characteristics of a Constructor
Same Name as Class
A constructor must have the same name as the class.
class Person {
Person() { // Constructor name = Class name
System.out.println("Person object created!");
}
}
No Return Type
Unlike methods, constructors do not have a return type (not even void).
class Example {
Example() { // Constructor
System.out.println("Object initialized!");
}
}
Automatically Called
It executes when an object is created using new.
Example obj = new Example(); // Constructor runs automatically
Can Have Parameters
Just like methods, constructors can accept parameters to initialize object values.
class Car {
String brand;
Car(String brand) { // Parameterized constructor
this.brand = brand;
}
}
Can Have Multiple Constructors (Constructor Overloading)
Java allows multiple constructors with different parameter lists (overloading).
class Person {
Person() { System.out.println("Default Constructor!"); }
Person(String name) { System.out.println("Hello, " + name); }
}
Can have access modifiers
Constructors in Java can have access modifiers just like methods and fields. The access modifier of a constructor determines where it can be accessed.
Access Modifiers for Constructors
Access Modifier
Description
public
The constructor is accessible from anywhere in the project.
private
The constructor is accessible only within the same class (used in Singleton pattern).
Prevents direct object creation from outside the class.
Used in Singleton Pattern to ensure only one instance exists.
protected
The constructor is accessible within the same package and in subclasses.
Allows access within the same package and in subclasses.
Used when creating an abstract class with a protected constructor.
default (no modifier)
The constructor is accessible only within the same package.
// Public Constructor
// ---------------------------------------
class Person {
public Person() { // Public Constructor
System.out.println("Person object created!");
}
}
public class Main {
public static void main(String[] args) {
Person p = new Person(); // Allowed
}
}
// ---------------------------------------
// Private Constructor (Singleton Pattern)
// ---------------------------------------
class Singleton {
private static Singleton instance;
private Singleton() { // Private Constructor
// The message appears only once, proving that only one instance is created.
System.out.println("Singleton Instance Created!");
}
public static Singleton getInstance() {
if (instance == null)
instance = new Singleton();
return instance;
}
}
public class Main {
public static void main(String[] args) {
// Singleton s = new Singleton(); // Not Allowed (Compilation Error)
Singleton s1 = Singleton.getInstance(); // Allowed
Singleton s2 = Singleton.getInstance(); // Same instance returned
}
}
// ---------------------------------------
// Protected Constructor (Inheritance)
// ---------------------------------------
class Animal {
protected Animal() { // Protected Constructor
System.out.println("Animal object created!");
}
}
class Dog extends Animal {
Dog() {
super(); // Allowed in subclass
System.out.println("Dog object created!");
}
}
public class Main {
public static void main(String[] args) {
Dog d = new Dog(); // Allowed
}
}
// ---------------------------------------
// Default (Package-Private) Constructor
// ---------------------------------------
class Car {
Car() { // Default Constructor (No Modifier)
System.out.println("Car object created!");
}
}
public class Main {
public static void main(String[] args) {
Car c = new Car(); // Allowed (same package)
}
}
package anotherPackage;
import myPackage.Car;
public class Test {
public static void main(String[] args) {
Car c = new Car(); // Not Allowed (Compilation Error)
}
}
// ---------------------------------------
Example
class Car {
String brand;
int speed;
// Constructor
Car(String brand, int speed) {
this.brand = brand;
this.speed = speed;
System.out.println(brand + " car created with speed " + speed + " km/h.");
}
}
public class Main {
public static void main(String[] args) {
Car car1 = new Car("Toyota", 120);
Car car2 = new Car("Honda", 100);
/* Output:
Toyota car created with speed 120 km/h.
Honda car created with speed 100 km/h.
*/
}
}
Types of Constructors in Java
1. Default Constructor (No-Argument Constructor)
A constructor without parameters that initializes default values.
class Dog {
String breed;
Dog() { // Default constructor
breed = "Unknown";
System.out.println("A dog is created!");
}
}
Dog d = new Dog(); // Output: A dog is created!
2. Parameterized Constructor
A constructor that accepts arguments to initialize object fields.
Laptop l = new Laptop("Dell");
System.out.println(l.brand); // Output: Dell
3. Copy Constructor
A constructor that copies values from another object.
class Book {
String title;
// Parameterized Constructor
Book(String title) {
this.title = title;
}
// Copy Constructor
Book(Book b) {
this.title = b.title;
}
}
Usage:
Book b1 = new Book("Java Programming");
Book b2 = new Book(b1);
System.out.println(b2.title); // Output: Java Programming
4. Private Constructor
A constructor that is private to prevent object creation. Used in Singleton Design Pattern.
class Singleton {
private static Singleton instance;
private Singleton() { } // Private Constructor
public static Singleton getInstance() {
if (instance == null)
instance = new Singleton();
return instance;
}
}
Usage:
Singleton obj = Singleton.getInstance(); // Only one instance allowed
5. Constructor Overloading
A class can have multiple constructors with different parameters.
class Student {
String name;
int age;
// Constructor Overloading
Student() { name = "Unknown"; age = 0; }
Student(String name) { this.name = name; }
Student(String name, int age) { this.name = name; this.age = age; }
}
Usage:
Student s1 = new Student();
Student s2 = new Student("Alice");
Student s3 = new Student("Bob", 20);
Can we have Destructors in Java?
Java does not have destructors like C++, but it provides finalization mechanisms for resource cleanup.
Why No Destructors in Java?
Garbage Collection Handles Memory Cleanup:
In Java, objects are automatically garbage collected when they are no longer referenced.
Unlike C++, where destructors explicitly free memory, Java depends on the JVM's garbage collector.
No Explicit Object Destruction:
In C++, destructors (~ClassName()) are used for manual cleanup of allocated memory and resources.
In Java, there is no direct equivalent because objects are deallocated by the JVM's garbage collector, making explicit destruction unnecessary.
Alternatives to Destructors in Java
1. finalize() (Deprecated)
Java provided a finalize() method in Object class as a cleanup mechanism, but it was unreliable and has been deprecated in Java 9.
Called before garbage collection, but not guaranteed to execute immediately or at all.
class Example {
@Override
protected void finalize() throws Throwable {
System.out.println("Finalize method called");
}
}
Why Avoid finalize()?
Unpredictable execution (depends on garbage collection timing).
Causes performance overhead.
Might not run before program exit.
2. try-with-resources (Preferred Approach)
For managing resources like files, database connections, sockets, etc., Java provides the try-with-resources mechanism. Classes that implement AutoCloseable or Closeable can be automatically closed when the block exits.
