ഇന്റർഫേസ് (ഒബ്ജക്റ്റ് ഓറിയന്റഡ് പ്രോഗ്രാമിംഗ്)

ഓബ്‌ജക്റ്റ്-ഓറിയന്റഡ് പ്രോഗ്രാമിംഗിൽ, **ഇന്റർഫേസ്** എന്നത് ചില പ്രവർത്തനങ്ങളുടെ രൂപരേഖ മാത്രമാണ്, എന്നാൽ ആ പ്രവർത്തനങ്ങൾ എങ്ങനെ നടപ്പാക്കണമെന്ന് പറയുന്നില്ല. ഇന്റർഫേസ് ഒരു പണിയിലേക്കുള്ള മാർഗരേഖ തന്നെയാണ്, എന്നാൽ ആ മാർഗം പല ക്ലാസുകൾക്കും പിന്തുടരാമെന്ന് പറയാം. അത് പാലിക്കുന്ന ക്ലാസുകൾക്ക് അവിടെ പറഞ്ഞ പ്രവർത്തനങ്ങൾ ചെയ്യാനുള്ള കഴിവ് ഉണ്ടാകുന്നു. ഒരു ക്ലാസ് പ്രോട്ടോക്കോളിൽ കൊടുത്തിരിക്കുന്ന രീതികളെ നടപ്പിലാക്കുകയാണെങ്കിൽ, ആ ക്ലാസ് പ്രോട്ടോക്കോൾ സ്വീകരിച്ചതായോ, ഇന്റർഫേസ് നടപ്പിലാക്കിയതായോ പറയും.

ഓരോ ഒബ്ജക്റ്റിന്റെ ഉള്ളടക്കം മറച്ചുവെച്ചിരിക്കുമ്പോൾ, മറ്റു ഒബ്ജക്റ്റുകൾ അതുമായി എങ്ങനെ പ്രവർത്തിക്കാമെന്ന് പറയുന്ന ഏക മാർഗം പ്രോട്ടോക്കോൾ ആണ്. ഉദാഹരണത്തിന്, ജാവയിൽ `Comparable` ഇന്റർഫേസ് ഒരു `compareTo()`എന്ന രീതി നിർദ്ദേശിക്കുന്നു, ആ ഇന്റർഫേസ് നടപ്പിലാക്കുന്ന ക്ലാസുകൾ ആ രീതി പ്രവർത്തിപ്പിക്കണം. `Comparable` ഇന്റർഫേസ് പിന്തുടരുന്ന ഏതൊരു ഒബ്ജക്റ്റ് ഗ്രൂപ്പും സോർട്ട് ചെയ്യാം(സോർട്ടിംഗ് എന്നു പറയുന്നത്, ഒരു ഗ്രൂപ്പിലുള്ള വസ്തുക്കളെ (ഉദാഹരണത്തിന്, നമ്പറുകൾ, പേരുകൾ, ഇമേജുകൾ) ഒരു പ്രത്യേക ക്രമത്തിൽ ക്രമീകരിക്കുന്ന പ്രക്രിയയാണ്. ഉദാഹരണത്തിന്, നമ്പറുകൾ ചെറുതിൽ നിന്ന് വലുതിലേക്ക് ക്രമീകരിക്കുന്നത് അല്ലെങ്കിൽ പേരുകൾ ആൽഫബെറ്റിക് ക്രമത്തിൽ വരുത്തുന്നത്), അവയുടെ ഉള്ളടക്കം അറിയാതെ തന്നെ പക്ഷേ, അവ തമ്മിൽ താരതമ്യം ചെയ്യാനായി `compareTo()` ഉപയോഗിക്കണമെന്നു മാത്രമേ അറിയേണ്ടതുള്ളു.

`compareTo()` ഉപയോഗിക്കുന്ന ഒരു ഇന്റർഫേസ് ഉദാഹരണം കാണാം. ഇത് സാധാരണയായി `Comparable` ഇന്റർഫേസ് ഉപയോഗിച്ച് തിരിച്ചറിയപ്പെടുന്നു, അത് രണ്ടു ഒബ്ജക്റ്റുകൾ തമ്മിൽ താരതമ്യം ചെയ്യാനായി ഉപയോഗിക്കുന്നു.

```javascript
// Comparable ഇന്റർഫേസ്, compareTo() രീതി നിർവചിക്കുന്നു
interface Comparable {
    int compareTo(Object o); // CompareTo() സിഗ്നേച്ചർ
}

// Person എന്ന ക്ലാസ്, Comparable ഇന്റർഫേസ് നടപ്പിലാക്കുന്നു
class Person implements Comparable {
    String name;
    int age;

    // Person ഓബ്ജക്റ്റ് ഇൻറൈഷ്യലൈസ് ചെയ്യാൻ Constructor
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // Comparable ഇന്റർഫേസ് ഇല്ലാത്ത compareTo() രീതി നടപ്പിലാക്കുന്നു
    @Override
    public int compareTo(Object o) {
        // Object നെ Person ആക്കി typecast ചെയ്ത് താരതമ്യം ചെയ്യുന്നു
        Person other = (Person) o;

        // പ്രായത്തിനനുസരിച്ച് താരതമ്യം ചെയ്യുന്നു
        if (this.age < other.age) {
            return -1;  // ഈ വ്യക്തി ചെറുതാണ്
        } else if (this.age > other.age) {
            return 1;   // ഈ വ്യക്തി വലിയവനാണ്
        } else {
            return 0;   // രണ്ടുപേരും സമാന പ്രായത്തിലുള്ളവരാണ്
        }
    }
}

// പ്രധാന ക്ലാസ്, compareTo() പരിശോധിക്കാൻ
public class Main {
    public static void main(String[] args) {
        Person person1 = new Person("John", 25);
        Person person2 = new Person("Alice", 30);
        Person person3 = new Person("Bob", 25);

        System.out.println(person1.compareTo(person2));  // ഔട്ട്‌പുട്ട്: -1 (John, Alice-നെക്കാൾ ചെറുതാണ്)
        System.out.println(person1.compareTo(person3));  // ഔട്ട്‌പുട്ട്: 0 (John, Bob സമാന പ്രായം)
        System.out.println(person2.compareTo(person3));  // ഔട്ട്‌പുട്ട്: 1 (Alice, Bob-നെക്കാൾ വലിയവളാണ്)
    }
}
```

;വിശദീകരണം:
`Comparable` Interface: `compareTo()` എന്നൊരു മെത്തഡ് സിഗ്നേച്ചർ ഉള്ള ഒരു ഇന്റർഫേസ് ആണ്. ഈ മെത്തഡ് ഉപയോഗിച്ച് നിരവധി ഒബ്ജക്റ്റുകൾ തമ്മിൽ താരതമ്യം ചെയ്യാനാകും.

പേഴ്സൺ ക്ലാസ്സ്: പേഴ്സൺ ക്ലാസ് `Comparable` ഇന്റർഫേസ് നടപ്പിലാക്കുന്നു. `compareTo()` മെത്തഡ് അവിടെ നടപ്പിലാക്കുന്നു, ഇത് ഒരു Person ഒബ്ജക്റ്റിനെ മറ്റൊരു Person ഒബ്ജക്റ്റുമായി താരതമ്യം ചെയ്യുന്നു. ഈ ഉദാഹരണത്തിൽ, age എന്ന ഫീൽഡ് അടിസ്ഥാനമാക്കി താരതമ്യം ചെയ്യുന്നു.

ഔട്ട്പുട്ട്: `compareTo()` മെത്തഡിന്റെ ഫലം:

*-1: ആദ്യത്തെ ഒബ്ജക്റ്റ് രണ്ടാമത്തെ ഒബ്ജക്റ്റിനേക്കാൾ ചെറുതാണ്.
*1: ആദ്യത്തെ ഒബ്ജക്റ്റ് രണ്ടാമത്തെ ഒബ്ജക്റ്റിനേക്കാൾ വലിയതാണ്.
*0: രണ്ടു ഒബ്ജക്റ്റുകളും സമാനമാണ്.
ഇങ്ങനെ, `compareTo()`മെത്തഡ് ഉപയോഗിച്ച് ഒന്നിലധികം ഒബ്ജക്റ്റുകൾ തമ്മിൽ ക്രമീകരണത്തിനായി താരതമ്യപ്പെടുത്താനാകും.

ചില പ്രോഗ്രാമിംഗ് ഭാഷകൾ (ഉദാഹരണത്തിന്, അഡ, സി#, ഡാർട്ട്, ഗോ, ജാവ, പൈത്തൺ 3.8 ലോഗ്‌ടോക്ക്, ഒബ്‌ജക്റ്റ് പാസ്കൽ, ഒബ്‌ജക്റ്റീവ്-സി, ഒകാമൽ, പിഎച്ച്പി, റാക്കറ്റ്, സീഡ്7, സ്വിഫ്റ്റ്, മുതലായവ) പ്രോട്ടോകോളുകൾ (അഥവാ ഇന്റർഫേസുകൾ) സൃഷ്ടിക്കാൻ നേരിട്ടുള്ള പിന്തുണ നൽകുന്നു. ഇത് ഒട്ടേറെ ക്ലാസുകൾക്ക് സാധാരണ രീതിയിൽ പ്രവർത്തനം നിർവഹിക്കാൻ സഹായിക്കുന്നു. സി++ പോലുള്ള ഭാഷകളിൽ, പല തരം പോളിമോർഫിസത്തെ പിന്തുണയ്ക്കുന്ന ഭാഷകളിൽ, ഇന്റർഫേസുകൾ സാധാരണയായി അബ്സ്ട്രാക്റ്റ് ക്ലാസുകൾ ആയി ഉപയോഗിക്കുന്നുണ്ട്.

വ്യക്തമായ നിയമങ്ങൾ ഇല്ലാത്ത ഭാഷകളിൽ, പ്രോട്ടോകോളുകൾ സാധാരണയായി ഒരു പൊതു രീതി സ്വീകരിച്ചേക്കാം. "ഡക്ക് ടൈപിംഗ്" എന്നത്, എന്തെങ്കിലും ഒരു പ്രവർത്തനം ചെയ്യുന്നുവെങ്കിൽ അത് എങ്ങനെ പ്രവർത്തിക്കണം എന്നതിനെ നിർബന്ധം കൂടാതെ അനുസരിക്കുക എന്നതാണ്. പൈത്തണിൽ, `__iter__` മെത്തഡ് ഉള്ള ക്ലാസ്സ് ഒരു കളക്ഷനായി ഉപയോഗിക്കാവുന്നതാണ്.

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

റസ്റ്റിൽ ട്രേയിറ്റ്സ്(traits) എന്നത് ഒരു "ജോലി വിവരപത്രം(job description)" പോലെയാണ്. അതിൽ പറയുന്ന പ്രവർത്തനങ്ങൾ സ്ട്രക്ടുകളിൽ(struct) എങ്ങനെ പ്രവർത്തിക്കണമെന്ന് നിർവചിക്കുന്നു. ഉദാഹരണത്തിന്, "study" എന്ന ട്രെയിറ്റ്സ് ഉണ്ടാക്കി, അതിൽ ഒരു `study` എന്ന ഫങ്ഷൻ ചേർത്താൽ, സ്ട്രക്റ്റിൽ അത് നടപ്പാക്കിയാൽ, സ്ട്രക്ട് സ്റ്റഡി ചെയ്യുന്നതിന് വേണ്ടി പ്രവർത്തിക്കും. ഇതിലൂടെ സ്ട്രക്ടുകൾക്ക് ഒരു പോലെ പ്രവർത്തനങ്ങൾ നടത്താൻ കഴിയുന്നുണ്ട്.
## അവലംബം