PHP OOP-യിലെ അനന്തരാവകാശം

വെറും $3.44 മുതൽ വിശ്വസനീയമായ SSL
പരസ്യങ്ങൾ
PHP-യിൽ മോഡിഫയറുകൾ ആക്സസ് ചെയ്യുക
PHP OOP-യിലെ സ്ഥിരാങ്കങ്ങൾ

എന്താണ് അനന്തരാവകാശം?

ഒരു വർഗ്ഗം മറ്റൊരു വർഗ്ഗത്തിൽ നിന്ന് ഉരുത്തിരിഞ്ഞു വരുമ്പോൾ അത് പാരമ്പര്യം എന്നറിയപ്പെടുന്നു. PHP-യിലെ അനന്തരാവകാശവുമായി ബന്ധപ്പെട്ട ചില പ്രധാന നിബന്ധനകൾ ഇതാ.

  • രക്ഷാകർതൃ ക്ലാസ് - മറ്റ് ക്ലാസുകൾ ഉരുത്തിരിഞ്ഞ ക്ലാസിനെ പേരന്റ് ക്ലാസ് എന്ന് വിളിക്കുന്നു. ഇത് അടിസ്ഥാന ക്ലാസ് എന്നും അറിയപ്പെടുന്നു.
  • കുട്ടികളുടെ ക്ലാസ് - മറ്റൊരു ക്ലാസിൽ നിന്ന് ഉരുത്തിരിഞ്ഞ ക്ലാസിനെ ചൈൽഡ് ക്ലാസ് എന്ന് വിളിക്കുന്നു. ലീഫ് ക്ലാസ് അല്ലെങ്കിൽ ഡെറൈവ്ഡ് ക്ലാസ് പോലെ ഇതിന് മറ്റ് ചില പേരുകളുണ്ട്.
PHP-യിലെ അനന്തരാവകാശം

പിഎച്ച്പിയിൽ ഒരു ക്ലാസ് എങ്ങനെ അവകാശമാക്കാം?

ഉപയോഗിക്കുന്നതിലൂടെ ഒരു ക്ലാസ് പാരമ്പര്യമായി ലഭിക്കും വിപുലീകരിക്കുന്നു കീവേഡ്. ഇനിപ്പറയുന്ന ഉദാഹരണം നോക്കുക.

<?php
class Fruit {
    protected $name;
    protected $color;

    public function __construct($name, $color) {
        $this->name = $name;
        $this->color = $color;
    }

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

    public function getColor() {
        return $this->color;
    }
}

class Apple extends Fruit {
    protected $variety;

    public function __construct($name, $color, $variety) {
        parent::__construct($name, $color);
        $this->variety = $variety;
    }

    public function getVariety() {
        return $this->variety;
    }
}

$apple = new Apple('Apple', 'Red', 'Fuji');
echo $apple->getName(); // Output: Apple
echo $apple->getColor(); // Output: Red
echo $apple->getVariety(); // Output: Fuji
?>

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

മുകളിൽ പറഞ്ഞവ സംഗ്രഹിക്കാൻ:

  1. പാരന്റ് ക്ലാസിന്റെ പൊതു __കൺസ്ട്രക്റ്റ്, രീതികൾ, പ്രോപ്പർട്ടികൾ എന്നിവ ആക്‌സസ് ചെയ്യാൻ ചൈൽഡ് ക്ലാസിനെ ഇൻഹെറിറ്റൻസ് അനുവദിക്കുന്നു.
  2. മുകളിലുള്ള ഉദാഹരണത്തിൽ, അതിന്റെ ഒബ്ജക്റ്റ് ഉപയോഗിച്ച് ആപ്പിൾ ക്ലാസിന്റെ രീതിയും അതുപോലെ പാരന്റ് ക്ലാസിന്റെ രീതികളും നമുക്ക് ആക്സസ് ചെയ്യാൻ കഴിയും.

ഇൻഹെറിറ്റൻസിലെ പരിരക്ഷിത ആക്‌സസ് മോഡിഫയറുകളുടെ വ്യാപ്തി

മുമ്പത്തെ ട്യൂട്ടോറിയലിൽ, ഒരു ക്ലാസിന്റെ സംരക്ഷിത ആട്രിബ്യൂട്ടുകൾ/രീതികൾ ക്ലാസിനുള്ളിലും അതിൽ നിന്ന് ഉരുത്തിരിഞ്ഞ ക്ലാസുകളിലും ആക്‌സസ് ചെയ്യാൻ കഴിയുമെന്ന് ഞങ്ങൾ മനസ്സിലാക്കി.

അനന്തരാവകാശത്തിൽ പരിരക്ഷിത ആക്‌സസ് മോഡിഫയറുകളുടെ വ്യാപ്തി മനസ്സിലാക്കാൻ, നമുക്ക് ഇനിപ്പറയുന്ന ഉദാഹരണം നോക്കാം.

<?php
class Fruit {
  public $name;
  public $color;
  public function __construct($name, $color) {
    $this->name = $name;
    $this->color = $color;
  }
  protected function intro() {
    echo "I am $this->name and my color is $this->color";
  }
}

class Apple extends Fruit {
  public function message() {
    echo "I am from Fruit class or Apple one?";
  }
}

$apple = new Apple("Apple", "red");
$apple->message();
$apple->intro();
?>

മുകളിലുള്ള ഉദാഹരണത്തിൽ:

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

നമുക്ക് മറ്റൊരു ഉദാഹരണം നോക്കാം, അത് അവസാനത്തേതിന്റെ അല്പം പരിഷ്കരിച്ച പതിപ്പാണ്.

<?php
class Fruit {
  public $name;
  public $color;
  public function __construct($name, $color) {
    $this->name = $name;
    $this->color = $color;
  }
  protected function intro() {
    echo "I am {$this->name} and my color is {$this->color}.";
  }
}

class Apple extends Fruit {
  public function message() {
    echo "Am I a fruit or an apple? ";
    $this -> intro(); // protected
  }
}

$apple = new Apple("Apple", "red");
$strawberry->message();
?>

മുമ്പത്തെ ഉദാഹരണത്തിലെ ക്ലാസിനുള്ളിൽ ഞങ്ങൾ ഇത് ആക്‌സസ് ചെയ്യുന്നതിനാൽ, ഫ്രൂട്ട് ക്ലാസിന്റെ സംരക്ഷിത രീതി ആപ്പിൾ ക്ലാസിൽ ലഭ്യമാണ്.

അനന്തരാവകാശത്തിൽ അസാധുവാക്കുന്നു

ഓവർറൈഡിംഗ് എന്നാൽ അതേ പേരിൽ ചൈൽഡ് ക്ലാസുകളിലെ പാരന്റ് ക്ലാസിന്റെ രീതികൾ പുനർ നിർവചിക്കുക എന്നാണ് അർത്ഥമാക്കുന്നത്. ഇനിപ്പറയുന്ന അനന്തരാവകാശത്തെ മറികടക്കുന്ന ഉദാഹരണം പരിഗണിക്കുക.

<?php
class Fruit {
  public $name;
  public $color;
  public function __construct($name, $color) {
    $this->name = $name;
    $this->color = $color;
  }
  public function intro() {
    echo "I am {$this->name} and my color is {$this->color}.";
  }
}

class Apple extends Fruit {
  public $weight;
  public function __construct($name, $color, $weight) {
    $this->name = $name;
    $this->color = $color;
    $this->weight = $weight;
  }
  public function intro() {
    echo "I am {$this->name}, my color is {$this->color}. Also, my weight is {$this->weight} kg.";
  }
}

$apple= new Apple("Apple", "red", 50);
$apple->intro();
?>

മുകളിലുള്ള ഉദാഹരണത്തിൽ:

വെറും $3.44 മുതൽ വിശ്വസനീയമായ SSL
പരസ്യങ്ങൾ
  • ഓവർറൈഡിംഗ് എന്നാൽ ചൈൽഡ് ക്ലാസുകളിലെ പാരന്റ് ക്ലാസ്സിന്റെ രീതികൾ പുനർനാമകരണം ചെയ്യുക എന്നാണ് അർത്ഥമാക്കുന്നത്. അനന്തരാവകാശത്തിൽ അസാധുവാക്കുന്നതിന്റെ ഇനിപ്പറയുന്ന ഉദാഹരണം പരിഗണിക്കുക.
  • ചൈൽഡ് ക്ലാസ് ആപ്പിളിലെ __കൺസ്ട്രക്റ്റ്, ഇൻട്രോ രീതികൾക്ക് ഒരേ പേരുണ്ട് എന്നത് ശ്രദ്ധിക്കേണ്ടതാണ്. എന്നിരുന്നാലും, പാരാമീറ്ററുകൾ വ്യത്യാസപ്പെടാം.
  • ഞങ്ങൾ ആപ്പിൾ ക്ലാസിന്റെ ഒരു ഉദാഹരണം സൃഷ്ടിക്കുകയും ബിൽഡ് രീതിയിലേക്ക് ആർഗ്യുമെന്റുകൾ അയയ്ക്കുകയും ചെയ്യുന്നു.
  • ആപ്പിൾ ക്ലാസ് കൺസ്ട്രക്‌റ്റർ ഉപയോഗിച്ചാണ് ഞങ്ങൾ ആപ്പിൾ ഒബ്‌ജക്‌റ്റ് ഇൻസ്‌റ്റൻസ് സൃഷ്‌ടിച്ചത്, ആപ്പിൾ ഇൻസ്‌റ്റൻസ് ഉപയോഗിച്ച് ഇൻട്രോ മെത്തേഡ് വിളിക്കുമ്പോൾ, അത് ആപ്പിൾ ക്ലാസിന്റെ ഇൻട്രോ ഫംഗ്‌ഷനെ വിളിക്കുന്നു.

അനന്തരാവകാശത്തിൽ അന്തിമ കീവേഡിന്റെ പങ്ക്

രക്ഷാകർതൃ/അടിസ്ഥാന ക്ലാസിന്റെ പ്രവർത്തനത്തെ അസാധുവാക്കുന്നതിൽ നിന്ന് അവസാന കീവേഡ് കുട്ടിയെ/ഉത്ഭവിച്ച ക്ലാസിനെ വിലക്കുന്നു. ഫൈനൽ കീവേഡ് എങ്ങനെയാണ് ഉപയോഗിക്കുന്നതെന്ന് കാണാൻ ഇനിപ്പറയുന്ന ഉദാഹരണം നോക്കുക.

<?php
class Fruit {
  final public function intro() {
    // code
  }
}

class Apple extends Fruit {
// error to override the intro
  public function intro() {
    // code
  }
}
?>

മുമ്പത്തെ ഉദാഹരണത്തിലെ ആമുഖ രീതിയെ മറികടക്കാൻ ആപ്പിൾ ക്ലാസ് ശ്രമിക്കുന്നു. ഫ്രൂട്ട് ക്ലാസിന്റെ ആമുഖ ഫംഗ്‌ഷനോടൊപ്പം ഞങ്ങൾ അവസാന കീവേഡ് ഉപയോഗിച്ചതിനാൽ ഇത് ഒരു പിശക് സൃഷ്ടിക്കും.

നിങ്ങൾക്ക് PHP പാരമ്പര്യത്തെക്കുറിച്ച് കൂടുതൽ വായിക്കണമെങ്കിൽ, ഞങ്ങൾ ഇനിപ്പറയുന്നവ ശുപാർശ ചെയ്യുന്നു ഔദ്യോഗിക ഗൈഡ്.

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

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

ചോദ്യം: PHP-യിൽ, മറ്റൊരു ക്ലാസിൽ നിന്ന് പാരമ്പര്യമായി ലഭിക്കുന്ന ഒരു ക്ലാസ്സിനെ നിങ്ങൾ എങ്ങനെ നിർവചിക്കും?
A: PHP-യിൽ, മറ്റൊരു ക്ലാസിൽ നിന്ന് പാരമ്പര്യമായി ലഭിക്കുന്ന ഒരു ക്ലാസ്സിനെ നിർവചിക്കാൻ "വിപുലീകരിക്കുന്നു" കീവേഡ് ഉപയോഗിക്കുന്നു. ഉദാഹരണത്തിന്, നിങ്ങൾക്ക് ഒരു "ParentClass" പാരന്റ് ക്ലാസ് ഉണ്ടെങ്കിൽ അതിൽ നിന്ന് പാരമ്പര്യമായി ലഭിക്കുന്ന "ChildClass" ചൈൽഡ് ക്ലാസ് നിർമ്മിക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നുവെങ്കിൽ, നിങ്ങൾക്ക് എഴുതാം:

class ChildClass extends ParentClass {
  // properties and methods
}

ചോദ്യം: PHP-യിൽ, ഒരു ക്ലാസിന് നിരവധി ക്ലാസുകളിൽ നിന്ന് പാരമ്പര്യമായി ലഭിക്കുമോ?
A: ഇല്ല, PHP-യിൽ, ഒരു ക്ലാസിന് മറ്റൊരു ക്ലാസിൽ നിന്ന് മാത്രമേ അവകാശം ലഭിക്കൂ. എന്നിരുന്നാലും, തത്തുല്യമായ പ്രവർത്തനക്ഷമത നൽകാൻ ഇന്റർഫേസുകൾ ഉപയോഗിക്കാം, കൂടാതെ ഒരു ക്ലാസിന് നിരവധി ഇന്റർഫേസുകൾ നടപ്പിലാക്കാൻ കഴിയും.

ചോദ്യം: ഒരു ചൈൽഡ് ക്ലാസ്സിൽ ഒരു രീതി അസാധുവാക്കാൻ കഴിയുമോ?
ഉത്തരം: അതെ, അതേ പേരിൽ ഒരു രീതി സൃഷ്ടിച്ചുകൊണ്ട് നിങ്ങൾക്ക് ഒരു ചൈൽഡ് ക്ലാസിലെ ഒരു രീതി അസാധുവാക്കാം. ഒരു ചൈൽഡ് ക്ലാസ് ഒബ്‌ജക്റ്റിൽ അഭ്യർത്ഥിക്കുമ്പോൾ, പാരന്റ് ക്ലാസ് രീതിക്ക് പകരം ചൈൽഡ് ക്ലാസ് രീതി ഉപയോഗിക്കും.

ചോദ്യം: ഒരു ചൈൽഡ് ക്ലാസ്സിൽ നിന്ന് ഒരു പാരന്റ് ക്ലാസ് രീതി അഭ്യർത്ഥിക്കാൻ കഴിയുമോ?
A: അതെ, നിങ്ങൾക്ക് "രക്ഷാകർതൃ" കീവേഡും തുടർന്ന് സ്കോപ്പ് റെസല്യൂഷൻ ഓപ്പറേറ്ററും (::) ഒരു ചൈൽഡ് ക്ലാസ്സിൽ നിന്ന് ഒരു പേരന്റ് ക്ലാസ് രീതിയെ വിളിക്കാൻ രീതിയുടെ പേരും ഉപയോഗിക്കാം. ഒരു ഉദാഹരണം എന്ന നിലക്ക്:

class ChildClass extends ParentClass {
  public function childMethod() {
    parent::parentMethod();
  }
}

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

  1. ഒരു ക്ലാസ് മറ്റൊരു ക്ലാസിൽ നിന്ന് പാരമ്പര്യമായി ലഭിക്കുന്നുണ്ടെന്ന് സൂചിപ്പിക്കാൻ PHP-യിൽ ഉപയോഗിക്കുന്ന കീവേഡ് എന്താണ്?
  2. ഒരു ചൈൽഡ് ക്ലാസിലെ പാരന്റ് ക്ലാസിൽ നിന്ന് നിങ്ങൾക്ക് എങ്ങനെ ഒരു രീതിയോ വസ്തുവോ ആക്സസ് ചെയ്യാൻ കഴിയും?
  3. ഒരു ചൈൽഡ് ക്ലാസ്സിന്റെ കൺസ്‌ട്രക്‌റ്ററിനുള്ളിലെ പാരന്റ് ക്ലാസിന്റെ കൺസ്‌ട്രക്‌റ്ററെ നിങ്ങൾക്ക് എങ്ങനെ വിളിക്കാനാകും?
  4. ഒരു ചൈൽഡ് ക്ലാസ്സിൽ ഒരു രീതിയോ വസ്തുവോ അസാധുവാക്കുന്നത് എങ്ങനെ തടയാം?
  5. തമ്മിലുള്ള വ്യത്യാസം എന്താണ് extends ഒപ്പം implements PHP-യിലെ കീവേഡുകൾ?

ഉത്തരങ്ങൾ:

  1. ദി extends ഒരു ക്ലാസ് മറ്റൊരു ക്ലാസിൽ നിന്ന് പാരമ്പര്യമായി ലഭിക്കുന്നുണ്ടെന്ന് സൂചിപ്പിക്കാൻ PHP-യിൽ കീവേഡ് ഉപയോഗിക്കുന്നു.
  2. ഒരു ചൈൽഡ് ക്ലാസിലെ പാരന്റ് ക്ലാസിൽ നിന്ന് നിങ്ങൾക്ക് ഒരു രീതിയോ പ്രോപ്പർട്ടിയോ ആക്സസ് ചെയ്യാൻ കഴിയും parent:: കീവേഡ്, തുടർന്ന് രീതി അല്ലെങ്കിൽ വസ്തുവിന്റെ പേര്.
  3. ഒരു ചൈൽഡ് ക്ലാസ്സിന്റെ കൺസ്‌ട്രക്‌ടറിനുള്ളിലെ പാരന്റ് ക്ലാസ്സിന്റെ കൺസ്‌ട്രക്‌റ്ററെ നിങ്ങൾക്ക് ഇത് ഉപയോഗിച്ച് വിളിക്കാം parent::__construct() രീതി.
  4. ഒരു ചൈൽഡ് ക്ലാസിൽ ഒരു രീതിയോ വസ്തുവോ അസാധുവാക്കുന്നത് തടയാൻ നിങ്ങൾക്ക് കഴിയും final പാരന്റ് ക്ലാസിലെ രീതി അല്ലെങ്കിൽ പ്രോപ്പർട്ടി ഡിക്ലറേഷന് മുമ്പുള്ള കീവേഡ്.
  5. ദി extends ഒരു ക്ലാസ് മറ്റൊരു ക്ലാസിൽ നിന്ന് പാരമ്പര്യമായി ലഭിക്കുന്നു എന്ന് സൂചിപ്പിക്കാൻ കീവേഡ് ഉപയോഗിക്കുന്നു implements ഒരു ക്ലാസ് ഒരു ഇന്റർഫേസ് നടപ്പിലാക്കുന്നു എന്ന് സൂചിപ്പിക്കാൻ കീവേഡ് ഉപയോഗിക്കുന്നു.
PHP-യിൽ മോഡിഫയറുകൾ ആക്സസ് ചെയ്യുക
PHP OOP-യിലെ സ്ഥിരാങ്കങ്ങൾ
അടയ്ക്കുക

PHP-യെ കുറിച്ച് കാലികമായിരിക്കുക!

ഞങ്ങൾ സ്പാം ചെയ്യുന്നില്ല!

വെറും $3.44 മുതൽ വിശ്വസനീയമായ SSL
പരസ്യങ്ങൾ

en English
X
ടോപ്പ് സ്ക്രോൾ