ਕਲਾਸ, ਆਬਜੈਕਟ ਅਤੇ ਕੰਸਟਰਕਟਰ ਕਿਵੇਂ ਕੰਮ ਕਰਦੇ ਹਨ?

Question

Accepted Answer

ਇੱਕ **class** ਇੱਕ ਬਲੂਪ੍ਰਿੰਟ ਹੈ; ਇੱਕ **object** ਇਸ ਤੋਂ ਬਣਾਈ ਗਈ ਇੱਕ ਮਿਸਾਲ ਹੈ। ਇੱਕ **constructor** ਇੱਕ ਖਾਸ ਢੰਗ ਹੈ ਜੋ ਇੱਕ ਨਵੀਂ ਆਬਜੈਕਟ ਨੂੰ ਸ਼ੁਰੂ ਕਰਦਾ ਹੈ। ਇਕੱਠੇ ਇਹ 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 ਕੰਮ ਦੇ ਅਧੀਨ ਹਨ, ਅਤੇ ਕੰਸਟਰਕਟਰ ਆਚਰਣ (ਖਾਸ ਤੌਰ ਤੇ ਲੋਪ ਹੋਣ ਵਾਲਾ ਡਿਫਾਲਟ ਅਤੇ ਚੈਨਿੰਗ) ਇੰਟਰਵਿਊ ਸਵਾਲਾਂ ਅਤੇ ਅਸਲ ਬੱਗ ਦੋਵਾਂ ਦਾ ਆਮ ਸਰੋਤ ਹੈ।