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

PHP-യിലെ OOP: ഒരു തുടക്കക്കാരന്റെ ഗൈഡ്
PHP-യിൽ മോഡിഫയറുകൾ ആക്സസ് ചെയ്യുക

മറ്റ് ഒബ്ജക്റ്റ് ഓറിയന്റഡ് പ്രോഗ്രാമിംഗ് ഭാഷകളെപ്പോലെ PHP, ക്ലാസ് കൺസ്ട്രക്‌റ്ററുകളേയും ഡിസ്ട്രക്റ്ററുകളേയും പിന്തുണയ്ക്കുന്നു.

ഒരു കൺസ്ട്രക്റ്റർ എന്നത് എ നിർദ്ദിഷ്ട പ്രവർത്തനം ഒരു ക്ലാസ് ഒബ്‌ജക്റ്റ് രൂപപ്പെടുമ്പോൾ അത് സ്വയമേവ അഭ്യർത്ഥിക്കുന്നു. ഒബ്‌ജക്‌റ്റിന്റെ പ്രോപ്പർട്ടികൾ സമാരംഭിക്കുകയും ഒബ്‌ജക്റ്റ് രൂപപ്പെടുമ്പോൾ ആർഗ്യുമെന്റുകളായി നൽകുന്ന ഡിഫോൾട്ട് മൂല്യങ്ങളോ മൂല്യങ്ങളോ ആയി സജ്ജീകരിക്കുകയും ചെയ്യുക എന്നതാണ് ഒരു കൺസ്‌ട്രക്‌ടറുടെ പ്രധാന പ്രവർത്തനം. ഡബിൾ അണ്ടർസ്‌കോർ (__) വാക്യഘടനയും "കൺസ്ട്രക്‌റ്റ്" എന്ന പദപ്രയോഗവും ഉപയോഗിച്ച് PHP-യിൽ കൺസ്ട്രക്‌റ്ററുകൾ പ്രഖ്യാപിക്കപ്പെടുന്നു. “__കൺസ്ട്രക്റ്റ്” എന്നത് കൺസ്ട്രക്റ്റർ രീതിയുടെ പേരായിരിക്കണം. “പെറ്റ്” ക്ലാസിലെ ഒരു കൺസ്ട്രക്‌ടറിന്റെ ഒരു ഉദാഹരണം ഇതാ:

class Pet {
  public $nick_name;
  public $color;

  function __construct($name, $color) {
    $this->nick_name = $name;
    $this->color = $color;
  }
  function get_name() {
    return $this->nick_name;
  }
  function get_color() {
    return $this->color;
  }
}

$cat = new Pet("Whiskers", "Black");
echo $cat->get_name();
echo "<br>";
echo $cat->get_color();

ഞങ്ങൾ ഒരു പുതിയ “പെറ്റ്” ഒബ്‌ജക്റ്റ് സൃഷ്‌ടിച്ച് “വിസ്‌കേഴ്‌സ്”, “ബ്ലാക്ക്” എന്നിവ പാരാമീറ്ററുകളായി ഇടുമ്പോൾ, കൺസ്‌ട്രക്‌റ്റർ ഒബ്‌ജക്റ്റിന്റെ “നിക്ക് നെയിം”, “കളർ” പ്രോപ്പർട്ടികൾ യഥാക്രമം “വിസ്‌ക്കർസ്”, “ബ്ലാക്ക്” എന്നിങ്ങനെ സജ്ജീകരിക്കുന്നു. ഈ ആട്രിബ്യൂട്ടുകളുടെ മൂല്യങ്ങൾ പിന്നീട് "പേര് നേടുക", "നിറം നേടുക" രീതികൾ ഉപയോഗിച്ച് വീണ്ടെടുക്കാം.

മറുവശത്ത്, ഒരു വസ്തു നശിപ്പിക്കപ്പെടുമ്പോഴോ മെമ്മറിയിൽ നിന്ന് നീക്കം ചെയ്യുമ്പോഴോ പ്രയോഗിക്കുന്ന ഒരു പ്രത്യേക നടപടിക്രമമാണ് ഡിസ്ട്രക്റ്റർ. ഡാറ്റാബേസ് കണക്ഷനുകൾ അവസാനിപ്പിക്കുകയോ മെമ്മറി ക്ലിയർ ചെയ്യുകയോ പോലുള്ള ഒബ്ജക്റ്റ് ഉപയോഗിച്ചിരുന്ന വിഭവങ്ങൾ സ്വതന്ത്രമാക്കുക എന്നതാണ് ഇതിന്റെ പ്രാഥമിക പ്രവർത്തനം. ഡബിൾ അണ്ടർസ്‌കോർ (__) വാക്യഘടനയും "നശിപ്പിക്കുക" എന്ന പദവും ഉപയോഗിച്ച് ഡിസ്ട്രക്‌റ്ററുകൾ PHP-യിൽ പ്രഖ്യാപിച്ചു. “__destruct” എന്നത് ഡിസ്ട്രക്റ്റർ രീതിയുടെ പേരായിരിക്കണം. പ്രവർത്തനത്തിലുള്ള ഒരു ക്ലാസ് ഡിസ്ട്രക്റ്ററിന്റെ ഒരു ഉദാഹരണം ഇതാ:

class Pet {
  public $nick_name;
  public $color;

  function __construct($name, $color) {
    $this->nick_name = $name;
    $this->color = $color;
  }
  function get_name() {
    return $this->nick_name;
  }
  function get_color() {
    return $this->color;
  }
  function __destruct() {
    echo "Goodbye, " . $this->nick_name . "!<br>";
  }
}

$cat = new Pet("Whiskers", "Black");
echo $cat->get_name();
echo "<br>";
echo $cat->get_color();

ഈ ഉദാഹരണത്തിൽ, സ്‌ക്രിപ്റ്റ് അവസാനിക്കുമ്പോഴോ "പെറ്റ്" ഒബ്‌ജക്റ്റ് നശിപ്പിക്കപ്പെടുമ്പോഴോ, ഡിസ്ട്രക്റ്റർ ഉടൻ തന്നെ അഭ്യർത്ഥിക്കുകയും "ഗുഡ്‌ബൈ, വിസ്‌കേഴ്‌സ്!" പ്രദർശിപ്പിക്കുകയും ചെയ്യുന്നു. സ്ക്രീനിൽ.

PHP-യിൽ, കൺസ്ട്രക്‌റ്ററുകളും ഡിസ്ട്രക്റ്ററുകളും സ്വമേധയാ നിർവഹിക്കപ്പെടുന്നില്ലെന്ന് മനസ്സിലാക്കേണ്ടത് പ്രധാനമാണ്; ഒരു വസ്തു സൃഷ്ടിക്കപ്പെടുമ്പോഴോ നശിപ്പിക്കപ്പെടുമ്പോഴോ അവ സ്വയമേവ വിളിക്കപ്പെടുന്നു. കൺസ്ട്രക്റ്റർ ആർഗ്യുമെന്റുകൾക്കായി നിങ്ങൾക്ക് ഡിഫോൾട്ട് മൂല്യങ്ങളും വ്യക്തമാക്കാം. ഉദാഹരണത്തിന്, കൺസ്‌ട്രക്‌ടറിന്റെ രണ്ടാമത്തെ പാരാമീറ്റർ ഓപ്‌ഷണൽ ആയിരിക്കണമെങ്കിൽ, നിങ്ങൾക്ക് ഇതുപോലുള്ള ഒരു സ്ഥിരസ്ഥിതി മൂല്യം നിർവചിക്കാം:

function __construct($name,$color = "Black") {
$this->nick_name = $name;
$this->color = $color;
}

ഈ ഉദാഹരണത്തിൽ, ഇല്ലെങ്കിൽ മൂല്യം ഒബ്‌ജക്റ്റ് സൃഷ്‌ടിക്കുമ്പോൾ രണ്ടാമത്തെ പാരാമീറ്റർ നൽകിയിരിക്കുന്നു, “കളർ” പ്രോപ്പർട്ടി സ്വയമേവ “കറുപ്പ്” ആയി സജ്ജീകരിക്കും.

ഒരു ചൈൽഡ് ക്ലാസ് ഒരു പാരന്റ് ക്ലാസ് വിപുലീകരിക്കുകയും ആഗ്രഹിക്കുന്നുവെങ്കിൽ എന്നതും ശ്രദ്ധിക്കേണ്ടതാണ് വിളി പാരന്റ് ക്ലാസ് കൺസ്ട്രക്റ്റർ അതിന്റെ സ്വന്തം കൺസ്‌ട്രക്‌ടറിൽ, അതിന് “പാരന്റ്:: __കൺസ്ട്രക്റ്റ് ()” എന്ന വാക്യഘടന ഉപയോഗിക്കാം. ചൈൽഡ് ക്ലാസിന് സ്വന്തമായി കൺസ്‌ട്രക്‌റ്റർ ഇല്ലെങ്കിൽ, അത് പ്രൈവറ്റ് ആയി പ്രഖ്യാപിക്കുന്നില്ലെങ്കിൽ, പാരന്റ് ക്ലാസിന്റെ കൺസ്‌ട്രക്‌റ്റർ ഒരു സാധാരണ പ്രവർത്തനമായി പാരമ്പര്യമായി ലഭിക്കും.

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

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

ചോദ്യം: PHP-യിലെ ഒരു കൺസ്ട്രക്റ്റർ എന്താണ്?

A: ഒരു ക്ലാസ് ഒബ്‌ജക്റ്റ് രൂപപ്പെടുമ്പോൾ സ്വയമേവ അഭ്യർത്ഥിക്കുന്ന ഒരു നിർദ്ദിഷ്ട ഫംഗ്ഷനാണ് കൺസ്ട്രക്റ്റർ. ഒബ്‌ജക്‌റ്റിന്റെ പ്രോപ്പർട്ടികൾ സമാരംഭിക്കുക, ഒബ്‌ജക്റ്റ് സൃഷ്‌ടിക്കുമ്പോൾ അവയെ ഡിഫോൾട്ട് മൂല്യങ്ങൾ അല്ലെങ്കിൽ ആർഗ്യുമെന്റുകളായി വിതരണം ചെയ്യുന്ന മൂല്യങ്ങൾ സജ്ജമാക്കുക എന്നതാണ് ഇതിന്റെ പ്രാഥമിക പ്രവർത്തനം. "കൺസ്ട്രക്‌റ്റ്" എന്ന വാക്കിനൊപ്പം ഇരട്ട അണ്ടർസ്‌കോർ (__) വാക്യഘടന ഉപയോഗിച്ചാണ് കൺസ്ട്രക്‌റ്ററുകൾ വ്യക്തമാക്കുന്നത്, കൺസ്‌ട്രക്‌ടർ രീതിയുടെ പേര് “__കൺസ്ട്രക്‌ട്” എന്നായിരിക്കണം.

ചോദ്യം: പിഎച്ച്പിയിൽ ഒരു കൺസ്ട്രക്റ്റർ എങ്ങനെയാണ് പ്രഖ്യാപിക്കുന്നത്?
A: കൺസ്ട്രക്‌റ്ററുകൾ പി‌എച്ച്‌പിയിൽ ഡബിൾ അണ്ടർസ്‌കോർ (__) വാക്യഘടനയും “കൺസ്ട്രക്‌റ്റ്” എന്ന വാക്യവും ഉപയോഗിച്ച് പ്രഖ്യാപിക്കുന്നു. “__കൺസ്ട്രക്റ്റ്” എന്നത് കൺസ്ട്രക്റ്റർ രീതിയുടെ പേരായിരിക്കണം.

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

ചോദ്യം: പിഎച്ച്പിയിൽ ഒരു ഡിസ്ട്രക്റ്റർ എങ്ങനെയാണ് പ്രഖ്യാപിക്കുന്നത്?
A: PHP-യിൽ, "ഡിസ്ട്രക്റ്റ്" എന്ന വാക്കിനൊപ്പം ഡബിൾ അണ്ടർസ്‌കോർ (__) വാക്യഘടന ഉപയോഗിച്ചാണ് ഡിസ്ട്രക്റ്ററുകൾ പ്രഖ്യാപിക്കുന്നത്. ഡിസ്ട്രക്റ്റർ രീതിയുടെ പേര് "__destruct" ആയിരിക്കണം.

ചോദ്യം: PHP-യിൽ നമുക്ക് കൺസ്ട്രക്‌റ്ററുകളേയും ഡിസ്ട്രക്റ്ററുകളേയും സ്വമേധയാ വിളിക്കേണ്ടതുണ്ടോ?
A: ഇല്ല, ഒരു ഒബ്‌ജക്‌റ്റ് സൃഷ്‌ടിക്കുമ്പോഴോ നശിപ്പിക്കപ്പെടുമ്പോഴോ കൺസ്‌ട്രക്‌റ്ററുകളും ഡിസ്ട്രക്‌റ്ററുകളും സ്വയമേവ വിളിക്കപ്പെടും, ഞങ്ങൾ അവയെ നേരിട്ട് വിളിക്കേണ്ടതില്ല.

ചോദ്യം: പി‌എച്ച്‌പിയിലെ കൺ‌സ്‌ട്രക്റ്റർ പാരാമീറ്ററുകൾക്കായി നമുക്ക് സ്ഥിര മൂല്യങ്ങൾ സജ്ജമാക്കാമോ?
A: അതെ, കൺസ്ട്രക്റ്റർ ആർഗ്യുമെന്റുകൾക്കായി സ്ഥിരസ്ഥിതി മൂല്യങ്ങൾ സ്ഥാപിക്കാൻ നമുക്ക് PHP ഉപയോഗിക്കാം. ഉദാഹരണത്തിന്, കൺസ്‌ട്രക്‌ടറിന്റെ രണ്ടാമത്തെ പാരാമീറ്റർ ഓപ്‌ഷണൽ ആയിരിക്കണമെങ്കിൽ, നിങ്ങൾക്ക് ഇതുപോലുള്ള ഒരു സ്ഥിരസ്ഥിതി മൂല്യം നിർവചിക്കാം:

function __construct($name, $color = "Black") {
    $this->nick_name = $name;
    $this->color = $color;
  }

ചോദ്യം: ഒരു ചൈൽഡ് ക്ലാസ്സിന് PHP-യിലെ പാരന്റ് ക്ലാസ് കൺസ്ട്രക്റ്ററെ എങ്ങനെ വിളിക്കാം?
A: ഒരു ചൈൽഡ് ക്ലാസ് ഒരു പാരന്റ് ക്ലാസ് വിപുലീകരിക്കുകയും പാരന്റ് ക്ലാസ് കൺസ്‌ട്രക്‌ടറെ സ്വന്തം കൺസ്‌ട്രക്‌ടറിൽ വിളിക്കാൻ ആഗ്രഹിക്കുകയും ചെയ്യുന്നുവെങ്കിൽ, അതിന് “പാരന്റ്::__കൺസ്ട്രക്‌ട് ()” എന്ന വാക്യഘടന ഉപയോഗിക്കാം.

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

  1. "നിർമ്മാണം", "മോഡൽ", "വർഷം" എന്നിവയ്‌ക്കുള്ള പ്രോപ്പർട്ടികൾ ഉപയോഗിച്ച് "കാർ" എന്നൊരു ക്ലാസും ഒരു പുതിയ ഒബ്‌ജക്റ്റ് സൃഷ്‌ടിക്കുമ്പോൾ ഈ മൂല്യങ്ങൾ സജ്ജമാക്കുന്ന ഒരു കൺസ്‌ട്രക്‌ടറും സൃഷ്‌ടിക്കുക.
  2. കാറിന്റെ നിർമ്മാണം, മോഡൽ, വർഷം എന്നിവ ഒരു സ്ട്രിംഗ് ആയി നൽകുന്ന "GetDetails" എന്ന ഒരു രീതി "കാർ" ക്ലാസിലേക്ക് ചേർക്കുക.
  3. "Car" ക്ലാസ് വിപുലീകരിക്കുന്ന "ElectricCar" എന്ന പേരിൽ ഒരു ചൈൽഡ് ക്ലാസ് സൃഷ്ടിക്കുക, കൂടാതെ "batteryLife" എന്നതിനായി ഒരു അധിക പ്രോപ്പർട്ടിയും ഈ മൂല്യം സജ്ജമാക്കുന്ന ഒരു കൺസ്ട്രക്റ്ററും സൃഷ്ടിക്കുക.
  4. "ElectricCar" ക്ലാസിലേക്ക് "getBatteryLife" എന്ന് വിളിക്കുന്ന ഒരു രീതി ചേർക്കുക, അത് "batteryLife" പ്രോപ്പർട്ടിയുടെ മൂല്യം നൽകുന്നു.
  5. "ElectricCar" ക്ലാസിന്റെ ഒരു ഒബ്‌ജക്റ്റ് സൃഷ്‌ടിച്ച് കാറിന്റെ വിശദാംശങ്ങളും ബാറ്ററി ലൈഫും പ്രദർശിപ്പിക്കുന്നതിന് നിങ്ങൾ സൃഷ്‌ടിച്ച രീതികൾ ഉപയോഗിക്കുക.

ഉത്തരങ്ങൾ:

1.

class Car {
  public $make;
  public $model;
  public $year;

  function __construct($make, $model, $year) {
    $this->make = $make;
    $this->model = $model;
    $this->year = $year;
  }
}

2.

class Car {
  public $make;
  public $model;
  public $year;

  function __construct($make, $model, $year) {
    $this->make = $make;
    $this->model = $model;
    $this->year = $year;
  }
  function getDetails() {
    return $this->make . " " . $this->model . " " . $this->year;
  }
}

3.

class ElectricCar extends Car {
  public $batteryLife;

  function __construct($make, $model, $year, $batteryLife) {
    parent::__construct($make, $model, $year);
    $this->batteryLife = $batteryLife;
  }
}

4.

class ElectricCar extends Car {
  public $batteryLife;

  function __construct($make, $model, $year, $batteryLife) {
    parent::__construct($make, $model, $year);
    $this->batteryLife = $batteryLife;
  }
  function getBatteryLife() {
    return $this->batteryLife;
  }
}

5.

$electricCar = new ElectricCar("Tesla", "Model S", 2022, 300);
echo $electricCar->getDetails();
echo "<br>";
echo "Battery Life: " . $electricCar->getBatteryLife();
PHP-യിലെ OOP: ഒരു തുടക്കക്കാരന്റെ ഗൈഡ്
PHP-യിൽ മോഡിഫയറുകൾ ആക്സസ് ചെയ്യുക
en English
X
ടോപ്പ് സ്ക്രോൾ