Constructors in Java
In Java, constructors are special methods used to initialize objects of a class. They are called automatically when an object is created and help set the initial state of the object.
What is a Constructor?
- A constructor has the same name as the class.
- It does not have a return type, not even
void. - Used to initialize object attributes when an object is created.
Syntax:
class ClassName {
// Constructor
ClassName() {
// Initialization code
}
}
Note: If you don’t define a constructor, Java provides a default constructor automatically.
Types of Constructors
A. Default Constructor
- Provided by Java if no constructor is explicitly defined.
- No parameters.
- Initializes objects with default values.
Example – Default Constructor Provided by Java:
class Car {
String color;
int speed;
}
public class Main {
public static void main(String[] args) {
Car myCar = new Car(); // Default constructor
System.out.println("Color: " + myCar.color); // null
System.out.println("Speed: " + myCar.speed); // 0
}
}
Note: Default values: null for objects, 0 for numeric types, false for boolean.
B. Parameterized Constructor
- Takes parameters to initialize object attributes.
- Allows you to create objects with custom values.
Example – Parameterized Constructor:
class Car {
String color;
int speed;
// Parameterized Constructor
Car(String c, int s) {
color = c;
speed = s;
}
void display() {
System.out.println(color + " car is driving at " + speed + " km/h");
}
}
public class Main {
public static void main(String[] args) {
Car car1 = new Car("Red", 80);
Car car2 = new Car("Blue", 120);
car1.display();
car2.display();
}
}
Output:
Red car is driving at 80 km/h
Blue car is driving at 120 km/h
Note: Parameterized constructors make object creation more flexible and readable.
Constructor Overloading
Java allows multiple constructors in the same class with different parameter lists. This is called constructor overloading.
Example:
class Car {
String color;
int speed;
Car() { // Default
color = "White";
speed = 0;
}
Car(String c) { // Single parameter
color = c;
speed = 50;
}
Car(String c, int s) { // Two parameters
color = c;
speed = s;
}
void display() {
System.out.println(color + " car at " + speed + " km/h");
}
}
public class Main {
public static void main(String[] args) {
Car car1 = new Car();
Car car2 = new Car("Red");
Car car3 = new Car("Blue", 100);
car1.display();
car2.display();
car3.display();
}
}
Output:
White car at 0 km/h
Red car at 50 km/h
Blue car at 100 km/h
Points to Remember
- Constructor name = class name, no return type.
- Default constructor is provided automatically if no constructor is defined.
- Parameterized constructors allow custom initialization.
- Constructor overloading helps initialize objects in different ways.
- Called automatically when an object is created.