Comment trouviez vous ce cours ?

12(85.7%)
10
2(14.3%)

Appéciations du lecteurs :

Visualisations : 645
Appreciations : 14

A propos de l'auteur :

R@chid
Email: victrachild@yahoo.com
Validation du cour :

La Programmation orientée objet Php

Php _ la programmation orientée objet

La programmation orienté objet est un type de programmation basée sur des objets, un objet représente un concept, une idée ou toute entité du monde physique (voiture, personne, livre, ...).

Cette programmation propose une nouvelle façon de concevoir et de développer des applications, de manière à améliorer :

  1. La structuration du code, afin de mieux pouvoir le comprendre.
  2. La réutilisabilité du code, afin de réduire les coûts de développement.
  3. La robustesse du code, afin de réduire les bugs et les arrêts brutaux des logiciels.

La POO se base sur les notions clés suivantes :

  • Classe et objets
  • Encapsulation
  • Abstraction
  • Héritage
  • Polymorphisme

 

Classe et Objets

 


Une classe est une structure d’un objet,   elle  rassemble les attributs (définissant l’état= « Person a des yeux noir ») et les méthodes (définissant les comportements= « Person marche ») communs d’un ou plusieurs objets.

        
       class Person{
		//Attributs
		public $nom = '';
		public $prenom = '';
		public $adresse = '';

		//Méthodes
		function parler(){
			echo "Je suis en train de parler";
		}
function manger($aliment){ return "je mange de ".$aliment; }
function rename($newName){ $this->nom = $newName;//Modifier l'état d'un objet } }

 Un objet est une entité constituée des données caractérisant cet objet et des traitements s'effectuant sur ces données. Pour créer un objet il faut instancier une classe.

    
    $person = new Person();
    $person1 = new Person();
    $person2 = new Person();

 Pour réinitialisé la valeur d’un attribut, on l’appelle on utilisant l’opérateur d’affectation ->.

        
        $person->nom = 'Ali';
	echo $person->nom;

Un message est une demande d’activation d’une méthode envoyé à un objet.

        
        $person->parler();
	echo $person->manger('pomme');
	$person->remane('Mohamed');
	echo $person->nom;

Par convention les classes doit être définit dans un seul fichier qui porte le nom de la classe(Person.class.php) puis on fait instancier les objets dans un autre fichier php qui fait des traitements sur cet objet (index.php), pour le faire il faut l’inclure  dans ce fichier.

        include(‘Person.class.php’) :

Les includes sont conditionnelles, ils peuvent être placer dans une condition ou une boucle ;

 

       require(‘Person.class.php’) :

Les requires doivent être se trouver toujours en début de script. 

 

C'est généralement un require() que l'on devrait utiliser (pour tout ce qui est librairies ou paramètres globaux). 

 

Bien souvent il est conseillé d'utiliser require_once() et include_once() à la place de require() et include(). La différence avec leur homologue est que le fichier ne sera inclut qu'une seule fois quoi qu'il arrive. 

 

Auto_load

 On  peut définir une fonction __autoload() qui sera automatiquement appelée si on essaye d'utiliser une classe ou interface non déclarée. Grâce à cette fonction, on a une dernière chance pour inclure une définition de classe, avant que PHP n'échoue avec une erreur.

index.php

function __autoload($class){
	require($class.'.class.php');
}
spl_autoload_register('__autoload');

$person = new Person();
$person->nom = 'Ali';
echo $person->nom;
$person->parler();
echo $person->manger('pomme');
$person->remane('Mohamed');
echo $person->nom;

index.php

        Require_once 'Person.class.php';
	$person = new Person();
	$person->nom = 'Ali';
	echo $person->nom;
	$person->parler();
	echo $person->manger('pomme');
	$person->remane('Mohamed');
	echo $person->nom;

Si nous avons plusieurs classes situeés dans défférent dossier, une solution consisite a charger lors de l’appelation d’autoload la classe active en verifiant l’existant de fichier contenant cette classe. Attention : les fichiers doivent porte le même nom de la classe.

index.php

           
function __autoload($class){
	if(file_exists($class.'.class.php')) require_once($class.'.class.php');
	if(file_exists('Poo/'.$class.'.class.php')) require_once '/Poo/'.$class.'.class.php';
}
spl_autoload_register('__autoload');

$person = new Person();
$person->nom = 'Ali';
echo $person->nom;
$person->parler();
echo $person->manger('pomme');
$person->remane('Mohamed');
echo $person->nom; 

$emp = new Employe();//Le fichier contenant cette classe situant dans le dossier poo.

 

Le constructeur

Les parenthèses après la classe lors de l’instanciation présente le constructeur, qui est une fonction sert à construire un objet à partir de cette classe. Le constructeur en php ne supporte pas la surcharge (plusieurs constructeurs avec de nombre de paramètre déférent). Doit être toujours public. Chaque classe à un constructeur (1-N constructeurs dans d’autres langages compilés), même qu’il est n’est pas spécifier.

public __construct(){

} 

Constructeur avec arguments

public function __construct($nom, $prenom, $adresse){
	$this->nom = $nom;
	$this->prenom = $prenom;
	$this->adresse = $adresse;
}

L’instanciation :

$p = new Person('Aliwa', 'Akram', 'Rabat');
echo $p->nom;

static

les attributs (et/ou méthodes) déclarés static sont considérer comme des attributs (méthode) de classe. Ils ne sont pas accessibles à partir d'une instance de classe, mais directement à partir de la définition de la classe elle-même, ils peuvent être consultés directement en utilisant le

 nomClass ::$staticattribut

 

déclaration :

class Person{
	//Attributs
	public static $id = 0;
	public $nom = '';
	public $prenom = '';
}

L’utilisation au sein et à l’extérieur de la classe :

public function __construct($nom, $prenom, $adresse){
	$this->nom = $nom;
	$this->prenom = $prenom;
	$this->adresse = $adresse;
	self::$id ++;
}

Exemple id auto incrémente :

class Person{
	//Attributs
	public static $x = 1;
	public $id = 0;
	...
		
	public function __construct($nom, $prenom, $adresse){
		...
		$this->id = self::$x ++;
        }

Exemple de méthodes :

        
        //POO 7  |  Static Methods
	Class Parle{
		public static function Bonjour(){
			echo 'Bonjour';
		}
		
		public static function AuRevoir(){
			echo 'Au Revoir';
		}
	}
	
        //Sans Instancier la classe on utilise ses méthodes
	Parle::Bonjour();
	Parle::AuRevoir();


Encapsulation

 

L’encapsulation est le fait d’interdiret l’accès aux attributs et méthodes d’un objet de l’extérieur. Les détails de l’implémentation d’un objet sont masqués aux autres objets du système à objets. On dit qu’il y a encapsulation de données et du comportement des objets.

 

On précise trois modes d’accès aux attributs d’un objet.

  •  public avec lequel les attributs seront accessibles directement par l’objet lui même

ou par d’autres objets.

  • private avec lequel les attributs de l’objet seront inaccessibles à partir d’autres

objets : seules les méthodes de l’objet pourront y accéder. Il s’agit du niveau le plus fort de

protection.

  • protected: cette technique de protection est étroitement associée à la notion 

d’héritage (suite du cours).

        
        private static $x = 1;
        private $id = 0;
	private $nom = '';
	private $prenom = '';
	private $adresse = '';

 

Si nous exécutons l’application, une erreur sera produite.

 

Fatal error: Cannot access private property Person::$nom in D:ProgrammeFilesxampphtdocsphp_oopindex.php on line 10

 

Pour accéder aux attributs de cette instance de classe, on doit créer les geters(accesseurs) et seter(modificateur)

 

       class Person{
		//Attributs
		private static $x = 1;
		private $id = 0;
		private $nom = '';
		private $prenom = '';
		private $adresse = '';
		
		public function __construct($nom, $prenom, $adresse){
			...
		}
		//id geter sans seter puisque le id sera auto incrémente
		public function getId() {
                    return $this->id;
                }

                public function getNom() {
                    return $this->nom;
                }

                public function setNom($nom) {
                    $this->nom = $nom;
                }

                public function getPrenom() {
                    return $this->prenom;
                }

                public function setPrenom($prenom) {
                    $this->prenom = $prenom;
                }

                public function getAdresse() {
                    return $this->adresse;
                }

                public function setAdresse($adresse) {
                    $this->adresse = $adresse;
                }

		//Méthodes
		...
	}

 

Modification :

$person->setNom('Ali');

Accessibilité :

echo $person->getNom();

 

Abstraction

 

Les classes qui sont définit abstraite ne peuvent pas être instancier, parce que ces classes sont incomplètes, il ne peut contenir qu'une définition des propriétés et/ou des méthodes sans l’implémentation de ses dernières. Elle sert de base à d'autres classes dérivées (héritées).

 

abstract Class Lecteur{
		protected $nom;
		protected $version;
		
		abstract public function Lancer($morceau);
		
		abstract function Jouer();
		
		abstract function Stoper();
		
	}

 Héritage

 

La notion d’héritage est une relation entre différentes classes permettant de définir une nouvelle classe en se basant sur les classes existantes. On parle d’héritage simple lorsqu’une classe fille ne possède qu’une classe mère.

 

Exemple d’héritage simple.

 

Class LecteurAudio extends Lecteur{
		
		public function __construct($nom){
			$this->nom = $nom;
		}
		
		public function Lancer($morceau){
			echo $this->nom . ' a lancé la lecture de'.$morceau ."
";
		}
		public function Jouer(){
			echo $this->nom . ' est entrain de lire';
		}
		
		public function Stoper(){
			echo $this->nom . ' a arrété la lecture';
		}
	}
	
	Class LecteurVideo extends Lecteur{
		public function __construct($nom, $version){
			$this->nom = $nom;
			$this->version = $vsersion ;
		}
		
		public function Lancer($morceau){
			echo $this->nom . ' a lancé la lecture de'.$morceau;
		}
		public function Jouer(){
			echo $this->nom . ' est entrain de lire';
		}
		
		public function Stoper(){
			echo $this->nom . ' a arrété la lecture';
		}
	}
	
		
	$jr = new LecteurAudio('mp3Player');
	$jr->Lancer('one of million.mp3');
	$jr->Jouer();
	$jr->Stoper();
	
	$fr = new LecteurVideo('VLC', '1.0.1');
	$fr->Lancer('avatar.avi');
	$fr->Jouer();
	$fr->Stoper();

 

L’héritage multiple consiste qu’une classe fille possède plusieurs classes mères. Le php ne supporte pas ce genre d’héritage comme plusieurs langages de programmation.  la difficulté de  l'héritage multiple c’est l’effet que 2 classes mères peuvent avoir une même variable membre ou une même méthode c’est provoquera une conflit en niveau de classe fille.

 

Les interfaces

 

Les interfaces ont été distinguées des classes abstraites qui n'ayant aucune variable membre et ne présentant aucune méthode définie, l'héritage multiple d'interface ne présente pas l'inconvénient du schéma d'héritage classique pour lequel hériter signifie hériter des données et du code de la classe mère.

 

L'héritage d'interface est donc simplement une sorte de contrat d'implémentation

  • L'héritage c'est un lien fort. Mère->Enfant
  • L'interface est un ensemble de fonctionnalités (contrat).


On ne peut hérité que d'une seule classe mère, tandis qu'on peut implémenter plusieurs interfaces.

Exemple de l’héritage d’une classe et l’implémentation de deux classes.

 Nous avons ici la classe WindowsMedia hérite de la classe Lecteur et implémente les deux classe LecteurAudio et LecteurVideo, les instances de cette classe WindowsMedia ont toutes les méthodes de la classe mére « Lecteur » ainsi la redinition des méthodes « enregistrerAudio » et « enregistrerVideo » des interfaces « LecteurAuio » et « LecteurVideo ».

 

Code des différentes classes :

 

Classe lecteur  : 

       
        //Class Mére 
	Class Lecteur{
		protected $enregistrement;
		
		public function Jouer(){
			echo 'Lecture de ' . $this->enregistrement;
		}
		public function Lancer(){
			echo 'Lancer la lecture de ' . $this->enregistrement;
		}
		public function Stoper(){
			echo 'Stoper la lecture de ' . $this->enregistrement;
		}
		public function VolumePlus(){
			echo 'Augmenter le volume ' . $this->enregistrement;
		}
		public function VolumeMoins(){
			echo 'Diminuer le volume ' . $this->enregistrement;
		}
	}

Interface LecteurAudio :

Interface LecteurAudio{
	public function enregistrerAudio();
}

Interface LecteurVideo :

Interface LecteurVideo{
	public function modeSecreen($mode);
}



   
        require_once('Lecteur.class.php');
	require_once('LecteurAudio.interface.php');
	require_once('LecteurVideo.interface.php');
	
	//1.  Class WindowsMedia  hérite de lecteur et implemente l'interface LecteurAudio
	Class WindowsMedia extends Lecteur implements LecteurAudio{
		
		public function __construct($enreg){
			echo 'Windows media est créé ';
			$this->enregistrement = $enreg;
		}
		
		public function enregistrerAudio(){
			echo 'Enrgistrer Audio';
		}
	}
	
	//2.  Class VLC  herite de lecteur et implemente l'interface LecteurAudio ET LecteurVideo
	Class VLC extends Lecteur implements LecteurAudio, LecteurVideo{
		
		public function __construct($enreg){
			echo 'VLC est crée ';
			$this->enregistrement = $enreg;
		}
		
		public function enregistrerAudio(){
			echo 'Enrgistrer Audio';
		}
		
		public function modeSecreen($mode){
			echo 'mode d'affichage ' . $mode;
		}
	}
	
	//3.  Class FLV  herite de lecteur et implemente l'interface LecteurVideo
	Class FLV extends Lecteur implements LecteurVideo{
		public function __constrcuct(){
			echo 'FLV est crée ';
		}
		
		public function modeSecreen($mode){
			echo 'mode d'affichage ' . $mode;
		}
		
	}

Test :

	
        $wm = new WindowsMedia('Sourate_ARRHMANE.mp3');
	$wm->Lancer();
	$wm->Jouer();
	$wm->VolumePlus();
	$wm->VolumeMoins();
	$wm->Stoper();
	$wm->enregistrerAudio();
	
	echo 'Instanciation de VLC';
	//Instanciation de VLC
	$vlc = new VLC('Avatar.flv');
	$vlc->Lancer();
	$vlc->Jouer();
	$vlc->VolumePlus();
	$vlc->VolumeMoins();
	$vlc->Stoper();
	$vlc->modeSecreen('Plein Ecran');




Téléchargement ...