తరగతులు, వస్తువులు మరియు నిర్మాతలు ఎలా పనిచేస్తారు?

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 పనికు ఆధారం, మరియు నిర్మాత ప్రవర్తన (ముఖ్యంగా డిఫాల్ట్ అదృశ్యమవడం మరియు చెయినింగ్) साक్ష్యం ప్రశ్నలు మరియు నిజమైన దోషాల సాధారణ మూలం.