Constructor
A constructor is a special method with the same name as the class, called automatically when an object is created with the 'new' keyword.
It lets us give an object a valid starting state right away — without setting each field separately.
class Student {
String name;
Student(String n) { name = n; }
}
Student s1 = new Student("Aarav");Default constructor koi arguments nahi leta aur fields ko default values (0, null, false) par set karta hai — agar tum khud kuch nahi likhte to Java automatically ek "no-arg" constructor de deta hai (isse hi "default constructor" kehte hain, technically).
Parameterized constructor arguments leta hai taaki object ko turant meaningful starting values di ja sakein — real projects mein zyadatar classes parameterized constructor hi use karti hain, kyunki "khaali" object shayad hi kabhi useful hota hai.
Zaroori baat: agar tum khud koi constructor (parameterized ya no-arg) likhte ho, Java automatic default constructor dena band kar deta hai — agar tumhe dono chahiye (no-arg aur parameterized), dono explicitly likhne padenge.
class Student {
String name;
Student() { name = "Unknown"; } // no-arg
Student(String n) { name = n; } // parameterized
}Ek class mein multiple constructors ho sakte hain, different parameters (number ya type) ke saath — jaise Java ke built-in classes mein hota hai (new ArrayList() ya new ArrayList(20) ya new ArrayList(anotherList) donon valid hain). Isse object banane ke multiple flexible tareeke milte hain, caller apni situation ke hisaab se choose kar sakta hai.
class Rectangle {
int width, height;
Rectangle() { this(1, 1); } // default: 1x1
Rectangle(int side) { this(side, side); } // square
Rectangle(int w, int h) { width = w; height = h; }
}this(...) se ek constructor doosre constructor (usi class ke) ko call kar sakta hai — duplicate initialization code avoid karne ke liye. Upar wale Rectangle example mein dekho, kaise har chhota constructor bade ko call kar raha hai.
super(...) se child class ka constructor parent class ke constructor ko call karta hai — taaki parent ka setup pehle ho jaaye.
Dono ka ek strict rule hai: ye call constructor ki *bilkul pehli* line honi chahiye — na to dono ek saath likh sakte ho (this() aur super() ek hi constructor mein nahi ho sakte), na inse pehle koi aur code.
class Student {
String name; int age;
Student(String name) { this(name, 18); } // chaining
Student(String name, int age) { this.name = name; this.age = age; }
}Constructor class ke naam se juda hota hai, isliye child class parent ke constructor ko directly inherit NAHI karti — ye ek common confusion hai. Lekin child apne constructor mein super(...) ke through parent ka constructor call kar sakta hai, aur agar child kuch na likhe, Java automatically super() (parent ka no-arg constructor) call karta hai default behavior mein.