POO : Les objets en PHP

 

Avec le PHP4, sont apparus les objets et les classes comme en programmation orientée objet (POO).
L'objectif est de créer un code facilement réutilisable en constituant des bibliothèques.
Malheureusement, les performances actuelles sont trés limitées contrairement à la POO C++.

Pour comprendre la notion d'objet, prenons l'exemple des applications Windows en POO C++.
Une boite de dialogue contient en standard un cadre, 3 petits boutons en haut à droite (Minimiser, Agrandir, Fermer) un bouton OK , un bouton Annuler et du texte.
Elle peut aussi contenir des onglets (voir par exemple Options Internet d'Internet Explorer). Une fenêtre d'édition contient aussi un cadre, des boutons, un menu, ...

La POO permet alors de définir une classe cadre, une classe bouton , ..... Ainsi la classe associée à l'objet boite de dialogue pourra « hériter » des propriétés des objets constitutifs qui possédent leur propre « gestion d'événements »

Créer un objet consiste à créer une « instance » de la classe qui gère cet objet. Une propriété de l'objet est gérée par une « méthode » (fonction interne à la classe)

Je vous propose un petit comparatif entre les objets PHP et C++ à partir d'exemples. Mais ceci ne vous donnera qu'un bref aperçu des possibilités de chaque langage.

PHP

Toutes les variables et méthodes sont publiques!
Les méthodes sont toutes INLINE.
Dés qu'une fonction a le même nom que la classe, c'est le Constructeur.
Il n'existe pas de destructeur : il faut penser alors à créer une fonction de libération de la mémoire
(avec unset par exemple)
Il existe un pointeur interne sur l'objet : $this

Syntaxe : (exemple)
class PEAR
{
// déclaration et initialisation : que des constantes !
var $_debug = false;
var $_default_error_mode = null;
var $_default_error_options = null;
var $_default_error_handler = '';
var $_error_class = 'PEAR_Error';
var $_expected_errors = array();
// constructeur
function PEAR($error_class = null)
{
$classname = get_class($this);
....
}
// destructeur
function _PEAR()
{ ..... }
function isError($data)
{
return (bool)(is_object($data) &&
(get_class($data) == 'pear_error' ||
is_subclass_of($data, 'pear_error')));
}
function setErrorHandling($mode = null, $options = null)
{ ..... }
........
}

Héritage :
Pas d'héritage multiple.
( suite exemple)
pas de constructeur ici.
class Mail extends PEAR
{
function factory($driver, $params = array() )
{ ..... }
function send($recipients, $headers, $body)
{
if (is_array($recipients))
$recipients = implode(', ', $recipients);
$subject = '';
if (isset($headers['Subject']))
{
$subject = $headers['Subject'];
unset($headers['Subject']);
}
// appel de méthode
list(,$text_headers) = Mail::prepareHeaders($headers);
return mail($recipients, $subject, $body, $text_headers);
}
function prepareHeaders($headers)
{ ..... }
.......
}

>

Si un constructeur de la classe dérivée existe, le constructeur de la classe parent n'est pas appelé.
Il faut l'appeler explicitement
nomclassepere::nomclassepere(valeur1, valeur2)
ou parent:: ou $this->
( parent est un mot réservé PHP )

Création d'instance
$xxx = new maclasse0( valeur1, valeur2 );
Ne pas oublier de passer les variables aux arguments de la fonction.





C++

Les variables et les méthodes sont publiques, protégées, privées suivant le comportement souhaité.
Les méthodes peuvent être définies à l'intérieur de la classe (INLINE) ou à l'extérieur.
Bien d'autres possibilités existent....
Il existe un pointeur interne sur l'objet : this

Syntaxe : (exemple)
class TObjectBuilder
{
public:
// constructeur
TObjectBuilder( TWindow& owner, int cursorId );
// destructeur, peut être surchargé dans une classe dérivée
virtual ~TObjectBuilder();
void SetAnchor( TPoint pos );
void Drag( TPoint pos );
// pointeur de fonction sur un objet
GraphicalObject *CreateObject();
// fonction constante
void Cancel() const;
protected:
// inline car définie
const TWindow& GetOwner() const { return Owner; }
private:
class BuilderDC : public TClientDC
{
public:
BuilderDC( HWND wnd );
~BuilderDC();
};
// 2 fonctions virtuelles pures
// méthodes abstraites => les définitions seront
// dans les classes dérivées
virtual void DrawSkeleton(
TDC& dc,
TPoint p1,
TPoint p2 ) const = 0;
virtual GraphicalObject
*BuildObject( TPoint p1, TPoint p2 ) = 0;
TPoint Anchor; // variable type objet TPoint
TPoint Current;
int Anchored; // type entier
HCURSOR OldCursor;
TWindow& Owner;
// autre constructeur; privé ici
// pour copier des objets
TObjectBuilder( const TObjectBuilder& );
const
TObjectBuilder& operator = ( const TObjectBuilder& );
};

Héritage :
L'héritage multiple est possible.
(suite exemple)
class LineBuilder : public TObjectBuilder
{
public:
LineBuilder( TWindow& owner );
private:
// ces 2 fonctions virtuelles surchargent
// celles de la classe parent : polymorphisme dynamique
virtual void DrawSkeleton
( TDC& dc, TPoint p1, TPoint p2 ) const;
virtual
GraphicalObject *BuildObject( TPoint p1, TPoint p2 );
};
autre exemple : héritage multiple
class CaptionedRectangleBuilder :
public RectangleBuilder,
private CaptionBuilder
{ ..... };

Création d'instance
Par exemple, on déclare un pointeur sur un objet
TObjectBuilder *Builder = new LineBuilder( *this );
mais on doit aussi penser à libérer la mémoire si l'objet est inutile :
if ( Builder ) delete Builder;
Builder = 0;

 


Si vous aimez le site

 

Select a language if you need :


Page chargée en 0.003 sec.

Dernière Modification : Mer 25 Janvier 2017 8:56
Copyright © 1999-2017 Jean-Paul Molina Tous droits réservés.

to Google