PHP-യിലെ OOP: ഒരു തുടക്കക്കാരന്റെ ഗൈഡ്

PHP-യിൽ Regex
PHP-യിലെ കൺസ്ട്രക്‌റ്ററുകളും ഡിസ്ട്രക്‌റ്ററുകളും

ഒബ്ജക്റ്റ്-ഓറിയന്റഡ് പ്രോഗ്രാമിംഗ് (OOP) എന്നത് ക്ലാസുകളുടെ ഉദാഹരണങ്ങളായ ഒബ്‌ജക്റ്റുകൾ ഉപയോഗിച്ച് ഡാറ്റയെയും പെരുമാറ്റത്തെയും പ്രതിനിധീകരിക്കുകയും കൈകാര്യം ചെയ്യുകയും ചെയ്യുന്ന ഒരു പ്രോഗ്രാമിംഗ് മാതൃകയാണ്. അന്തർനിർമ്മിത പ്രവർത്തനങ്ങളുടെയും ഘടനകളുടെയും ഒരു ശേഖരം വഴി PHP OOP പിന്തുണ നൽകുന്നു.

ഒബ്‌ജക്‌റ്റുകൾ നിർമ്മിക്കുന്നതിനുള്ള ഒരു ബ്ലൂപ്രിന്റാണ് PHP-യിലെ ഒരു ക്ലാസ്. ഒരു ക്ലാസ് ഒരു വസ്തുവിനെ നിർവചിക്കുന്നു പ്രോപ്പർട്ടികൾ (അംഗ വേരിയബിളുകൾ അല്ലെങ്കിൽ ആട്രിബ്യൂട്ടുകൾ എന്നും അറിയപ്പെടുന്നു) രീതികളും (അംഗങ്ങളുടെ പ്രവർത്തനങ്ങൾ അല്ലെങ്കിൽ പെരുമാറ്റങ്ങൾ എന്നും അറിയപ്പെടുന്നു). യഥാക്രമം ഗുണങ്ങളും രീതികളും വ്യക്തമാക്കുന്നതിന് "var", "function" എന്നീ പദങ്ങൾ ക്ലാസിനുള്ളിൽ ഉപയോഗിക്കുന്നു. അടിസ്ഥാന PHP ക്ലാസിന്റെ ഒരു ഉദാഹരണം ഇതാ:

class Person {
    var $name;
    var $age;

    function setName($name) {
        $this->name = $name;
    }

    function getName() {
        return $this->name;
    }

    function setAge($age) {
        $this->age = $age;
    }

    function getAge() {
        return $this->age;
    }
}

ഈ ഉദാഹരണത്തിലെ "വ്യക്തി" എന്ന ക്ലാസ്സിൽ രണ്ട് പ്രോപ്പർട്ടികൾ അടങ്ങിയിരിക്കുന്നു: $name, $age. നാല് രീതികളും ഉണ്ട്: setName(), getName(), setAge(), and getAge(). ഈ രീതികൾ ഉപയോഗിക്കുന്നു ഗണം പ്രോപ്പർട്ടി മൂല്യങ്ങൾ വീണ്ടെടുക്കുക. "ഇത്" എന്ന പദം ക്ലാസിലെ നിലവിലെ വസ്തുവിനെ സൂചിപ്പിക്കുന്നു എന്നത് ശ്രദ്ധിക്കേണ്ടതാണ്.

ഒരു ക്ലാസ് ഒബ്‌ജക്റ്റ് നിർമ്മിക്കുന്നതിന്, ഞങ്ങൾ "പുതിയ" കീവേഡ് തുടർന്ന് ക്ലാസ് നാമം ഉപയോഗിക്കുന്നു. ഒരു ഉദാഹരണം ഇതാ:

$person = new Person();

നമുക്ക് ഒരു ഒബ്‌ജക്റ്റ് ലഭിച്ചുകഴിഞ്ഞാൽ, പ്രോപ്പർട്ടികളുടെ മൂല്യങ്ങൾ സജ്ജീകരിക്കാനും നേടാനും നമുക്ക് ക്ലാസിന്റെ രീതികൾ ഉപയോഗിക്കാം:

$person->setName("John Doe");
$person->setAge(30);

echo $person->getName(); // prints "John Doe"
echo $person->getAge(); // prints "30"

ഒബ്ജക്റ്റ്-ഓറിയന്റഡ് പ്രോഗ്രാമിംഗിലെ ഒരു അടിസ്ഥാന ആശയമാണ് പാരമ്പര്യം, അത് ഒരു ക്ലാസിനെ മറ്റൊന്നിൽ നിന്ന് ആട്രിബ്യൂട്ടുകളും ഫംഗ്ഷനുകളും അവകാശമാക്കാൻ അനുവദിക്കുന്നു. ഒരു സബ്ക്ലാസ് അല്ലെങ്കിൽ ഡെറൈവ്ഡ് ക്ലാസ് എന്നത് മറ്റൊരു ക്ലാസിൽ നിന്ന് പാരമ്പര്യമായി ലഭിക്കുന്ന ഒന്നാണ്, അതേസമയം അത് പാരമ്പര്യമായി ലഭിക്കുന്ന ക്ലാസ് സൂപ്പർക്ലാസ് അല്ലെങ്കിൽ ബേസ് ക്ലാസ് എന്നറിയപ്പെടുന്നു.

"വ്യക്തി" എന്ന സൂപ്പർക്ലാസിൽ നിന്ന് ഉരുത്തിരിഞ്ഞ "വിദ്യാർത്ഥി" ഉപവിഭാഗത്തിന്റെ ഒരു ഉദാഹരണം ഇതാ:

class Student extends Person {
    var $studentId;

    function setStudentId($id) {
        $this->studentId = $id;
    }

    function getStudentId() {
        return $this->studentId;
    }
}

ഈ ഉദാഹരണത്തിൽ, വിദ്യാർത്ഥി ക്ലാസിന് പേഴ്സൺ ക്ലാസിന്റെ എല്ലാ പ്രോപ്പർട്ടികളും രീതികളും അവകാശമാക്കുകയും അതിലേക്ക് ഒരു പുതിയ പ്രോപ്പർട്ടി $studentId, രീതികൾ setStudentId(), and getStudentId() എന്നിവ ചേർക്കുകയും ചെയ്യുന്നു.

$student = new Student();
$student->setName("Jane Doe");
$student->setAge(20);
$student->setStudentId("123456");

echo $student->getName(); // prints "Jane Doe"
echo $student->getAge(); // prints "20"
echo $student->getStudentId(); // prints "123456"

സംയോജകഘടകങ്ങള് ഒരു ക്ലാസ് നടപ്പിലാക്കേണ്ട ഒരു കൂട്ടം രീതികൾ വ്യക്തമാക്കുന്ന ഒരു തരം കരാറാണ്. ഒരു നിർവചിക്കാൻ ഇന്റർഫേസ് കീവേഡ് ഉപയോഗിക്കുന്നു ഇന്റർഫേസ്, കൂടാതെ ഇതിൽ മെത്തേഡ് സിഗ്നേച്ചറുകൾ മാത്രമേ ഉൾപ്പെടുത്താൻ കഴിയൂ, മെത്തേഡ് ബോഡികളല്ല.

ആകാരങ്ങൾക്കായുള്ള ഒരു കൂട്ടം രീതികൾ നിർവചിക്കുന്ന "ഷേപ്പ്" ഇന്റർഫേസിന്റെ ഒരു ഉദാഹരണം ഇതാ:

interface Shape {
    public function getArea();
    public function getPerimeter();
}

ഒരു ഇന്റർഫേസ് നടപ്പിലാക്കുന്ന ഒരു ക്ലാസ് ഇന്റർഫേസിൽ വ്യക്തമാക്കിയ രീതികൾ നിർവ്വചിക്കേണ്ടതാണ്. ഷേപ്പ് ഇന്റർഫേസ് നടപ്പിലാക്കുന്ന "ദീർഘചതുരം" എന്ന ക്ലാസിന്റെ ഒരു ഉദാഹരണം ഇതാ:

class Rectangle implements Shape {
    private $width;
    private $height;

    public function __construct($width, $height) {
        $this->width = $width;
        $this->height = $height;
    }

    public function getArea() {
        return $this->width * $this->height;
    }

    public function getPerimeter() {
        return 2 * ($this->width + $this->height);
    }
}

ഈ ഉദാഹരണത്തിൽ, ചതുരാകൃതിയിലുള്ള ക്ലാസ് ഷേപ്പ് ഇന്റർഫേസിന്റെ getArea(), getPerimeter() ഫംഗ്ഷനുകൾ നടപ്പിലാക്കുന്നു. നമുക്ക് ഇപ്പോൾ ഒരു ദീർഘചതുരാകൃതിയിലുള്ള ഒബ്ജക്റ്റ് നിർമ്മിച്ച് അത് ഉപയോഗിക്കാം രീതികൾ:

$rectangle = new Rectangle(5, 10);
echo $rectangle->getArea(); // prints "50"
echo $rectangle->getPerimeter(); // prints "30"

ക്ലാസുകൾ, വസ്തുക്കൾ, അവകാശം, കൂടാതെ ഇന്റർഫേസുകളാണ് PHP-യിലെ OOP-യുടെ അടിസ്ഥാന ആശയങ്ങൾ. സോഫ്‌റ്റ്‌വെയറിനെ കൂടുതൽ മോഡുലാർ, കൈകാര്യം ചെയ്യാവുന്നതും പുനരുപയോഗിക്കാവുന്നതുമാക്കാൻ PHP-യിൽ പ്രയോഗിച്ചേക്കാവുന്ന അമൂർത്തമായ ക്ലാസുകൾ, പോളിമോർഫിസം, എൻക്യാപ്‌സുലേഷൻ, തുടങ്ങിയവ.

PHP-യിലെ ഒരു മാതൃക മാത്രമാണ് OOP എന്നത് ഓർത്തിരിക്കേണ്ടത് പ്രധാനമാണ്; PHP കോഡ് നിർമ്മിക്കുന്നതിന് മറ്റ് നിരവധി രീതികളുണ്ട്; എങ്കിലും, OOP വ്യാപകമായി ഉപയോഗിക്കപ്പെടുന്നു, നിലവിലുള്ള PHP വികസനത്തിൽ ശുപാർശ ചെയ്യുന്ന ഒരു സമ്പ്രദായമായി കണക്കാക്കപ്പെടുന്നു.

ചോദ്യോത്തരങ്ങൾ

ചോദ്യം: എന്താണ് ഒബ്ജക്റ്റ് ഓറിയന്റഡ് പ്രോഗ്രാമിംഗ് (OOP)?
A: OOP എന്നത് ഒബ്‌ജക്‌റ്റുകൾ ഉപയോഗിച്ച് ഡാറ്റയെയും പെരുമാറ്റത്തെയും പ്രതിനിധീകരിക്കുകയും കൈകാര്യം ചെയ്യുകയും ചെയ്യുന്ന ഒരു പ്രോഗ്രാമിംഗ് മാതൃകയാണ്, അവ ക്ലാസുകളുടെ ഉദാഹരണങ്ങളാണ്.

ചോദ്യം: PHP OOPയെ പിന്തുണയ്ക്കുന്നുണ്ടോ?
A: അതെ, OOP പ്രവർത്തനക്ഷമമാക്കുന്നതിനുള്ള ബിൽറ്റ്-ഇൻ ഫംഗ്‌ഷനുകളും സവിശേഷതകളും ഉൾപ്പെടുന്ന ഒരു ജനപ്രിയ സെർവർ സൈഡ് സ്‌ക്രിപ്റ്റിംഗ് ഭാഷയാണ് PHP.

ചോദ്യം: പിഎച്ച്പിയിൽ ഒരു ഒബ്ജക്റ്റ് എങ്ങനെ സൃഷ്ടിക്കാം?
A: ഒരു ക്ലാസ്സിന്റെ ഒബ്‌ജക്‌റ്റ് സൃഷ്‌ടിക്കാൻ, ഞങ്ങൾ "പുതിയ" കീവേഡ് ഉപയോഗിക്കുന്നു, തുടർന്ന് ക്ലാസ്സിന്റെ പേര്. ഉദാഹരണത്തിന്: $person = പുതിയ വ്യക്തി();

ചോദ്യം: OOP-യിലെ അനന്തരാവകാശം എന്താണ്?
A: ഒരു ക്ലാസിനെ മറ്റൊരു ക്ലാസിൽ നിന്ന് ഗുണങ്ങളും രീതികളും അവകാശമാക്കാൻ അനുവദിക്കുന്ന OOP യുടെ അടിസ്ഥാന വശമാണ് അനന്തരാവകാശം.

ചോദ്യം: ഇന്റർഫേസുകൾ എന്താണെന്ന് വിശദീകരിക്കാമോ?
A: ഒരു ക്ലാസിനായുള്ള കരാർ നിർവചിക്കുന്നതിനുള്ള ഒരു മാർഗമാണ് ഇന്റർഫേസുകൾ, ക്ലാസ് നടപ്പിലാക്കേണ്ട ഒരു കൂട്ടം രീതികൾ വ്യക്തമാക്കുന്നു.

ചോദ്യം: PHP-യിൽ OOP-യുടെ മറ്റ് വിപുലമായ ആശയങ്ങൾ ഉണ്ടോ?
A: അതെ, അബ്‌സ്‌ട്രാക്‌റ്റ് ക്ലാസുകൾ, പോളിമോർഫിസം, എൻക്യാപ്‌സുലേഷൻ മുതലായവ പോലെ, പ്രോഗ്രാമിനെ കൂടുതൽ മോഡുലാർ, മാനേജ്‌മെന്റ്, പുനരുപയോഗം എന്നിവ ആക്കുന്നതിന് PHP-യിൽ പ്രയോഗിച്ചേക്കാവുന്ന നിരവധി സങ്കീർണ്ണമായ തത്വങ്ങളുണ്ട്.

വ്യായാമങ്ങൾ:

  1. PHP-യിൽ ഒരു ക്ലാസ് സൃഷ്ടിക്കുന്നതിനുള്ള വാക്യഘടന എന്താണ്?
  2. ഒരു PHP ക്ലാസ്സിൽ ഒരു കൺസ്ട്രക്റ്റർ രീതി നിങ്ങൾക്ക് എങ്ങനെ നിർവചിക്കാം?
  3. ഒരു PHP ക്ലാസിലെ സ്റ്റാറ്റിക് രീതിയും നോൺ-സ്റ്റാറ്റിക് രീതിയും തമ്മിലുള്ള വ്യത്യാസം എന്താണ്?
  4. PHP-യിലെ ഒരു ക്ലാസ്സിൽ നിന്ന് നിങ്ങൾക്ക് എങ്ങനെ ഒരു ഒബ്ജക്റ്റ് സൃഷ്ടിക്കാൻ കഴിയും?
  5. ഒരു PHP ക്ലാസിലെ "വിപുലീകരിക്കുന്നു" കീവേഡിന്റെ ഉദ്ദേശ്യം എന്താണ്?

ഉത്തരങ്ങൾ:

  1. PHP-യിൽ ഒരു ക്ലാസ് സൃഷ്ടിക്കുന്നതിനുള്ള വാക്യഘടന "ക്ലാസ് ക്ലാസ് നെയിം {}" ആണ്
  2. ഒരു PHP ക്ലാസിലെ കൺസ്ട്രക്റ്റർ രീതി __confirst () ഫംഗ്ഷൻ ഉപയോഗിച്ച് നിർവചിക്കാം.
  3. ക്ലാസിന്റെ ഒരു ഒബ്‌ജക്‌റ്റ് സൃഷ്‌ടിക്കാതെ തന്നെ ഒരു സ്റ്റാറ്റിക് രീതിയെ വിളിക്കാം, അതേസമയം നോൺ-സ്റ്റാറ്റിക് രീതിക്ക് ഒരു ഒബ്‌ജക്റ്റ് സൃഷ്‌ടിക്കേണ്ടതുണ്ട്, തുടർന്ന് അതിനെ വിളിക്കാം.
  4. PHP-യിലെ ഒരു ക്ലാസ്സിൽ നിന്ന് "പുതിയ" കീവേഡ് ഉപയോഗിച്ച് ഒരു ഒബ്‌ജക്റ്റ് സൃഷ്‌ടിക്കാൻ കഴിയും, തുടർന്ന് ക്ലാസ്സിന്റെ പേര്, ഒരു വേരിയബിളിലേക്ക് അസൈൻ ചെയ്യുക. ഉദാ $object = പുതിയ ClassName;
  5. ഒരു PHP ക്ലാസിലെ "വിപുലീകരിക്കുന്നു" കീവേഡ് ഒരു പാരന്റ് ക്ലാസിൽ നിന്ന് പാരമ്പര്യമായി ലഭിച്ചതാണെന്ന് സൂചിപ്പിക്കാൻ ഉപയോഗിക്കുന്നു. മറ്റൊരു ക്ലാസിൽ നിന്ന് ഗുണങ്ങളും രീതികളും അവകാശമാക്കാൻ ഇത് ഒരു ക്ലാസിനെ അനുവദിക്കുന്നു.
PHP-യിൽ Regex
PHP-യിലെ കൺസ്ട്രക്‌റ്ററുകളും ഡിസ്ട്രക്‌റ്ററുകളും
en English
X
ടോപ്പ് സ്ക്രോൾ