Ereditarietà in PHP OOP

I

Che cos'è l'ereditarietà?

Quando una classe deriva da un'altra classe, si parla di ereditarietà. Ecco alcuni termini importanti relativi all'ereditarietà in PHP.

  • Classe genitore – La classe da cui derivano le altre classi è detta classe genitore. È anche conosciuta come classe base.
  • Classe bambino – La classe che deriva da un'altra classe è chiamata classe figlio. Ci sono anche altri nomi come classe foglia o classe derivata.
Ereditarietà in PHP

Come ereditare una classe in PHP?

Una classe può essere ereditata usando si estende parola chiave. Guarda il seguente esempio.

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

Nell'esempio sopra

  • Creiamo una classe base o padre Fruit con alcune proprietà e metodi.
  • Creiamo un'altra mela di classe che estende/eredita la classe padre Fruit usando la parola chiave estende.
  • Crea un'istanza/oggetto apple e accedi al metodo della classe fruit utilizzando l'ereditarietà.

Concludendo l'introduzione all'ereditarietà in PHP, raccogliamo i seguenti punti per te.

  1. L'ereditarietà consente alla classe figlia di accedere al __construct pubblico, ai metodi e alle proprietà della classe padre.
  2. Nell'esempio sopra, possiamo accedere al metodo della classe apple usando il suo oggetto, così come i metodi della classe genitore.

Ambito dei modificatori di accesso protetto in Ereditarietà

Nel tutorial precedente, abbiamo appreso che gli attributi/metodi protetti di una classe sono accessibili all'interno della classe e delle classi derivate da essa.

Per comprendere l'ambito dei modificatori di accesso protetto nell'ereditarietà, esaminiamo prima l'esempio seguente.

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

Nell'esempio sopra:

  • Creiamo un frutto di classe con alcuni attributi pubblici e un metodo protetto.
  • Creiamo un'altra classe apple, si estende dalla classe Fruit e ne creiamo l'istanza.
  • Quando proviamo ad accedere al metodo protetto della classe Fruite utilizzando l'oggetto classe apple, viene restituito un errore perché stiamo cercando di accedere al membro protetto della classe Fruit al di fuori della classe derivata.

Passiamo a un altro esempio, che in realtà è leggermente modificato dall'esempio precedente.

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

Nell'esempio sopra, il metodo protetto della classe Fruit è accessibile nella classe apple perché lo stiamo accedendo all'interno della classe.

Override nell'ereditarietà

Override si riferisce alla ridefinizione dei metodi della classe genitore nelle classi figlie, utilizzando lo stesso nome. Guarda il seguente esempio di sovrascrittura nell'ereditarietà di seguito.

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

Nell'esempio sopra:

  • Creiamo una classe padre Fruit e una classe figlia apple che estende la classe Fruit e ridefinisce i metodi __conduct e intro in essa.
  • Si noti che la classe figlia apple definisce i metodi __construct e intro con lo stesso nome. Tuttavia, i parametri possono essere diversi.
  • Creiamo l'istanza della classe apple e passiamo i parametri alla funzione di costruzione.
  • Quando chiamiamo il metodo intro usando l'istanza apple, chiama il metodo intro della classe apple perché abbiamo creato l'istanza dell'oggetto apple usando il costruttore della classe apple.

Ruolo della parola chiave finale nell'ereditarietà

finale La parola chiave impedisce alla classe figlia/derivata di sovrascrivere il metodo della classe padre/base. Guarda il seguente esempio per capire l'uso della parola chiave Final.

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

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

Nell'esempio sopra, la classe apple tenta di sovrascrivere il metodo intro. Darà un errore perché abbiamo usato la parola chiave final con il metodo intro della classe Fruit.

Clicca per un ufficiale riferimento all'ereditarietà PHP.

Conclusioni

L'ereditarietà non è solo un importante concetto di OOP in PHP, ma gioca un ruolo fondamentale in qualsiasi linguaggio. Dal punto di vista dell'intervista, le domande sull'eredità sono molto importanti. Quindi, devi praticare l'eredità da solo.

Aggiungi un commento

Rete di tutor

Impara PHP dalla A alla Z