कक्षाएं, ऑब्जेक्ट और कंस्ट्रक्टर कैसे काम करते हैं?

Question

Accepted Answer

एक **कक्षा** एक ब्लूप्रिंट है ; एक **ऑब्जेक्ट** इससे बनाया गया एक उदाहरण है। एक **कंस्ट्रक्टर** एक विशेष विधि है जो एक नई ऑब्जेक्ट को प्रारंभ करती है। एक साथ, वे Java के ऑब्जेक्ट-ओरिएंटेड मॉडल की नींव हैं।

## कंस्ट्रक्टर के साथ कक्षा को परिभाषित करना

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

जब आप एक ऑब्जेक्ट बनाते हैं तो कंस्ट्रक्टर चलता है, इसकी प्रारंभिक स्थिति को सेट करता है। `this` वर्तमान ऑब्जेक्ट को संदर्भित करता है, समान नाम वाले फील्ड और पैरामीटर को स्पष्ट करता है।

## ऑब्जेक्ट बनाना

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

`new` कीवर्ड हीप पर मेमोरी आवंटित करता है और कंस्ट्रक्टर को आमंत्रित करता है ; `p` नई ऑब्जेक्ट को संदर्भ रखता है।

## कंस्ट्रक्टर ओवरलोडिंग और चेनिंग

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

आप **कई कंस्ट्रक्टर** हो सकते हैं जिनमें विभिन्न पैरामीटर सूची (ओवरलोडिंग) है, और एक `this(...)` के साथ दूसरे को कॉल कर सकता है प्रारंभीकरण को डुप्लिकेट करने से बचने के लिए।

## डिफ़ॉल्ट कंस्ट्रक्टर

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

यदि आप कोई कंस्ट्रक्टर नहीं लिखते हैं, तो Java एक बिना-तर्क डिफ़ॉल्ट प्रदान करता है। जैसे ही आप कोई कंस्ट्रक्टर परिभाषित करते हैं, वह डिफ़ॉल्ट गायब हो जाता है (यदि आवश्यक हो तो आपको इसे स्पष्ट रूप से जोड़ना चाहिए)।

## यह क्यों महत्वपूर्ण है

कक्षाएं, ऑब्जेक्ट और कंस्ट्रक्टर Java प्रोग्रामिंग की पूर्ण नींव हैं — आप जो कुछ भी बनाते हैं वह कक्षाओं से बनाई गई ऑब्जेक्ट से बना होता है।

यह समझना कि कंस्ट्रक्टर स्थिति को कैसे प्रारंभ करते हैं (`this`, `new` कीवर्ड की भूमिका, लचीले निर्माण के लिए कंस्ट्रक्टर ओवरलोडिंग और चेनिंग, और डिफ़ॉल्ट-कंस्ट्रक्टर नियम) ऑब्जेक्ट को सही तरीके से बनाने और प्रारंभ करने के लिए आवश्यक है।

ये अवधारणाएं Java में सभी OOP कार्यों को रेखांकित करती हैं, और कंस्ट्रक्टर व्यवहार (विशेष रूप से गायब डिफ़ॉल्ट और चेनिंग) साक्षात्कार प्रश्न और वास्तविक बग दोनों का एक सामान्य स्रोत है।