வகுப்புகள், பொருள்கள் மற்றும் கட்டமைப்பிகள் எவ்வாறு செயல்படுகின்றன?

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 வேலைகளின் அடிப்படை, மற்றும் கட்டமைப்பி நடத்தை (குறிப்பாக இயல்பான மறைவு மற்றும் சங்கிலி) பொதுவாக பேட்டி கேள்விகள் மற்றும் உண்மையான பிழைகளின் மூலம் உள்ளது.