Výhoda OOP - prosím o příklad

<?php
class Clovek
{
   private $jmeno;
   private $narozeni;
 
   public function __construct($jmeno, $narozeni) {
       $this->jmeno = $jmeno;
       $this->narozeni= $narozeni;
   }
   
   public function getName() {
       return $this->jmeno;
   }
       
    public function getAge() {
      return date("Y")-$this->narozeni;
    }
 
}

class Pes {
    private $jmeno;
    private $majitel;
    private $rok_narozeni;
    private $rok_umrti ;
    
    public function __construct($jmeno, $majitel, $rok_narozeni, $rok_umrti = null) {
      $this->jmeno = $jmeno;
      $this->majitel= $majitel;
      $this->rok_narozeni= $rok_narozeni;
      $this->rok_umrti = $rok_umrti ;
    }
    
    public function getOwner() {
      return $this->majitel;
    }
    
    public function isAlive() {
       return $this->rok_umrti===null;
    }
    public function getDeathAge() {
       if ( $this->isAlive() ) {
           throw new Exception("Pes porad zije!");
       }
       return $this->rok_umrti-$this->rok_narozeni;
    }
    
    public function getAge() {
      return date("Y")-$this->narozeni;
    }
   
   public function getName() {
      return $this->jmeno;
   }
}

$karel = new Clovek("Karel", 1980);
$alik = new Pes("Alik", $karel, 1990, 2000);


echo 'Majitel psa jmenem '.$alik->getName() ' se jmenuje '.$alik->getOwner()->getName().'. ';
if ( $alik->isAlive() ) {
    echo "Bohuzel uz umrel ve veku ".$alik->getDeathAge()." let.";
} else {
    echo "Psovi je ".$alik->getAge()." let.";
}

var $repository = new FileRepository()
// var $repository = new MysqlRepository()
…
for(var $animal in $repository->getAnimals()) {
  echo $animal;
}

public functio render() {
    echo '<div class="form-input">';
    parent::render();
    echo '</div>';
}

V praxi to vypadá tak, že:

Ve FP vytvoříme tucet různých funkcí dělající to samé. Pak přijde senior a profackuje vývojáře, kteří projdou všechny ty funkce, a zrefaktorují je. A protože funkce je jednoduchá a kompaktní jednotka, ideálně bez stavů, tak to jde snadno.

V OOP se vytvoří tucet různých metod a tříd, ideálně velice sofistikovaně poděděných (to, že by v praxi dědičnost jakkoliv pomáhala, natož aby byla pozitivní zpětnou vazbou – je mýtus). Následně přijde senior, a začne se chytat za hlavu, a že potřebuje alespoň týden, aby to rozmotal, a dva aby se to otestovalo.

Ve funkcionálním programování jakoby prasíte, ale výsledkem je čistej kód. Klidně si šáhnu na global state, a nic se neděje. Proč? Je immutable, můžu z něj jen číst :-) V OOP velmi rychle něco poserete, ve funkcionálním programování kód zdaleka tak rychle nehnije.