Différences entre les versions de « Programmation PHP/Programmation orientée objet »

aucun résumé de modification
 
<source lang="php">
class parent1 {
{
var $varParent;
var $varParent;
 
function méthodeParente() {
{
print 'Je connais méthodeParente' . PHP_EOL;
print 'Je connais méthodeParente' . PHP_EOL;
}
}
}
 
class enfant extends parent1 {
{
var $varEnfant;
var $varEnfant;
 
function méthodeEnfant() {
{
print 'Je connais méthodeEnfant' . PHP_EOL;
print 'Je connais méthodeEnfant' . PHP_EOL;
}
}
}
 
On peut aussi invoquer les méthodes parentes depuis la classe enfant :
<source lang="php">
class enfant2 extends parent1 {
{
var $varEnfant;
var $varEnfant;
 
function méthodeEnfant() {
{
parent::méthodeParente();
parent::méthodeParente();
print 'Je connais méthodeEnfant2' . PHP_EOL;
print 'Je connais méthodeEnfant2' . PHP_EOL;
}
}
}
 
trait MonTrait1
{
function Hello() {
print 'Hello';
}
}
}
 
trait MonTrait2
{
function World() {
print 'World';
}
}
}
 
class MaClasse1
{
use MonTrait1;
use MonTrait2;
 
function __construct() {
$this->Hello();
$this->World();
}
}
}
 
Voici un exemple de {{w|classe abstraite}} :
<source lang=php>
class abstract MaClasseAbstraite {
{
public $var="Bonjour";
abstract public function MaMethode($var1, $var2)var="Bonjour";
abstract public function MaMethode($var1, $var2);
}
</source>
interface MonInterface
{
public function setName($name);
public function getName();
}
</source>
class MaClasse implements MonInterface
{
private $myName;
 
public function setName($name){
{
print 'Définition de '.$name;
$myName = print 'Définition de '.$name;
$myName = $name;
}
}
 
public function getName(){
print 'Récupération de '.$myName;
}
}
</source>
class CompteEnBanque
{
private $argent = 0;
 
private function ajouterArgent($valeur)
private $argent = 0;
{
$this->argent += $valeur;
}
 
private function ajouterArgentgagnerArgent($valeur)
{
$this->argent += ajouterArgent($valeur);
}
 
function gagnerArgent($valeur)
{
$this->ajouterArgent($valeur);
}
}
 
class Humain
{
public $homme = false;
public $femme = false;
 
function __construct($type)
{
if ($type=="homme")
$this->homme=true;
if ($type=="femme")
$this->femme=true;
}
 
function extremeOnction()
{
echo 'Amen';
}
 
 
function __destruct()
function __destruct()
{
{
$this->extremeOnction();
$this->extremeOnction();
}
}
 
}
$homme = new Humain("homme");
 
if ($homme->homme) {
echo "C'est un homme";
{
} elseif ($homme->femme) {
echo "C'est un homme";
echo "C'est une femme";
}
elseif ($homme->femme)
{
echo "C'est une femme";
}
 
La méthode <code>__call()</code> s'exécute quand une méthode appelée est inaccessible ou inexistante. Exemple :
<source lang="php">
function __call($method,$arguments) {
{
echo "On a appelé $method sans succès avec les paramètres :<br/>";
echo "On a appelé $method sans succès avec les paramètres :<br/>";
var_dump($arguments);
var_dump($arguments);
}
}
</source>
 
 
<source lang="php">
class test {
{
public $a;
private public $ba;
private $b;
 
function __construct($a,$b) {
{
$this->a=$a;
$this->ba=$ba;
$this->b=$b;
}
}
 
function __get($nom) {
{
echo "On a appelé __get(\$$nom)";
echo "On a appelé __get(\$$nom)";
}
}
}
 
Exemple de réécriture de la méthode <code>__get</code> ci-dessus pour accéder à la variable privée :
<source lang="php">
function __get($nom) {
{
if ($nom == 'b') { echo $this->b; }
if ($nom == 'b') {
echo $this->b;
}
}
</source>
 
<source lang="php">
class test2 {
{
public $a;
private public $ba;
private $b;
function __construct($a,$b) {
 
$this->a=$a;
function __construct($a,$b)
$this->b=$b;
} {
$this->a=$a;
function __get($nom) {
$this->b=$b;
echo 'get '.$nom;echo '<br/>';
}
 
function __set($nom,$value) {
function __get($nom)
echo 'set '.$nom.' '.$value;echo '<br/>';
} {
echo 'get '.$nom;echo '<br/>';
}
 
function __set($nom,$value)
{
echo 'set '.$nom.' '.$value;echo '<br/>';
}
}
 
<source lang=php>
<?php
function __autoload($ClasseDistante) {
{
throw new Exception($ClasseDistante . ' est introuvable !');
throw new Exception($ClasseDistante . ' est introuvable !');
}
 
try {
$ClasseDistante1 = new ClasseDistante();
} catch (Exception $ex) {
echo $ex->getMessage(), "<br/>";
}
 
try {
$ClasseDistante2 = ClasseDistante::MethodeStatique();
} catch (Exception $ex) {
echo $ex->getMessage(), "<br/>";
}
?>
 
<source lang="php">
if( (class_exists('maClasse'))
$var = new maClasse();
</source>
 
Assurent la transformation du flux de données, en précisant les types des variables et index des tableaux. Exemple :
<source lang=php>
$Hello = 'Hello World';
var_dump($Hello); // string(11) "Hello World"
$Hello = serialize($Hello);
print $Hello; // s:11:"Hello World";
 
$Hello = array('Hello', 'World');
var_dump($Hello); // array(2) { [0]=> string(5) "Hello" [1]=> string(5) "World" }
$Hello = serialize($Hello);
print $Hello; // a:2:{i:0;s:5:"Hello";i:1;s:5:"World";}
</source>