ક્લાસ, ઑબ્જેક્ટ્સ અને કન્સ્ટ્રક્ટર કેવી રીતે કાર્ય કરે છે?

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` કીવર્ડ heap પર મેમોરી ફાળવે છે અને કન્સ્ટ્રક્ટરને આમંત્રણ આપે છે ; `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 કામ અને ઇન્ટરવ્યુ પ્રશ્ન અને વાસ્તવિક બગ્સ બંનેનો સામાન્ય સ્ત્રોત છે.