Moștenirea în PHP OOP

I

Ce este Moștenirea?

Când o clasă derivă dintr-o altă clasă, este cunoscută ca moștenire. Iată câțiva termeni importanți legați de moștenire în PHP.

  • Clasa părinte – Clasa din care sunt derivate celelalte clase se numește clasă părinte. Este cunoscută și sub numele de clasă de bază.
  • Clasa pentru copii – Clasa care este derivată dintr-o altă clasă se numește clasă copil. Există și alte nume pentru aceasta, cum ar fi clasa frunzelor sau clasa derivată.
Moștenirea în PHP

Cum se moștenește o clasă în PHP?

O clasă poate fi moștenită prin utilizarea extinde cuvânt cheie. Uită-te la următorul exemplu.

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

// Apple is inherited from Fruit
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();
?>

În exemplul de mai sus

  • Creăm o clasă de bază sau părinte Fruit cu unele proprietăți și metode.
  • Creăm un alt măr de clasă care extinde/moștenește clasa părinte Fruit folosind cuvântul cheie extinde.
  • Creați o instanță/obiect Apple și accesați metoda clasei de fructe folosind moștenirea.

Încheind introducerea în moștenire în PHP, adunăm următoarele puncte pentru tine.

  1. Moștenirea permite clasei copil să acceseze __constructul public, metodele și proprietățile clasei părinte.
  2. În exemplul de mai sus, putem accesa metoda clasei Apple folosind obiectul său, precum și metodele clasei părinte.

Domeniul de aplicare al modificatorilor de acces protejat în Moștenire

În tutorialul anterior, am învățat că atributele/metodele protejate ale unei clase sunt accesibile în cadrul clasei și claselor derivate din aceasta.

Pentru a înțelege domeniul de aplicare al modificatorilor de acces protejat în moștenire, să ne uităm mai întâi la următorul exemplu.

<?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();
?>

În exemplul de mai sus:

  • Creăm un fruct de clasă cu unele atribute publice și o metodă protejată.
  • Creăm o altă clasă Apple, se extinde din clasa Fruit și îi creăm instanța.
  • Când încercăm să accesăm metoda protejată a clasei Fruite folosind obiectul clasei Apple, dă eroare, deoarece încercăm să accesăm un membru protejat al clasei Fruit în afara clasei derivate.

Să trecem la un alt exemplu, care este de fapt puțin modificat față de exemplul de mai sus.

<?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();
?>

În exemplul de mai sus, metoda protejată a clasei Fruit este accesibilă în clasa Apple, deoarece o accesăm în cadrul clasei.

Ignoră în Moștenire

Supracomandarea se referă la redefinirea metodelor clasei părinte în clasele copil, folosind același nume. Uitați-vă la următorul exemplu de înlocuire a moștenirii de mai jos.

<?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();
?>

În exemplul de mai sus:

  • Creăm o clasă părinte Fruit și o clasă copil Apple care extinde clasa Fruit și redefinim metodele __contruct și intro în ea.
  • Rețineți că clasa copil Apple definește metodele __construct și intro cu același nume. Cu toate acestea, parametrii pot fi diferiți.
  • Creăm intanța clasei Apple și trecem parametrii funcției de construcție.
  • Când apelăm metoda intro folosind instanța Apple, aceasta apelează metoda intro a clasei Apple, deoarece am creat instanța obiectului Apple folosind constructorul clasei Apple.

Rolul cuvântului cheie final în moștenire

final cuvântul cheie împiedică clasa copil/derivată să suprascrie metoda clasei părinte/de bază. Priviți următorul exemplu pentru a înțelege utilizarea cuvântului cheie Final.

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

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

În exemplul de mai sus, clasa Apple încearcă să suprascrie metoda intro. Va da o eroare deoarece am folosit cuvântul cheie final cu metoda de introducere a clasei Fruit.

Faceți clic pentru un oficial referință la moștenirea PHP.

Concluzii

Moștenirea nu este doar un concept important de POO în PHP, dar, în orice limbă, joacă un rol vital. Din perspectiva interviului, întrebările legate de moștenire sunt foarte importante. Deci, trebuie să practici moștenirea pe cont propriu.

Adaugă comentariu

Rețeaua de tutori

Învață PHP de la A la Z