L'héritage casse le principe d'encapsulation. Une sous classe dépend du fonctionnement de la classe mère (en l'occurrence la classe PDO ici). Il faut au maximum éviter la dépendance à l'implémentation et travailler sur le concept de contrat (programmer par interface).

Sur un plan purement logique, un point m'échappe dans ce raisonnement.

Je pars du principe de base que les fonctions natives d'une version stable d'un langage n'évolueront à priori pas de façon régressives, l'extension ne posera pas de problème dans le temps. Mais comme tu l'as souligné, si on suppose que l'évolution du langage déclare la classe PDO final et donc non extensible, tu n'auras pas le choix de faire une composition. En revanche, pour une modification dans son fonctionnement, que ce soit par héritage ou composition, tu vas quand même te heurter à un problème. L'objet instancié n'aura pas le même comportement et du coup son utilisation dans ta propre classe, qu'elle étende PDO ou en utilise une instance de composition, en sera modifiée également parce que le comportement des méthodes ou des propriétés en aura été modifié... Le résultat de ta propre classe sera donc obligatoirement différent aussi, non ?

Notez que je ne suis pas un gourou de la POO loin s'en faut, je pars peut-être d'une erreur d'interprétation

class PDO   {
    class Database extends PDO {
    function __construct($dsn, $username="", $password="", $driver_options=array()) {
        parent::__construct($dsn,$username,$password, $driver_options);
        $this->setAttribute(PDO::ATTR_STATEMENT_CLASS, array('DBStatement', array($this)));
    }
}
class DBStatement extends PDOStatement {
    public $dbh;
    protected function __construct($dbh) {
        $this->dbh = $dbh;
    }
}

Class SQl extends PDO
{
    public $lien;
    public function __construct($url, $login, $password, $nom){
        try
        {
            $lien = parent::__construct('mysql:host='.$url.';dbname='.$nom, $login, $mdp);
        }

        catch(Exception $e)
        {
            //Erreur
        }

    } 
}

public function query($mysql) 
    { 
        return(parent::query($mysql)); 
    } 

	public function query($mysql)
	{
		return($this->lien->query($mysql));
	}

	public function query($mysql)
	{
		return(PDO::query($mysql));
	}

	public function query($mysql)
	{
		return($lien->query($mysql));
	}

 $sql = new SQL($url, $login, $pass, $bdd);
$sql->query(...);...

Je me trompe sûrement (car moi non plus mon niveau de POO n'est pas "sublime"), mais en ajoutant un "calque" comme ça, si PDO change je n'aurais qu'à modifier ma classe et non tout mon code, ce sera plus rapide il me semble. Non ?!?

L'héritage casse le principe d'encapsulation. Une sous classe dépend du fonctionnement de la classe mère (en l'occurrence la classe PDO ici). Il faut au maximum éviter la dépendance à l'implémentation et travailler sur le concept de contrat (programmer par interface).

Ensuite, merci à zeus, mais comment dois-je l'utiliser, j'ai bien une idée :

public function __call($methode, $parametres)

public function __call($lien, $methode)

L'héritage casse le principe d'encapsulation. Une sous classe dépend du fonctionnement de la classe mère (en l'occurrence la classe PDO ici). Il faut au maximum éviter la dépendance à l'implémentation et travailler sur le concept de contrat (programmer par interface).

L'héritage peut fragiliser le code car il dépend de détails d'implémentation. Clairement, n'ayant pas la main sur l'implémentation de la classe PDO, utiliser la composition permet de s'affranchir du fonctionnement interne de la classe.

J'ai tendance à utiliser l'héritage dans du code que je maîtrise. C'est fort pratique pour factoriser du code. Mais dès que je dépend du code d'autrui, j'utilise au maximum la composition afin de rester insensible aux modifications futures de la librairie que j'utilise

PS : désolé katagoto

Je sens un débat intéressant.

// tu ne devrais pas hard coder le DSN car ta classe ne peut pas
//être utilisée avec MySQL par exemple

<?php
class sql {
   public function __call($methode, $parametres) {
         try
         {
            return $methode->$parametres;
         }
         catch(Exception $e) 
        { 
            $_SESSION['erreur']=$e; 
            header("Location:erreur_sql.php"); 
        } 
   }
}