1. Key Characteristics of a Constructor
✅ Same name as the class
✅ No return type (not even void
)
✅ Called automatically when an object is instantiated
✅ Used to initialize instance variables
✅ Can be overloaded (multiple constructors in the same class)
2. Example: Basic Constructor
class Car {
String model;
// Constructor (same name as class)
Car(String modelName) {
model = modelName; // Initializing instance variable
}
void display() {
System.out.println("Car Model: " + model);
}
}
public class ConstructorExample {
public static void main(String[] args) {
Car car1 = new Car("Tesla Model 3"); // Constructor is called
car1.display(); // Output: Car Model: Tesla Model 3
}
}
✅ The constructor initializes model
when Car
is created.
3. Types of Constructors
(a) Default Constructor
- A constructor without parameters.
- If no constructor is explicitly defined, Java automatically provides a default constructor.
Example: Default Constructor
class Animal {
Animal() { // No parameters
System.out.println("An Animal is Created!");
}
}
public class DefaultConstructorExample {
public static void main(String[] args) {
Animal a = new Animal(); // Calls the default constructor
}
}
✅ Output:
An Animal is Created!
(b) Parameterized Constructor
- Accepts arguments to initialize fields.
Example: Parameterized Constructor
class Person {
String name;
int age;
// Parameterized constructor
Person(String name, int age) {
this.name = name;
this.age = age;
}
void display() {
System.out.println(name + " is " + age + " years old.");
}
}
public class ParameterizedConstructorExample {
public static void main(String[] args) {
Person p = new Person("Alice", 25);
p.display(); // Output: Alice is 25 years old.
}
}
✅ Uses constructor parameters to initialize name
and age
.
(c) Copy Constructor
- Creates a new object by copying the values of an existing object.
Example: Copy Constructor
class Book {
String title;
// Constructor
Book(String title) {
this.title = title;
}
// Copy Constructor
Book(Book other) {
this.title = other.title;
}
void display() {
System.out.println("Book Title: " + title);
}
}
public class CopyConstructorExample {
public static void main(String[] args) {
Book b1 = new Book("Java Programming");
Book b2 = new Book(b1); // Copy constructor
b1.display(); // Java Programming
b2.display(); // Java Programming
}
}
✅ Creates an exact copy of b1
in b2
.
(d) Private Constructor
- Used to restrict object creation (commonly used in the Singleton pattern).
Example: Singleton Pattern Using a Private Constructor
class Singleton {
private static Singleton instance;
private Singleton() { // Private constructor
System.out.println("Singleton Instance Created");
}
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
public class PrivateConstructorExample {
public static void main(String[] args) {
Singleton obj1 = Singleton.getInstance(); // Only one instance
Singleton obj2 = Singleton.getInstance(); // Same instance reused
}
}
✅ Output:
Singleton Instance Created
🛑 Prevents multiple object creation!
4. Constructor Overloading
- Multiple constructors in the same class, but with different parameters.
Example: Constructor Overloading
class Employee {
String name;
int age;
// Constructor 1
Employee() {
this.name = "Unknown";
this.age = 0;
}
// Constructor 2
Employee(String name) {
this.name = name;
this.age = 0;
}
// Constructor 3
Employee(String name, int age) {
this.name = name;
this.age = age;
}
void display() {
System.out.println("Employee: " + name + ", Age: " + age);
}
}
public class ConstructorOverloadingExample {
public static void main(String[] args) {
Employee e1 = new Employee();
Employee e2 = new Employee("Bob");
Employee e3 = new Employee("Alice", 30);
e1.display(); // Employee: Unknown, Age: 0
e2.display(); // Employee: Bob, Age: 0
e3.display(); // Employee: Alice, Age: 30
}
}
✅ Different constructors allow flexible object creation.
5. Difference Between Constructor and Method
Feature | Constructor | Method |
---|---|---|
Purpose | Initializes an object | Defines behavior of an object |
Name | Same as the class name | Can have any name |
Return Type | ❌ No return type | ✅ Has a return type |
Called When? | Automatically at object creation | Explicitly called |
Overloading | ✅ Yes, multiple constructors can exist | ✅ Yes, multiple methods can exist |
✅ Example: Constructor vs. Method
class Student {
String name;
// Constructor
Student(String name) {
this.name = name;
}
// Method
void display() {
System.out.println("Student Name: " + name);
}
}
public class ConstructorVsMethodExample {
public static void main(String[] args) {
Student s = new Student("Alice"); // Constructor called
s.display(); // Method called
}
}
✅ Constructor initializes, method displays.
6. Summary
Constructor Type | Description |
---|---|
Default Constructor | No parameters, auto-created if not defined. |
Parameterized Constructor | Accepts arguments to initialize fields. |
Copy Constructor | Creates a new object by copying another object. |
Private Constructor | Restricts object creation (Singleton pattern). |
Constructor Overloading | Multiple constructors with different parameters. |
7. Conclusion
✅ A constructor is a special method used to initialize objects in Java.
✅ It runs automatically when an object is created.
✅ It can be overloaded and customized for different initialization scenarios.