Archives par mot-clé : héritage

Subtilité sur les classes abstraites Java

Publié dans Java | Laisser un commentaire

J’ai découvert une petite subtilité dans l’utilisation des classes abstraites aujourd’hui. Imaginons une interface Java qui est partiellement implémentée par une classe abstraite. Cette classe abstraite est assez naturellement étendue par une bonne vieille classe Java (la version française du POJO ;p). Jusqu’ici tout va bien.

Exemple 1 : héritage Java

Exemple 1 : héritage Java

Maintenant, imaginons que les méthodes implémentées dans notre classe abstraite, utilisent des méthodes implémentées seulement dans notre POJO. C’est là qu’est la subtilité (que j’annonce subtilement).
Continuer la lecture

Qt et l’héritage de QObjects

Publié dans C / C++ | Laisser un commentaire

Le modèle objet de Qt est basé sur les QObject, qui offrent notamment le système très utile de communication inter-classes via signal / slot. Gérer l’héritage avec cette architecture peut-être de prime-abord légèrement tricky ! J’ai notamment eu quelques soucis de connexion signal / slot avec des classes héritant d’une interface (classe virtual pure).

Mon architecture

Une interface IMyClass et deux classes l’implémentant MyClass et MyClassSimulation. J’ai en prime un patron « factory » pour faciliter l’instanciation de ces classes (et pour avoir plus de souplesse dans l’avenir) : MyClassFactory.

C++ inheritance and factory

C++ inheritance and factory pattern

Je connecte alors la méthode « slot » de mon instance de IMyClass (qui est soit MyClass, soit MyClassSimulation en ait) :

connect(otherClass, SIGNAL(aSuperSignal()), myClassInstance, SLOT(myGreatMethod());

L’erreur typique

QObject::connect: Cannot connect OtherClass::aSuperSignal() to (null)::myGreatMethod()

Continuer la lecture

George Müller

Anecdote n°3 : Georges Müller dans le brouillard

Publié dans L'anecdote du week-end | Laisser un commentaire
George Müller

Photographie de M. George Müller

L’évangéliste Charles Inglis raconta ce qui suit à propos de George Müller: « Lorsque je suis allé en Amérique pour la première fois, il y a trente et un ans, le capitaine du navire était l’un des plus fervents croyants que j’ai jamais connus. Alors que nous nous approchions de Terre-Neuve, il me dit : Monsieur Inglis, la dernière fois que je suis passé par là, il y a cinq semaines, il s’est passé une chose si extraordinaire qu’elle a changé toute ma vie de croyant. Jusqu’alors j’étais un croyant ordinaire comme il y en a beaucoup. Il y avait à bord avec nous un homme de Dieu, monsieur George Müller, de Bristol. j’avais passé vingt-deux heures sans quitter le pont de commandement un seul instant, lorsque je sursautai parce qu’on m’avait touché l’épaule. C’était monsieur George Müller.
Continuer la lecture

Classes abstraites et finales

Publié dans PHP objet | 2 commentaires

Les notions de classes abstraites et classes finales permettent de sécuriser notre programmation PHP, dans le sens qu’elles permettent d’éviter qu’un programmeur, reprenant notre code, n’en contourne la logique et s’égare ainsi sur une fausse piste.
En effet :

  • Class abstraite : class qui ne peut être instanciée, il est donc OBLIGATOIRE de créer une class héritante de cette class pour s’en servir. Utile lorsque l’on créé une class générique qui ne servira qu’à créer des sous class et non à être instanciée. Une telle class ne contient donc pas de __construct() puisqu’elle n’est pas instanciée. Mot clef : abstract.
  • Class finale : class qui NE PEUT PLUS avoir de sous-class, c’est-à-dire de class héritante. Les méthodes de cette class ne pourront être surchargées (réécrites, redéfinies). Mot clef : final. De la même manière, on peut aussi déclarer des méthodes abstraites et finales.
  • Méthode abstraite : méthode qui doit OBLIGATOIREMENT être surchargée (réécrite, ou redéfinie). Une class contenant une méthode abstraite doit aussi être abstraite. Mot clef : abstract.
  • Méthode finale : méthode qui NE PEUT ÊTRE surchargée (réécrite, redéfinie). Une class finale s’applique sur toutes les méthodes ou attributs de la classe, alors qu’ici on ne touche qu’à une seule méthode. Mot clef : final. Pour bien comprendre ces 2 notions et en saisir mieux l’intérêt voici plusieurs exemples, un pour chaque cas.

Class et méthodes abstraites

 abstract class Site {
	protected $type;
	protected $name;
	public function getType()
	{
		return $this->type;
	}
	public function getName()
	{
		return $this->name;
	}
}
$monSite = new Site();
echo $monSite->getType(); // Erreur : on tente d'instancier une classe abstraite

Continuer la lecture

Vocabulaire à connaître de la POO

Publié dans PHP objet | 2 commentaires

Voici quelques mots de vocabulaire qu’il peut être utile de connaître pour s’y retrouver en programmation orientée objet. Je complèterai cette liste au fil du temps. (en fonction de mes souvenirs et de mes découvertes)

  • Classe : Permet de définir la structure d’un objet qui pourra ensuite être utilisé plusieurs fois avec des options différentes, et dupliqué à loisir par le biais de classes filles. Mot clef : class
  • Instance : Une classe définie et chargée. Une instance (un objet) est donc utilisable concrètement, alors qu’une classe. Mot clef : new
  • Objet : Instance d’une classe
  • Attribut ou Propriété : Variable d’une classe. Mot clefs : var ou const
  • Méthode : Fonction d’une classe. Mot clefs : function
  • Surcharge ou polymorphisme Ad hoc : Permet de définir des méthodes avec le même nom et ayant des fonctionnalités similaires (ex : afficher(), supprimer()) dans des classes héritant d’une même classe mais n’ayant pas d’autres liens entres elles. On parle ainsi de surcharge d’une méthode lorsque l’on redéfinie une méthode qui avait déjà été définie dans une classe parente. Ex : fonction trier() qui fonctionnera pour trier des livres ou des CD sans que le programmeur se souci du nom de la méthode.
  • Attribut ou méthode magique : Attribut ou méthode commençant généralement par deux underscores (__) , étant apparu dans PHP 5, et ayant des fonctionnalités impossible à coder « à la main » comme par exemple le déclenchement d’une méthode lors de l’instanciation d’une classe ou la suppression d’une instance. Ex : __construct, __clone, __toString
  • Méthode prédéfinie : Méthode déjà définie par PHP. Ex : get_parent_class, class_exists
  • Héritage : Notion permettant qu’une classe (dites fille) hérite des attributs et des méthodes d’une autre classe (dites parente). Mot clef : extends
  • Constructeur : Méthode permettant de créer un objet en instanciant une classe. Mot Clef : __construct($params)
  • Interface : Définie une liste de méthodes que doit contenir les classes qui implémentent cette interface. Mot clef : interface

Constructeur et notion d’héritage

Publié dans PHP objet | Laisser un commentaire

Continuons avec les bases en nous intéressant au constructeur et à la notion d’héritage.

Constructeur

Dans mon dernier billet, je me suis amusé à remplir mes attributs à la main, pourtant, en utilisant un constructeur, tout serait bien plus simple. Un constructeur est une méthode qui a le même nom que la class. Elle prend en paramètre les attributs que l’on souhaite remplir.

<?php
class Blog {
  var $nom;
  var $description;
  var $url = 'http://url.fr';
  function Blog($nom, $description) {
    $this->nom = $nom;
    $this->description = $description;
  }
  function ajouter_billet() {
     echo 'Ceci est mon premier billet pour blog '.$this->nom.'.<br />';
  }
  function ajouter_categorie() {
    echo 'Ceci est ma première catégorie pour blog '.$this->nom.'.<br />';
  }
}

$blogDeBN = new Blog('30 minutes par jour', '30 minutes par jour au coeur de l\'informatique.');
// On peut afficher les attributs
echo 'Nom du blog : '.$blogDeBN->nom.'<br />';
echo 'Description du blog : '.$blogDeBN->description.'<br />';
echo 'Url du blog : '.$blogDeBN->url.'<br />';
// On utilise les méthodes
$blogDeBN->ajouter_billet();
$blogDeBN->ajouter_categorie(); ?>

Attribut objet

En PHP objet, il est tout à fait possible de créer un attribut qui sera un objet (une instance d’une class), tout comme cet attribut aurait pu être un int, un string, … Il nous faudra donc utiliser deux sélecteurs flêches -> pour accéder aux attributs de cet objet.

<?php
class Categorie {
  var $nom;
  var $description;
  var $sousCat;
  function Categorie($nom, $description) {
    $this->nom = $nom;
    $this->description = $description;
  }
}

class Blog {
  var $nom;
  var $description;
  var $categorie;
  var $url;
  function Blog($nom, $description, $categorie) {
    $this->nom = $nom;
    $this->description = $description;
    $this->categorie = $categorie;
  }
  function ajouter_billet() {
     echo 'Ceci est mon premier billet pour blog '.$this->nom.'.<br />';
  }
  function ajouter_categorie() {
    echo 'Ceci est ma première catégorie pour blog '.$this->nom.'.<br />';
  }
}

// --- Un attribut peut être un objet
$catCMS = new Categorie('CMS', 'Quelques lignes sur les CMS');
$blogDeBN = new Blog('30 minutes par jour', '30 minutes par jour au coeur de l\'informatique.', $catCMS, 'http://30minparjour.la-bnbox.fr');
// On peut afficher les attributs
echo 'Catégorie : '.$catCMS->nom.'<br />';
echo 'Description de la catégorie : '.$catCMS->description.'<br /><br />';
echo 'Nom du blog : '.$blogDeBN->nom.'<br />';
echo 'Description du blog : '.$blogDeBN->description.'<br />';
echo 'Catégorie du blog : '.$blogDeBN->categorie->nom.'<br />';
echo 'Description de la catégorie : '.$blogDeBN->categorie->description.'<br />';
echo 'Url du blog : '.$blogDeBN->url.'<br /><br />';
// --- Un attribut peut aussi être une instance de la même classe que son objet parent
$catDotclear = new Categorie('Dotclear', 'Parlons de Dotclear');
$catCMS->sousCat = $catDotclear;
// On affiche les attributs
echo 'Catégories du blog : '.$blogDeBN->categorie->nom.' / '.$blogDeBN->categorie->sousCat->nom.'<br />';
echo 'Description de la catégorie : '.$catCMS->sousCat->description.'<br />'; ?>

Notion d’héritage

On peut aussi construire des class qui hériteront des attributs et méthodes d’une autre classe. Prenons un exemple. Un blog photo est bien un blog, il a bien un nom, une description, un url, on peut ajouter un billet ou une catégorie. Mais il serait assez pratique de pouvoir préciser aussi le nombre de photos qu’il contient, ou alors une méthode pour ajouter une photo, … tout un tas de choses qu’un blog classique n’a pas besoin. Au lieu de réécrire deux class grandement similaire, on va dire que la class BlogPhoto va hériter de tous les attributs et méthodes de la class Blog grâce au mot clé extends.

<?php
class Blog {
  var $nom;
  var $description;
  var $url;
  function Blog($nom, $description) {
    $this->nom = $nom;
    $this->description = $description;
  }
  function ajouter_billet() {
     echo 'Ceci est mon premier billet pour blog '.$this->nom.'.<br />';
  }
  function ajouter_categorie() {
    echo 'Ceci est ma première catégorie pour blog '.$this->nom.'.<br />';
  }
}

class BlogPhoto extends Blog {
  var $nbDePhoto;
  function ajouter_photo() {
    echo 'J\'ajoute une magnifique photo...';
  }
}

$blogDeBN = new Blog('30 minutes par jour', '30 minutes par jour au coeur de l\'informatique.');
$blogPhoto = new BlogPhoto('Mes photos', '');
$blogPhoto->nbDePhoto = '10';
// On peut afficher les attributs
echo 'Nom du blog de BN : '.$blogDeBN->nom.'<br />';
echo 'Description du blog de BN : '.$blogDeBN->description.'<br />';
echo 'Nb de photos du blog de BN (erreur) : '.$blogDeBN->nbDePhoto.'<br />';
echo 'Nom du blog photo : '.$blogPhoto->nom.'<br />';
echo 'Description du blog Photo : '.$blogPhoto->description.'<br />';
echo 'Nb de photos du blog Photo : '.$blogPhoto->nbDePhoto.'<br />'; $blogPhoto->ajouter_photo(); 

Si je redéfinis un attribut ou une méthode dans ma class BlogPhoto, cet attribut ou cette méthode sera réécris et ce n’est plus celui de la class Blog qui sera utilisé. Bon, fini pour ajourd’hui. Le cours sur Developpez.com a l’air bien complet et plutôt bien expliqué. Par contre, j’ai cru comprendre que PHP 5 avait amené son lot de nouveautés et que du coup mes 2 derniers billets sont peut-être obsolètes. Il existe par exemple un mot clé __construct pour le constructeur. Bref, je vais lire ce cours et je pourrai en dire plus à ce moment là !