NFA017 Web coté serveur

cours 4
Programmation objet en PHP

References: PHP.net, Developer.com, KillerPHP, DevX

Pourquoi utiliser des classes et des objects?

• PHP est d'abord un langage procédural
• De petits programmes peuvent s'écrire facilement sans classes ni objects
• Des programmes plus gros, deviennent vite plus compliqué à structurer et à maintenir
• Grouperles données liées et leur comportement dans des objet aide à gérer la taille et la complexité

construir et utiliser des objets

# Construire un objet
$name = new ClassName(parameters);

# acceder au champs d'un objet (si le champs est public)
$name->fieldName

# appeler une méthode
$name->methodName(parameters);

$zip = new ZipArchive();
$zip->open("moviefiles.zip");
$zip->extractTo("images/");
$zip->close();

• Le code suivant unzips un fhichier
• test si une classe est installé avec un test class_exists

Example d'utilisation : récupérer un fichier sur le web

# créer un requête  HTTP pour récupérer le
  fichier  student.php
$req = new HttpRequest("student.php", HttpRequest::METH_GET);
$params = array("first_name" => $fname, "last_name" => $lname);
$req->addPostFields($params);

# envoyer la requête et examiner le résultat
$req->send();
$http_result_code = $req->getResponseCode();   # 200 means OK
print "$http_result_code\n";
print $req->getResponseBody();

• L'objet HttpRequest permet de récupérer un document sur le web

syntaxe de la déclaration d'une classe

class ClassName {
	# champs - donnée dans chaque objet
	public $name;    #champs  public 
	private $name;   # champs private 
	
	# constructeur - creer et initialiser l'object objet
	public function __construct(parameters) {
		instruction(s);
	}
	
	# méthode: comportement (fonction) de l' object
	public function name(parameters) {
		instructions;
	}
}

• Dans le constructor ou dans une methode, utiliser $this fait référence a l'objet courant

Exemple de Classe

<?php
class Point {
	public $x;
	public $y;
	
	# Equivalent du constructeur  Java
	public function __construct($x, $y) {
		$this->x = $x;
		$this->y = $y;
	}
	
	public function distance($p) {
		$dx = $this->x - $p->x;
		$dy = $this->y - $p->y;
		return sqrt($dx * $dx + $dy * $dy);
	}
	
	# Equivalent à la méthode Java : toString
	public function __toString() {
		return "(" . $this->x . ", " . $this->y . ")";
	}
}
?>

Exemple d'utilisation de classe

<?php
# Ce code peut être
  dans un fichier fichier nommé  use_point.php
include("Point.php");

$p1 = new Point(0, 0);
$p2 = new Point(4, 3);
print "La distance entre $p1 et $p2 est " . $p1->distance($p2) . "\n\n";

var_dump($p2);   # var_dump affiche un
  descriptif détailler de l'objet (Pour débuguer)
?>

La distance entre  (0, 0) et (4, 3) est 5

object(Point)[2]
  public 'x' => int 4
  public 'y' => int 3

• $p1 et $p2 sont des references aux object Point

Heritage(basique)

class ClassName extends ClassName {
	...
}

class Point3D extends Point {
	public $z;
	
	public function __construct($x, $y, $z) {
		parent::__construct($x, $y);
		$this->z = $z;
	}
	
	...
}

• La classe va heriter toute les donnée et les methode de ClassName

Static

static $name = value;    #
  declaration d'un champs static 
const $name = value;     #
  declaration d'une constante static

# déclaration d'une constante statique
public static function name(parameters) {
	instructions;
}

ClassName::methodName(parameters);  #
  appel d'une méthode static (en dehors de la classe)
self::methodName(parameters);       #appel
  d'une methode statique (dans la classe)

• champs et méthodes static sont partagé a travers la classe et non repliqué dans chaque objet

classes abstraite et interfaces

interface InterfaceName {
	public function name(parameters);
	public function name(parameters);
	...
}

class ClassName implements InterfaceName { ...

abstract class ClassName {
	abstract public function name(parameters);
	...
}

• Les interfaces sont des "supertypes" qui specifient/déclarent les methodes sans implementations
  • ne peuvent etre instanciées ; ne peuvent contenir de le corps d'une fonction ou des champs
  • permette le polymorphisme entre "sous-type" sans partage de l'implementation du code.
• Les classes abstraite sont comme les interfaces, mais contenir de le corps d'une fonction ou des champs
  • bien que ne puissant être instancié permettre le polymorphisme avec partage de code.