Programmation Orienté Objet

Syntaxe POO PHP

Vous débutez dans l'apprentissage de ce langage en utilisant la POO ? Vous désirez parfaire vos connaissances pour obtenir une bonne base ? Cet article est fait pour vous !

1. Constructeur et destructeur

class Exemple1 // Le polymorphisme n'existe pas en PHP5, il n'est donc pas possible d'avoir plusieurs contrusteurs.
{
	public $maVar;
	function __construct()
	{
		$this->maVar = "7";
		echo "Constructeur déclenché
";
	}
	
	function Function1()
	{
		echo "Exemple Function : ".$this->maVar."
";
	}
	
	function __toString() // Comment doit réagir la classe lorsqu'elle est convertie en chaîne de caractère
	{
		return "ToString";
	}
	
	function __destruct() 
	{
		echo "Destructeur déclenché";
	}
}

	$obj = new Exemple1();
	echo $obj."
"; // Affichera "ToString"
	$obj->Function1(); // Affichera "Exemple Function : 7"
	echo $obj->maVar."
"; // Affichera "7"

2. Portée des membres

class Exemple2 
{
	public function methode1()
	{
		echo "méthode publique, ";
		$this->methode3();
	}
	protected function methode2()
	{
		echo "méthode protégée";
	}	
	private function methode3()
	{
		echo "méthode privée";
	}
}

class Exemple2Fille extends Exemple2 // Héritage
{
	function __construct()
	{
		$this->methode1(); // Affichera "méthode publique, méthode privée"
		$this->methode2(); // Affichera "méthode protégée"
		$this->methode3(); // ERREUR
	}
}


$obj = new Exemple2Fille(); // Création d'une instance

3. Constantes

class MaClasse 
{
    const CONST1 = 'MaConstante';
    public $var1 = 'MaConstante';
}


echo MaClasse::CONST1;

// Une constante n'est pas accessible depuis l'instance d'un objet, mais uniquement dans un context static 
//$inst = new MaClasse();
//echo $inst->$var1;

4. Accesseurs

class MaClasse 
{
    private $propertie;
    private $propertie1;
    private $propertie2;
    private $propertie3;

	function __construct() 
	{
		$this->propertie = "Value1";
    }
	
	function __call($name , $arguments) 
	{
        echo "Vous tentez d'appeler la méthode ".$name." avec les arguments suivants : 
";
		print_r($arguments);
    }
	
	function __get($name) 
	{
		echo "
__get
";
		return $this->$name;
    }
	
	function __set($name, $value) 
	{
		echo "
__set
";
		$this->$name = $value;
    }
}


$obj = new MaClasse();
echo $obj->callFunction(18, "String");
echo $obj->propertie;
$obj->propertie = "newValue";
echo $obj->propertie;

echo $obj->propertie3;
$obj->propertie3 = "newValue";
echo $obj->propertie3;

5. Classe abstraite

abstract class Abstract1
{ 
	public $propertie = "123";
	
	abstract public function Function1();
}

class Exemple4 extends Abstract1 // L'héritage multiple n'existe pas : une classe peut hériter uniquement que d'une seule classe mère
{  
	public function Function1()
	{
		echo "Implémentation du prototype Function1 de la classe abstraite Abstract1
";
	}
}


//$obj = new Abstract1(); // -> ERREUR on ne peut pas instancier une classe abstraite 
$obj = new Exemple4();
$obj->Function1();
echo $obj->propertie;

6. Interface

interface Interface1
{
	//Prototypes des méthodes
	//Aucune propriété ne peut être définie dans une interface
	public function Function1();
	public function Function2();
}

interface Interface2
{
	//public $propertie = "123"; // -> ERREUR une interface ne peut pas contenir de propriété
	
	//Prototypes des méthodes
	//Aucune propriété ne peut être définie dans une interface
	public function Function3();
	public function Function4();
}

class Exemple3 implements Interface1, Interface2 // Il est possible d'implémenter plusieurs intefaces
{
	public function Function1()
	{
		echo "Implémentation du prototype Function1 de l'interface Interface1
";
	}
	
	public function Function2()
	{
		echo "Implémentation du prototype Function2 de l'interface Interface1
";
	}
	public function Function3()
	{
		echo "Implémentation du prototype Function3 de l'interface Interface2
";
	}
	
	public function Function4()
	{
		echo "Implémentation du prototype Function4 de l'interface Interface2
";
	}
}


//$obj = new Interface1(); // -> ERREUR on ne peut pas instancier une interface
$obj = new Exemple3();
$obj->Function1();
$obj->Function2();
$obj->Function3();
$obj->Function4();

7. Static

class MainClass
{
	function ParentFunction($arg)
	{
		echo "ParentFunction de la classe mère avec l'argument : ".$arg."<br?-->";
	}
}

class Exemple extends MainClass
{
	public static $propertie = 1;
	public $propertie2 = "Proriété non static";
			
	static function StaticFunction()
	{
		return self::$propertie;
		//return $this->propertie; // INCORRECT car nous sommes dans un contexte static
	}
	
	function NewFunction()
	{
		parent::ParentFunction($this->propertie2);
		//parent::ParentFunction(self::$propertie2); // INCORRECT car $propertie2 est non static
	}
}

echo "Accès statique : ".Exemple::StaticFunction()."
";
$obj = new Exemple(); 
echo $obj->NewFunction()."
";

8. Final

class Exemple
{
	final public function Function1() 
	{
		echo "Function1 de type final";
	}
}

class ExempleFille extends Exemple
{
	public function Function1()
	{
		echo "Override de la méthode Function1 de la classe Exemple6"; // Interdit
	}
}

9. Clone

class CloneClass
{
	public $propertie;

	function __construct()
	{
		echo "Construct ";
		$this->propertie = 1;
	}
	
	function __clone()
	{
		echo "Clone ";
		$this->propertie=2;
	}
}

$obj = new CloneClass(); 
echo $obj->propertie."
";

$clone = clone $obj;
echo $clone->propertie."
";

10. Exception

class CustomException extends Exception
{
	__construct($Message,$ErrorCode)
	{
		parent::$Message = $Message
	}
}

class ExClass
{
	public function throwException() 
	{
    	throw new CustomException ("Exception déclenchée", 3);
	}
}

$Obj = new ExClass();

try 
{
    $Obj->throwException();
}
catch (Exception $exception) 
{
    echo "Message : ".$exception->getMessage().", Line : ".$exception->getLine().", File : ".$exception->getFile();
}
catch (CustomException $exception) 
{
    echo "Message : ".$exception->getMessage().", Line : ".$exception->getLine().", File : ".$exception->getFile();
}

11. Singleton

class Single 
{
	static $instance;
	private function __construct() 
	{
		// Générera une erreur si appelé grâce au new par l'exterieur car le constructeur est déclaré en private
	}
	static function GetInstance() 
	{
		if (empty(self::$instance)) 
		{
			self::$instance = new Single;  
		}
		return self::$instance;
	}
	
    public function __clone()
    {
        trigger_error("Le clônage n'est pas autorisé", E_USER_ERROR); // On déclenche une erreur car le clonage n'est pas autorisé
    }
}


//$obj = new Single();					  // => ERREUR car constructeur déclaré en private
//$obj = clone Single::GetInstance();	  // => ERREUR car la méthode __clone déclenche une erreur
Single::GetInstance();

12. Autoload

function __autoload($ClassName) 
{
    @require $ClassName.".class.php"; // MaClasse.class.php
}
$obj = new MaClasse();
echo $obj->var1;

13. Serialize

class exempleSerialize
{
	public $var1;
	public $var2;
	
    function __construct()
	{
        $this->var1 = "Value1";
        $this->var2 = 1;
    }
	
	function __sleep()
	{
		return array('var1','var2');
	}

	function __wakeup()
	{
		echo "methode __wakeup
";
	}
}

$exempleSerialize = new exempleSerialize();

echo $exempleSerialize->var1."
";
echo $exempleSerialize->var2."
";
$lin = serialize($exempleSerialize);
echo $lin."
";
$de_lin = unserialize($lin);
echo $de_lin->var1."
";
echo $de_lin->var2."
";

Merci de prendre en compte l'ancienneté de l'article : 2014 soit 6 ans