Moștenirea în PHP OOP

Modificatori de acces în PHP
Constante în PHP OOP

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ă folosind extinde cuvânt cheie. Uită-te la următorul exemplu.

<?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
?>

În acest exemplu, clasa Apple extinde clasa Fruit, ceea ce înseamnă că clasa Apple conține toate atributele și metodele clasei Fruit pe lângă propriile sale. Constructorul clasei Apple folosește funcția parent:: construct() pentru a apela constructorul părinte, furnizând parametrii corespunzători. Apoi, folosind moștenirea, puteți crea o instanță a clasei Apple și puteți accesa funcția din clasa părinte.

Pentru a rezuma cele de mai sus:

  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 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:

  • Facem o clasă numită fructe care are anumite caracteristici publice și o funcție protejată.
  • Construim o altă clasă, Apple, care se extinde de la Fruit și are propria ei instanță.
  • Când încercăm să accesăm metoda protejată a clasei Fruit folosind obiectul clasei Apple, dă eroare, deoarece încercăm să accesăm un membru protejat al clasei Fruit în afara clasei derivate.

Să ne uităm la un alt exemplu, care este în esență o versiune puțin modificată a ultimului.

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

Deoarece îl accesăm în cadrul clasei din exemplul precedent, metoda protejată a clasei Fruit este disponibilă în clasa Apple.

Ignoră în Moștenire

Suprascriere înseamnă redefinirea metodelor clasei părinte în clasele copil cu același nume. Luați în considerare următorul exemplu de suprascriere a moștenirii.

<?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:

  • Suprascriere înseamnă redenumirea metodelor clasei părinte din clasele copil. Luați în considerare următorul exemplu de suprascriere în moștenire.
  • Este demn de remarcat faptul că metodele __construct și intro din clasa copil Apple au același nume. Cu toate acestea, parametrii pot varia.
  • Creăm o instanță a clasei Apple și trimitem argumentele la metoda build.
  • Deoarece am generat instanța obiectului Apple folosind constructorul clasei Apple, atunci când apelăm metoda intro folosind o instanță Apple, aceasta apelează funcția intro a clasei Apple.

Rolul cuvântului cheie final în moștenire

Cuvântul cheie final interzice clasa copil/derivată să suprascrie funcția clasei părinte/de bază. Uitați-vă la următorul exemplu pentru a vedea cum este utilizat cuvântul cheie Final.

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

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

Clasa Apple încearcă să suprascrie metoda intro din exemplul precedent. Va genera o eroare, deoarece am folosit cuvântul cheie final cu funcția de introducere a clasei Fruit.

Dacă doriți să citiți mai multe despre moștenirea PHP, vă recomandăm următoarele ghid oficial.

Q & A

Î: În PHP OOP, ce este moștenirea?
R: În PHP OOP, moștenirea este un sistem care permite unei noi clase să moștenească atributele și metodele unei clase anterioare. Acest lucru implică faptul că noua clasă poate reutiliza codul și funcționalitatea clasei părinte adăugând, de asemenea, proprietăți și metode noi.

Î: În PHP, cum definiți o clasă care moștenește de la o altă clasă?
R: În PHP, cuvântul cheie „extends” este folosit pentru a defini o clasă care moștenește de la o altă clasă. De exemplu, dacă aveți o clasă părinte „ParentClass” și doriți să construiți o clasă copil „ChildClass” care moștenește din aceasta, puteți scrie:

class ChildClass extends ParentClass {
  // properties and methods
}

Î: În PHP, poate o clasă să moștenească din mai multe clase?
R: Nu, în PHP, o clasă poate moșteni doar de la o altă clasă. Cu toate acestea, interfețele pot fi folosite pentru a oferi funcționalitate echivalentă, iar o clasă poate implementa multe interfețe.

Î: Este posibil să suprascrieți o metodă într-o clasă copil?
R: Da, puteți suprascrie o metodă dintr-o clasă copil creând o metodă cu același nume. Când este invocată pe un obiect de clasă copil, metoda clasei copil va fi utilizată în locul metodei clasei părinte.

Î: Este posibil să invocați o metodă de clasă părinte dintr-o clasă copil?
R: Da, puteți utiliza cuvântul cheie „părinte” urmat de operatorul de rezoluție a domeniului (::) și numele metodei pentru a apela o metodă de clasă părinte dintr-o clasă copil. Ca exemplu:

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

Exerciții:

  1. Care este cuvântul cheie folosit în PHP pentru a indica faptul că o clasă moștenește de la o altă clasă?
  2. Cum puteți accesa o metodă sau o proprietate din clasa părinte într-o clasă copil?
  3. Cum puteți apela constructorul clasei părinte în cadrul constructorului unei clase copil?
  4. Cum poți împiedica o metodă sau o proprietate să fie înlocuită într-o clasă copil?
  5. Care este diferența dintre extends și implements cuvinte cheie în PHP?

răspunsuri:

  1. extends cuvântul cheie este folosit în PHP pentru a indica faptul că o clasă moștenește de la o altă clasă.
  2. Puteți accesa o metodă sau o proprietate din clasa părinte dintr-o clasă copil utilizând parent:: cuvânt cheie, urmat de metoda sau numele proprietății.
  3. Puteți apela constructorul clasei părinte în cadrul constructorului unei clase copil folosind parent::__construct() metodă.
  4. Puteți preveni suprascrierea unei metode sau a unei proprietăți într-o clasă copil utilizând final cuvânt cheie înainte de metoda sau declarația proprietății din clasa părinte.
  5. extends cuvântul cheie este folosit pentru a indica faptul că o clasă moștenește de la o altă clasă, în timp ce implements cuvântul cheie este folosit pentru a indica faptul că o clasă implementează o interfață.
Modificatori de acces în PHP
Constante în PHP OOP
en English
X
Derulaţi în sus