Classe astratta in PHP OOP

A
SSL affidabile a partire da soli $ 3.44
Costanti in PHP OOP
Interfaccia in PHP

In questo articolo, impareremo la classe astratta in PHP.

Che cos'è una classe astratta in PHP?

Una classe astratta contiene la dichiarazione dei metodi ma non la loro definizione. Contiene solo i loro nomi. È responsabilità della classe figlia definire questi metodi.

Che cos'è un metodo astratto?

Un metodo astratto è un metodo di una classe astratta che viene dichiarata utilizzando parole chiave astratte e non contiene il corpo. È definito dalla classe del bambino.

  • astratto la parola chiave viene utilizzata per dichiarare una classe o un metodo astratto.
  • Una classe astratta deve contenere almeno un metodo astratto. Tuttavia, può contenere anche metodi non astratti.

Sintassi

<?php
abstract class ParentClass {
  abstract public function someMethod1();
  abstract public function someMethod2($name, $color);
  abstract public function someMethod3() : string;
}
?>

Quali sono le regole della classe astratta in PHP?

  • Una classe astratta deve contenere almeno un metodo astratto. Tuttavia, può contenere anche metodi non astratti.
  • Quando un figlio chiamato eredita la classe genitore astratta, deve definire i metodi astratti della classe genitore con lo stesso nome.
  • Durante la definizione dei metodi asbtract nella classe figlio, dovrebbe essere definito con un modificatore di accesso meno limitato. Ad esempio, se la classe genitore contiene il metodo astratto con protetta modificatore di accesso. Quindi, quando la classe figlia definisce questo metodo, dovrebbe mantenere il suo modificatore di accesso come protetta or la percezione. Non può impostarlo su un bagno, perché più ristretto del protetto.
  • La classe figlia che definisce il metodo abstract deve passare lo stesso numero di argomenti come specificato nella dichiarazione nella classe asbtract genitore. Tuttavia, la classe figlio può avere argomenti opzionali/extra diversi da quelli richiesti.

Esempio di classe astratta in PHP

<?php
// Parent abstract class
abstract class Bike {
  public $name;
  public function __construct($name) {
    $this->name = $name;
  }
  abstract public function introduction() : string;
}

// Child classes defining the parent classes
class Honda extends Bike {
  public function intro() : string {
    return "I am $this->name!";
  }
}

class Suzuki extends Bike {
  public function introduction() : string {
    return "I am $this->name!";
  }
}

// Objects from child classes
$honda = new honda("Honda");
echo $honda->introduction();

$suzuki= new suzuki("Suzuki");
echo $suzuki->introduction();

?>

Spiegazione dell'esempio sopra

  • Nell'esempio sopra, creiamo una classe astratta Biciclette che contiene un metodo astratto introduzione.
  • Creiamo due classi figlio Honda di Suzuki che estende la classe astratta e definisce il metodo di introduzione.
  • Creiamo gli oggetti di queste classi e chiamiamo il metodo di introduzione usando i loro oggetti. Il metodo di introduzione funziona secondo l'implementazione data dalla sua classe corrispondente.

Esempio di classe astratta con argomenti extra nell'override del metodo



<?php
// Parent abstract class
abstract class Bike {
  public $name;
  public function __construct($name) {
    $this->name = $name;
  }
  abstract protected function introduction($model) : string;
}

// Child classes defining the parent classes
class Honda extends Bike {
  public function intro($model) : string {
    return "I am $this->name. My model is $model";
  }
}

class Suzuki extends Bike {
  public function introduction($model, $color=null) : string {
    return "I am $this->name. My model is $model and color is $color";
  }
}

// Objects from child classes
$honda = new honda("Honda");
echo $honda->introduction();

$suzuki= new suzuki("Suzuki");
echo $suzuki->introduction();
?>

Spiegazione dell'esempio sopra

  • La logica di base dell'esempio precedente è come l'esempio precedente. Tuttavia, passiamo un argomento in più alla funzione nel metodo di introduzione di suzuki classe.
  • Come abbiamo definito la regola in precedenza in questo tutorial, il modificatore di accesso della classe figlio durante l'implementazione del metodo astratto della classe genitore deve essere minore di quanto specificato nella classe genitore per la dichiarazione di questo metodo. Quindi, entrambe le classi figlio utilizzano il modificatore di accesso pubblico per definire il metodo di introduzione.
  • Prova a definire la funzione con il modificatore di accesso privato, produrrà un errore.

Nota: la classe astratta non contiene alcun metodo del costruttore. Quindi, non possiamo creare l'istanza di una classe astratta.

Astrazione della classe Documentazione ufficiale di PHP 8.

Costanti in PHP OOP
Interfaccia in PHP

Rete di tutor

Condividi questo

Impara PHP dalla A alla Z