ക്ലാസ് (കമ്പ്യൂട്ടർ പ്രോഗ്രാമിംഗ്)

ക്ലാസ് എന്നത് ഒബ്ജക്റ്റ് ഓറിയെന്റഡ് പ്രോഗ്രാമിംഗിൽ ഒരു ടെംപ്ലേറ്റ് പോലെയാണ്. ഇത് ഒരു ഒബ്ജക്റ്റിന്റെ സ്റ്റേറ്റ് (വേരിയബിളുകൾ) ബിഹേവിയർ (മെത്തേഡുകൾ) എന്നിവ നിർവചിക്കുന്നു. ഉദാഹരണത്തിന്, നിങ്ങൾക്ക് "കാർ" എന്ന ക്ലാസ് ഉണ്ടെന്ന് കരുതുക. ഈ ക്ലാസിൽ കാറിന്റെ നിറം, മോഡൽ തുടങ്ങിയ വിവരങ്ങളും (സ്റ്റേറ്റ്) കാർ ഓടിക്കുക, നിർത്തുക തുടങ്ങിയ പ്രവർത്തനങ്ങളും (ബിഹേവിയർ) ഉണ്ടാകും. ഈ ക്ലാസിൽ നിന്ന് സൃഷ്ടിക്കുന്ന ഓരോ ഒബ്ജക്റ്റിനും (ഉദാഹരണത്തിന്, ഒരു പ്രത്യേക കാർ) ഈ സ്വഭാവസവിശേഷതകൾ ഉണ്ടാകും. ചില സവിശേഷതകൾ എല്ലാ ഒബ്ജക്റ്റുകൾക്കും പൊതുവായിരിക്കും, ചിലത് ഓരോ ഒബ്ജക്റ്റിനും വ്യക്തിഗതമായിരിക്കും. ഇത് പ്രോഗ്രാമിംഗ് ഭാഷ അനുസരിച്ച് വ്യത്യാസപ്പെടാം.

ക്ലാസിന്റെ ഓരോ ഇൻസ്റ്റൻസിനും (ഒബ്ജക്റ്റ്) അതിന്റെ സ്വന്തം സ്റ്റേറ്റ് ഉണ്ടാകും, അത് മറ്റ് ഇൻസ്റ്റൻസുകളിൽ നിന്ന് വ്യത്യസ്തമായിരിക്കും. എന്നാൽ, ക്ലാസ് സ്റ്റേറ്റ് എല്ലാ ഇൻസ്റ്റൻസുകളും പങ്കിടുന്ന ഒരു പൊതു സ്റ്റേറ്റ് ആണ്. ഒബ്ജക്റ്റ് മെത്തേഡുകൾക്ക് ആ ഒബ്ജക്റ്റിന്റെ സ്റ്റേറ്റ് ആക്സസ് ചെയ്യാൻ കഴിയും (ഇംപ്ലിസിറ്റ് അല്ലെങ്കിൽ എക്സ്പ്ലിസിറ്റ് പാരാമീറ്റർ വഴി), പക്ഷേ ക്ലാസ് മെത്തേഡുകൾക്ക് ഒബ്ജക്റ്റ് സ്റ്റേറ്റ് ആക്സസ് ചെയ്യാൻ കഴിയില്ല. ഇത് ലളിതമായി മനസ്സിലാക്കാം: ഒരു ക്ലാസ് എന്നത് ഒരു മോൾഡ് പോലെയാണ്, അതിൽ നിന്ന് നിങ്ങൾക്ക് പല ഒബ്ജക്റ്റുകൾ (ഉദാഹരണത്തിന്, കാറുകൾ) സൃഷ്ടിക്കാം. ഓരോ ഒബ്ജക്റ്റിനും അതിന്റെ സ്വന്തം സവിശേഷതകൾ ഉണ്ടാകും (ഉദാഹരണത്തിന്, ഒരു കാറിന്റെ നിറം), അത് മറ്റ് ഒബ്ജക്റ്റുകളിൽ നിന്ന് വ്യത്യസ്തമാകാം. എന്നാൽ, ക്ലാസിന് ഒരു പൊതു സവിശേഷതയും ഉണ്ടാകാം (ഉദാഹരണത്തിന്, എത്ര കാറുകൾ സൃഷ്ടിച്ചു എന്നത്), അത് എല്ലാ ഒബ്ജക്റ്റുകളും പങ്കിടുന്നു. ഒബ്ജക്റ്റിന്റെ പ്രവർത്തനങ്ങൾക്ക് (ഉദാഹരണത്തിന്, കാർ ഓടിക്കുക) അതിന്റെ സ്വന്തം സവിശേഷതകൾ ഉപയോഗിക്കാൻ കഴിയും, പക്ഷേ ക്ലാസ് പ്രവർത്തനങ്ങൾക്ക് ഒബ്ജക്റ്റിന്റെ സവിശേഷതകൾ ഉപയോഗിക്കാൻ കഴിയില്ല, അവ പൊതുവായ പ്രവർത്തനങ്ങൾ മാത്രം നിർവഹിക്കും.
ജാവാസ്ക്രിപ്റ്റ് കോഡിലുള്ള ലളിതമായ ഒരു ഉദാഹരണം:
// ക്ലാസ് ഡിഫൈൻ ചെയ്യുക
class Car {
    // ക്ലാസ് സ്റ്റേറ്റ് (എല്ലാ കാറുകൾക്കും പൊതുവായത്)
    static totalCars = 0;

    constructor(color) {
        // ഒബ്ജക്റ്റ് സ്റ്റേറ്റ് (ഓരോ കാറിനും പ്രത്യേകം പ്രത്യേകം നിറങ്ങൾ)
        this.color = color;
        // ഒരു പുതിയ കാർ സൃഷ്ടിക്കുമ്പോൾ ക്ലാസ് സ്റ്റേറ്റ് അപ്ഡേറ്റ് ചെയ്യുക
        Car.totalCars += 1;
    }

    // ഒബ്ജക്റ്റ് മെത്തേഡ് (ഒബ്ജക്റ്റിന്റെ സ്റ്റേറ്റ് ഉപയോഗിക്കുന്നു)
    displayColor() {
        console.log(`ഈ കാറിന്റെ നിറം ${this.color} ആണ്.`);
    }

    // ക്ലാസ് മെത്തേഡ് (ക്ലാസ് സ്റ്റേറ്റ് ഉപയോഗിക്കുന്നു)
    static displayTotalCars() {
        console.log(`ആകെ കാറുകളുടെ എണ്ണം: ${Car.totalCars}`);
    }
}

// ഒബ്ജക്റ്റുകൾ സൃഷ്ടിക്കുക
const car1 = new Car("ചുവപ്പ്");
const car2 = new Car("നീല");

// ഒബ്ജക്റ്റ് മെത്തേഡ് വിളിക്കുക
car1.displayColor(); // ഔട്ട്പുട്ട്: ഈ കാറിന്റെ നിറം ചുവപ്പ് ആണ്.
car2.displayColor(); // ഔട്ട്പുട്ട്: ഈ കാറിന്റെ നിറം നീല ആണ്.

// ക്ലാസ് മെത്തേഡ് വിളിക്കുക
Car.displayTotalCars(); // ഔട്ട്പുട്ട്: ആകെ കാറുകളുടെ എണ്ണം: 2
വിശദീകരണം
ക്ലാസ് സ്റ്റേറ്റ് (`totalCars`): എല്ലാ കാറുകളും പങ്കിടുന്ന ഒരു പൊതു വേരിയബിൾ. ഇത് `static` ആയി ഡിഫൈൻ ചെയ്യുന്നു.
ഒബ്ജക്റ്റ് സ്റ്റേറ്റ് (`color`): ഓരോ കാറിനും അതിന്റെ സ്വന്തം നിറം ഉണ്ട്.
ഒബ്ജക്റ്റ് മെത്തേഡ് (`displayColor`): ഓരോ കാറിന്റെയും നിറം കൺസോളിൽ പ്രിന്റ് ചെയ്യുന്നു.
ക്ലാസ് മെത്തേഡ് (`displayTotalCars`): എല്ലാ കാറുകളുടെയും എണ്ണം കൺസോളിൽ പ്രിന്റ് ചെയ്യുന്നു. ഇതും `static` ആണ്.

ഇൻഹെറിറ്റൻസ് പിന്തുണയ്ക്കുന്ന ഭാഷയിൽ, ഒരു ക്ലാസ് മറ്റൊരു ക്ലാസ്സിന്റെ അടിസ്ഥാനത്തിൽ ആക്കാവുന്നതാണ്. പുതിയ ക്ലാസ്സിന് അതിന്റെ മേൽ ക്ലാസ്സിന്റെ എല്ലാ പ്രത്യേകതകളും (സ്റ്റേറ്റ്, ബിഹേവിയർ) ഉണ്ടാകും, കൂടാതെ പുതിയ പ്രത്യേകതകളും (സ്റ്റേറ്റ്, ബിഹേവിയർ) ലഭിക്കും. അതിനാൽ, പുതിയ ക്ലാസ്സ് സബ്‌ക്ലാസ് ആയും, അതിന്റെ അടിസ്ഥാന ക്ലാസ്സ് സൂപ്പർക്ലാസ് ആയും കണക്കാക്കപ്പെടുന്നു.
ഗുണവിശേഷങ്ങൾ
ഒബജക്ട് ലൈഫ് സൈക്കിൾ
ഒരു ക്ലാസിൽ നിന്നാണ് ഒബ്ജക്റ്റ് ഉണ്ടാക്കുന്നത്. ഒബ്ജക്റ്റ് ഉണ്ടാക്കുമ്പോൾ, അതിന്റെ ഡാറ്റ മെമ്മറിയിൽ സേവ് ചെയ്യപ്പെടുന്നു. കമ്പ്യൂട്ടർ കോഡ് ആ ഡാറ്റ ഉപയോഗിച്ച് അതിനെ പ്രവർത്തിപ്പിക്കും. ഒടുവിൽ, ഒബ്ജക്റ്റ് ഉപയോഗിച്ച് എല്ലാം കഴിഞ്ഞാൽ, ആ ഡാറ്റ മെമ്മറിയിൽ നിന്ന് നീക്കം ചെയ്യും. ഒരു ഒബ്ജക്റ്റ് സൃഷ്ടിക്കുമ്പോൾ അതിന്റെ പ്രവർത്തനങ്ങൾ എങ്ങനെ നടക്കുമെന്ന് പറയാൻ കൺസ്ട്രക്ടർ ഉപയോഗിക്കുന്നു. ഒബ്ജക്റ്റ് ഇല്ലാതാക്കുമ്പോൾ അതിന്റെ മെമ്മറി, റിസോഴ്‌സ് എന്നിവ തിരികെ നൽകാൻ ഡിസ്ട്രക്ടർ ഉപയോഗിക്കുന്നു. ഇത് ഒബ്ജക്റ്റിന്റെ തുടങ്ങലും അവസാനവും നിയന്ത്രിക്കാൻ സഹായിക്കും.

ഇവിടെ ജാവാസ്ക്രിപ്റ്റിൽ ഒരു സിമ്പിൾ കൺസ്ട്രക്റ്റർ ഡിസ്ട്രക്റ്റർ ഉള്ള ഉദാഹരണം കാണാം:
```javascript
class Car {
    // Constructor
    constructor(make, model) {
        this.make = make;
        this.model = model;
        console.log(`${this.make} ${this.model} created!`);
    }

    // Destructor (അല്ലെങ്കിൽ, റിസോഴ്സുകൾ എങ്ങനെ ഫ്രീയാക്കാമെന്ന് സിമുലേറ്റ് ചെയ്യാം)
    destroy() {
        console.log(`${this.make} ${this.model} destroyed!`);
        // ഇവിടെ ആവശ്യമായ റിസോഴ്‌സുകൾ ഒഴിവാക്കാം
    }
}

let myCar = new Car("Toyota", "Corolla"); // Constructor ഈ സമയത്ത് പ്രവർത്തിക്കും
myCar.destroy(); // Destructor ഇവിടെ പ്രവർത്തിക്കും
```

Output:
```
Toyota Corolla created!
Toyota Corolla destroyed!
```
വ്യാഖ്യാനം
കൺസ്ട്രക്റ്റർ `constructor(make, model)` - ഒബ്ജക്റ്റ് സൃഷ്ടിക്കുമ്പോൾ അതിന്റെ മെക്കും മോഡലും സെറ്റ് ചെയ്ത് "created!" പ്രിന്റ് ചെയ്യും.
ഡിസ്ട്രക്റ്റർ റിസോഴ്‌സുകൾ (resources) മോചിപ്പിക്കുന്നതിനായി ഒരു പ്രത്യേക ഡിസ്ട്രക്റ്റർ ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നില്ല, എങ്കിലും destroy()എന്ന ഫംഗ്ഷൻ ഉപയോഗിച്ച് "destroyed!" ചെയ്ത് ഒബ്ജക്റ്റിന്റെ അതിന്റെ ഉപയോഗം അവസാനിപ്പിക്കാം.

ജാവാസ്ക്രിപ്റ്റിൽ ഡിസ്ട്രക്റ്റർ യഥാർത്ഥത്തിൽ വേണമെന്നാൽ ഇല്ല, കാരണം ഗാർബേജ് കളക്ഷൻ(Garbage Collection) സ്വയം പ്രവർത്തിക്കുന്നു, അത് ഉപയോഗിക്കപ്പെടാത്ത ഒബ്ജക്റ്റുകൾ കണ്ടെത്തി അവയുടെ മെമ്മറി റിലീസ് ചെയ്യുന്നു.

ടൈപ്പ്
ഒരു ഇന്റർഫേസ് എന്ന് പറഞ്ഞാൽ, അത് ഒരു ബ്ലൂപ്രിന്റ് പോലെയാണ് – അതിൽ ഒന്നും നടത്തപ്പെടുന്നില്ല, പക്ഷേ എന്ത് പ്രവർത്തനങ്ങൾ ഉണ്ടാകണം എന്നതു മാത്രം പറയുന്നു. ഒരു ക്ലാസ് ആ ബ്ലൂപ്രിന്റ് പ്രകാരം പ്രവർത്തിക്കും, അതിനാൽ ക്ലാസ്സിൽ സൃഷ്ടിക്കുന്ന ഒബ്ജക്റ്റുകൾ ആ ബ്ലൂപ്രിന്റ് പ്രകാരം പ്രവർത്തിക്കും. അതായത്, ഇന്റർഫേസ് അനുസരിച്ച് ഒരു പ്രവർത്തനം എങ്ങനെ നടക്കണമെന്ന് ക്ലാസ് തീരുമാനിക്കുന്നു. ടൈപ്പ് (ഇന്റർഫേസ്) എന്നത് ക്ലാസുകളുടെ പ്രവർത്തനങ്ങളുടെ ഒരു സ്പെസിഫിക്കേഷൻ ആണ്. ക്ലാസ് അതിന്റെ ഇംപ്ലിമെന്റേഷനാണ്, അത് ടൈപ്പിന്റെ നിർദ്ദേശങ്ങൾ അനുസരിച്ച് പ്രവർത്തിക്കുന്നു. ഒരേ ടൈപ്പ് (ഇന്റർഫേസ്) പല ക്ലാസുകൾക്ക് നൽകാം, എന്നാൽ ഓരോ ക്ലാസും അതിന്റെ സ്വന്തം രീതിയിൽ പ്രവർത്തിക്കും. ഉദാഹരണത്തിന്, സ്റ്റാക്ക്(Stack) എന്ന ഇന്റർഫേസ് സ്മോൾസ്റ്റാക്ക് (SmallStack), സ്കെയിലബിൾസ്റ്റാക്ക് (ScalableStack) എന്നിവ പോലെ വ്യത്യസ്ത ക്ലാസുകൾ നൽകാം. ഇത് ഓരോ ക്ലാസിനും അതിന്റേതായ പ്രത്യേകതകൾ ഉണ്ടാക്കാനും ഒരേ ഇന്റർഫേസ് പിന്തുണയ്ക്കാനും സഹായിക്കുന്നു.
ഘടന
ഒരു ക്ലാസ്സിൽ ഡാറ്റാ ഫീൽഡുകൾ (അഥവാ പ്രോപ്പർട്ടീസ്, ഫീൽഡുകൾ, ആട്രിബ്യൂട്ടുകൾ) ക്ലാസ്സിന്റെ അംശങ്ങളാണ്, അത് ക്ലാസ്സിന്റെ സ്റ്റേറ്റ് സൂക്ഷിക്കുന്നു. ഈ ഫീൽഡുകൾക്ക് ഇന്റേണൽ ഡാറ്റ നൽകുന്ന ഘടകങ്ങൾ പോലെയാണ് പ്രവർത്തനം. ഓരോ ഫീൽഡും ഒരു പ്രത്യേക വാല്യു സൂക്ഷിച്ച് ക്ലാസിന്റെ സ്വഭാവം (state) നിർണ്ണയിക്കുന്നു. ഉദാഹരണത്തിന്, നെയിം(name), എയ്ജ്(age), ബാലൻസ്(balance) എന്നിവ ഒരു ക്ലാസിന്റെ ഫീൽഡുകളായി നൽകുന്നു. ഈ ഡാറ്റാ ഫീൽഡുകൾ ക്ലാസ്സിന്റെ പ്രവർത്തനത്തെ നിയന്ത്രിക്കും. പൈത്തണിലെ ഒബ്ജക്ടുകൾ ക്രമീകരിക്കാൻ, ക്ലാസ് സൃഷ്ടിക്കുന്ന രീതിക്ക് പൊതുവെ പ്രത്യേകമായ മെമ്മറി ഘടന ഇല്ല. അതിന്റെ പകരം, പൈത്തൺ ഒബ്ജക്ടുകൾ "അസോസിയേറ്റീവ് കി-വാല്യൂ കണ്ടെയ്‌നറുകൾ" (key-value pairs) ഉപയോഗിക്കുന്നു. പൈത്തണിലെ ഓരോ ഒബ്ജക്ടിലും ഒരു ഡിക്ഷണറി പോലെയുള്ള ഘടന ഉണ്ടാകും, അതിൽ ഓരോ പാരാമീറ്ററുടെയും പേരും (കീ) അത് സൂക്ഷിക്കുന്ന വിലയും (വാല്യു) സൂക്ഷിക്കപ്പെടും.  
ഉദാഹരണത്തിന്:
```പൈത്തൺ
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
```
ഇവിടെ, `Person` എന്ന ക്ലാസ്സിന്റെ ഓരോ ഒബ്ജക്ട് സൃഷ്ടിക്കുമ്പോൾ, പൈത്തൺ അതിന്റെ ഉള്ളടക്കം ഒരു കീ-വാല്യൂ ഡാറ്റായിരിക്കും സ്റ്റോർ ചെയ്യുന്നത്. പൈത്തൺ ഒബ്ജക്ടുകൾ ഒരു "കീ-വാല്യു" പട്ടികയിൽ സൂക്ഷിക്കുന്നത് പോലെ, `person1` എടുക്കുമ്പോൾ അതിന്റെ വിവരങ്ങൾ (name: "John", age: 25) ഇതുപോലെ സൂക്ഷിക്കും. ഇതിന് അനുസരിച്ച്, ഓരോ കീ (name, age) യുടെ മൂല്യം (John, 25) സൂക്ഷിക്കപ്പെടുന്നു. പൈത്തൺ ഒബ്ജക്ടുകളുമായി ബന്ധപ്പെട്ട വിവരങ്ങൾ(data) ഒരു "കീ-വാല്യു പട്ടിക"യിൽ സൂക്ഷിക്കുന്നുണ്ട്, അതിനാൽ മെമ്മറി ക്രമം സ്ഥിരമല്ല. മറ്റ് ഭാഷകളിൽ, ഒബ്ജക്ടുകളുടെ മെമ്മറി ക്രമം എപ്പോഴും നിശ്ചിതവും ശാസ്ത്രീയവുമായിരിക്കും. ഈ സങ്കേതം പൈത്തണിനെ കൂടുതൽ ഫ്ലെക്സിബിളാക്കുന്നു, എന്നാൽ മറ്റു ഭാഷകൾക്ക് മെമ്മറി കുറച്ചും ശക്തിയുള്ള ക്ലാസുകൾക്കായി ഒരു സ്പെസിഫിക് ഘടന സ്വീകരിക്കേണ്ടതുണ്ട്.

അവലംബം