PHP对象编程基础与实践

需积分: 7 198 浏览量更新于2024-07-26 收藏 5.45MB PDF 举报

"site du zero La programmation orientée objet en PHP" 在编程领域，面向对象编程（Object-Oriented Programming，简称OOP）是一种强大的设计和实现软件的方式，它被广泛应用于许多编程语言中，包括PHP。这篇由Victor Thuillier(vyk12)编写的资源，"site du zero La programmation orientée objet en PHP"是关于如何在PHP中应用面向对象编程的教程，旨在帮助初学者理解并掌握这一核心概念。面向对象编程的基本思想是将数据和操作这些数据的方法封装在一起，形成一个独立的对象。在PHP中，这主要通过定义类（Class）来实现。类是创建对象的蓝图，它包含了属性（Attributes，即对象的状态）和方法（Methods，即对象的行为）。首先，了解面向对象编程的基础是必要的。在传统的过程化编程中，程序是按照一系列步骤来执行的，而在面向对象编程中，程序是由相互协作的对象组成的网络。OOP引入了类的概念，允许开发者将相关的数据和行为打包，使其易于管理和重用。教程通过一个简单的"Personnage"（人物）类示例，展示了如何创建一个类。在这个例子中，类包含了一些属性，如名字、生命值等，并定义了相应的方法，如攻击、防御等。这有助于解释封装的概念，即隐藏对象内部的实现细节，只暴露必要的接口给外部世界。在PHP中，创建一个类需要使用关键字"class"，接着是类名，然后是一系列属性和方法的定义。属性的可见性可以通过访问控制修饰符来设定，如public、private和protected，分别表示对象外部、仅限类内部和子类可访问。方法的定义类似于函数，但属于类的一部分。创建对象（实例化）是通过new关键字来完成的，然后可以调用对象的方法或访问其属性。例如，创建一个Personnage对象并设置其属性，或者调用其方法来执行特定动作。为了更好地利用类，有时需要为对象提供特殊的方法，如构造函数（Constructor），它在对象创建时自动执行，通常用于初始化属性。另外，PHP支持类的自动加载，通过spl_autoload_register()函数可以实现，这样就不需要在代码中显式地包含每个类文件。此外，还提到了访问器（Accessors）和 mutators（Mutators）。访问器用于获取对象的属性值，而mutators则用来设置属性值。它们提供了一种控制对对象状态修改的手段，确保了数据的完整性。 "site du zero La programmation orientée objet en PHP"这个资源深入浅出地介绍了PHP中的面向对象编程，涵盖了从基础概念到实际应用的各种要素，对于希望学习或提升PHP OOP技能的人来说，是一个非常有价值的参考资料。

Pour répondre à cette question, il faut savoir sur quel objet est appelée la méthode. En effet, souvenez-vous que $this est une

variable représentant l'objet à partir duquel on a appelé la méthode. Dans notre cas, on a appelé la méthode frapper() à partir

du personnage qui frappe, donc $this représente le personnage qui frappe.

L'instruction contenue dans la méthode signifie donc « ajoute la valeur de la force du personnage qui frappe à l'attribut

$_degats du personnage frappé ».

Maintenant, nous pouvons créer une sorte de petite mise en scène qui fait interagir nos personnages. Par exemple, nous

pouvons créer un script qui fait combattre les personnages. Le personnage 1 frapperait le personnage 2 puis gagnerait de

l'expérience, puis le personnage 2 frapperait le personnage 1 et gagnerait de l'expérience. Procédez étape par étape :

Créez deux personnages ;

Faites frapper le personnage 1 ;

Faites gagner de l'expérience au personnage 1 ;

Faites frapper le personnage 2 ;

Faites gagner de l'expérience au personnage 2.

Ce script n'est qu'une suite d'appels de méthodes. Chaque puce (sauf la première) correspond à l'appel d'une méthode, ce que

vous savez faire. En conclusion, vous êtes apte à créer ce petit script ! Voici la correction :

Code : PHP

<?php

$perso1 = new Personnage(); // Un premier personnage

$perso2 = new Personnage(); // Un second personnage

$perso1->frapper ($perso2); // $perso1 frappe $perso2

$perso1->gagnerExperience(); // $perso1 gagne de l'expérience

$perso2->frapper ($perso1); // $perso2 frappe $perso1

$perso2->gagnerExperience(); // $perso2 gagne de l'expérience

Cependant, un petit problème se pose. Puisqu'à la base, les deux personnages ont le même niveau de dégâts, la même expérience

et la même force, ils seront à la fin toujours égaux. Pour pallier ce problème, il faudrait pouvoir assigner des valeurs spécifiques

aux deux personnages, afin que le combat puisse se différencier. Or, vous ne pouvez pas accéder aux attributs en-dehors de la

classe ! Pour savoir comment pallier à ce problème, je vais vous apprendre deux nouveaux mots : accesseur et mutateur. Mais

avant, j'aimerais faire une petite parenthèse.

Exiger des objets en paramètre

Reprenons l'exemple du code auquel nous sommes arrivés, et concentrons-nous sur la méthode frapper(). Celle-ci accepte un

argument : un personnage à frapper. Cependant, qu'est-ce qui vous garantit qu'on vous passe un personnage à frapper ? On

pourrait très bien passer un argument complètement différent, comme un nombre par exemple :

Code : PHP

<?php

$perso = new Personnage();

$perso->frapper(42);

Et là, qu'est-ce qui se passe ? Une erreur est générée, car à l'intérieur de la méthode frapper(), nous essayons d'appeler une

méthode sur le paramètre qui n'est pas un objet. C'est comme si on avait fait ça :

Code : PHP

<?php

$persoAFrapper = 42;

$persoAFrapper->_degats += 50; // Le nombre 50 est arbitraire,

il est censé représenter une force

Partie 1 : [Théorie] Les bases de la POO 16/319

www.siteduzero.com

Ce qui n'a aucun sens. Il faut donc s'assurer que le paramètre passé est bien un personnage, sinon PHP arrête tout et n'exécute

pas la méthode. Pour cela, il suffit d'ajouter un seul mot : le nom de la classe dont le paramètre doit être un objet. Dans notre cas,

si le paramètre doit être un objet de type Personnage, alors il faudra ajouter le mot-clé Personnage, juste avant le nom du

paramètre, comme ça :

Code : PHP

<?php

class Personnage

{

// ...

public function frapper(Personnage $persoAFrapper)

{

// ...

}

Grâce à ce mot-clé, vous êtes sûr que la méthode frapper() ne sera exécutée que si le paramètre passé est de type Personnage,

sinon PHP interrompt tout le script. Vous pouvez donc appeler les méthodes de l'objet sans crainte qu'un autre type de variable

soit passé en paramètre.

Le type de la variable à spécifier doit obligatoirement être un nom de classe ou alors un tableau. Si vous voulez exiger

un tableau, faites précéder le nom du paramètre devant être un tableau du mot-clé array comme ceci :

public function frapper(array $coups) par exemple. Vous ne pouvez pas exiger autre chose : par

exemple, il est impossible d'exiger un nombre entier ou une chaine de caractères de cette façon.

Les accesseurs et mutateurs

Comme vous le savez, le principe d'encapsulation nous empêche d'accéder directement aux attributs de notre objets puisqu'ils

sont privés : seule la classe peut les lire et les modifier. Par conséquent, si vous voulez récupérer un attribut, il va falloir le

demander à la classe, de même si vous voulez les modifier.

Accéder à un attribut : l'accesseur

À votre avis, comment peut-on faire pour récupérer la valeur d'un attribut ? La solution est simple : nous allons implémenter des

méthodes dont le seul rôle sera de nous donner l'attribut qu'on leur demande ! Ces méthodes ont un nom bien spécial : ce sont

des accesseurs (ou getters). Par convention, ces méthodes portent le même nom que l'attribut dont elle renvoie la valeur. Par

exemple, voici la liste des accesseurs de notre classe Personnage :

Code : PHP

<?php

class Personnage

{

private $_force;

private $_experience;

private $_degats;

public function frapper(Personnage $persoAFrapper)

{

$persoAFrapper->_degats += $this->_force;

}

public function gagnerExperience()

{

$this->_experience += $this->_experience;

}

// Ceci est la méthode degats() : elle se charge de

renvoyer le contenu de l'attribut $_degats

public function degats()

{

return $this->_degats;

Partie 1 : [Théorie] Les bases de la POO 17/319

www.siteduzero.com

}

// Ceci est la méthode force() : elle se charge de renvoyer

le contenu de l'attribut $_force

public function force()

{

return $this->_force;

}

// Ceci est la méthode experience() : elle se charge de

renvoyer le contenu de l'attribut $_experience

public function experience()

{

return $this->_experience;

}

Modifier la valeur d'un attribut : les mutateurs

Maintenant, comment cela se passe-t-il si vous voulez modifier un attribut ? Encore une fois, il va falloir que vous demandiez à la

classe de le faire pour vous. Je vous rappelle que le principe d'encapsulation est là pour vous empêcher d'assigner un mauvais

type de valeur à un attribut : si vous demandez à votre classe de le faire, ce risque est enlevé, car la classe contrôle la valeur des

attributs. Comme vous l'aurez peut-être deviné, ce sera par le biais de méthodes que l'on demandera à notre classe de modifier tel

attribut. La classe doit impérativement contrôler la valeur afin d'assurer son intégrité, car si elle ne le fait pas, on pourra passer

n'importe quelle valeur à la classe et le principe d'encapsulation n'est plus respecté ! Ces méthodes ont aussi un nom spécial : il

s'agit de mutateurs (ou setters). Ces méthodes sont de la forme setNomDeLAttribut(). Voici la liste des mutateurs (ajoutée à la

liste des accesseurs) de notre classe Personnage :

Code : PHP

<?php

class Personnage

{

private $_force;

private $_experience;

private $_degats;

public function frapper(Personnage $persoAFrapper)

{

$persoAFrapper->_degats += $this->_force;

}

public function gagnerExperience()

{

$this->_experience += $this->_experience;

}

// Mutateur chargé de modifier l'attribut $_force

public function setForce($force)

{

if (!is_int($force)) // S'il ne s'agit pas d'un nombre

entier

{

trigger_error('La force d\'un personnage doit être

un nombre entier', E_USER_WARNING);

return;

}

if ($force > 100) // On vérifie bien qu'on ne souhaite

pas assigner une valeur supérieure à 100

{

trigger_error('La force d\'un personnage ne peut

dépasser 100', E_USER_WARNING);

return;

}

Partie 1 : [Théorie] Les bases de la POO 18/319

www.siteduzero.com

$this->_force = $force;

}

// Mutateur chargé de modifier l'attribut $_experience

public function setExperience($experience)

{

if (!is_int($experience)) // S'il ne s'agit pas d'un

nombre entier

{

trigger_error('L\'expérience d\'un personnage doit

être un nombre entier', E_USER_WARNING);

return;

}

if ($experience > 100) // On vérifie bien qu'on ne

souhaite pas assigner une valeur supérieure à 100

{

trigger_error('L\'expérience d\'un personnage ne

peut dépasser 100', E_USER_WARNING);

return;

}

$this->_experience = $experience;

}

// Ceci est la méthode degats() : elle se charge de

renvoyer le contenu de l'attribut $_degats

public function degats()

{

return $this->_degats;

}

// Ceci est la méthode force() : elle se charge de renvoyer

le contenu de l'attribut $_force

public function force()

{

return $this->_force;

}

// Ceci est la méthode experience() : elle se charge de

renvoyer le contenu de l'attribut $_experience

public function experience()

{

return $this->_experience;

}

Voilà ce que j'avais à dire concernant ces accesseurs et mutateurs. Retenez bien ces définitions, vous les trouverez dans la

plupart des classes que vous trouverez !

Retour sur notre script de combat

Maintenant que nous avons vu ce qu'étaient des accesseurs et des mutateurs, nous pouvons améliorer notre script de combat.

Pour commencer, je vais vous demander d'afficher, à la fin du script, la force, l'expérience et le niveau de dégâts de chaque

personnage.

Voici la correction :

Code : PHP

<?php

$perso1 = new Personnage(); // Un premier personnage

$perso2 = new Personnage(); // Un second personnage

Partie 1 : [Théorie] Les bases de la POO 19/319

www.siteduzero.com

$perso1->frapper ($perso2); // $perso1 frappe $perso2

$perso1->gagnerExperience(); // $perso1 gagne de l'expérience

$perso2->frapper ($perso1); // $perso2 frappe $perso1

$perso2->gagnerExperience(); // $perso2 gagne de l'expérience

echo 'Le personnage 1 a ', $perso1->force(), ' de force,

contrairement au deuxième personnage qui a ', $perso2->force(), ' de

force. ';

echo 'Le personnage 1 a ', $perso1->experience(), '

d\'expérience, contrairement au deuxième personnage qui a ',

$perso2->experience(), ' d\'expérience. ';

echo 'Le personnage 1 a ', $perso1->degats(), ' de dégâts,

contrairement au deuxième personnage qui a ', $perso2->degats(), '

de dégâts. ';

Comme nous l'avions dit, les valeurs finales des deux personnages sont identiques. Pour pallier ce problème, nous allons

modifier, juste après la création des personnages, la valeur de la force et de l'expérience des deux personnages. Vous pouvez par

exemple favoriser un personnage en lui donnant une grande force et une grande expérience comparé au deuxième.

Voici la correction que je vous propose (peu importe les valeurs que vous avez choisies, l'essentiel est que vous ayez appelé les

bonnes méthodes) :

Code : PHP

<?php

$perso1 = new Personnage(); // Un premier personnage

$perso2 = new Personnage(); // Un second personnage

$perso1->setForce (10);

$perso1->setExperience (2);

$perso2->setForce (90);

$perso2->setExperience (58);

$perso1->frapper ($perso2); // $perso1 frappe $perso2

$perso1->gagnerExperience(); // $perso1 gagne de l'expérience

$perso2->frapper ($perso1); // $perso2 frappe $perso1

$perso2->gagnerExperience(); // $perso2 gagne de l'expérience

echo 'Le personnage 1 a ', $perso1->force(), ' de force,

contrairement au deuxième personnage qui a ', $perso2->force(), ' de

force. ';

echo 'Le personnage 1 a ', $perso1->experience(), '

d\'expérience, contrairement au deuxième personnage qui a ',

$perso2->experience(), ' d\'expérience. ';

echo 'Le personnage 1 a ', $perso1->degats(), ' de dégâts,

contrairement au deuxième personnage qui a ', $perso2->degats(), '

de dégâts. ';

Ce qui affichera :

Citation : Résultat

Le personnage 1 a 10 de force, contrairement au deuxième personnage qui a 90 de force.

Le personnage 1 a 3 d'expérience, contrairement au deuxième personnage qui a 59 d'expérience.

Le personnage 1 a 90 de dégâts, contrairement au deuxième personnage qui a 10 de dégâts.

Comme vous le voyez à la fin, les deux personnages n'ont plus les mêmes caractéristiques !

Partie 1 : [Théorie] Les bases de la POO 20/319

www.siteduzero.com

剩余317页未读，继续阅读

Niyigena1

粉丝: 0
资源: 3

PHP对象编程基础与实践

Programmation_Orientée_Objet_Java_2020-2021_java_Java_OOP_

Optimisation et analyse numérique-Partie 1 : Éléments d'analyse numérique

rhino grasshoper平面线生造型.gh

Webapp_rimw_ebapp协助投资者评估A股上市公司.zip

Linux笔记1111

CentOS批量自动化修改服务器等保基线操作脚本

rhino grasshoper 柜 组合 系列.gh

基于百川7b的开源多模态大语言模型.zip

电信产品运营-基础业务增减PVC业务操作流程.doc

毕业设计论文SpringBoot智能排课系统.docx

最新资源

rhino grasshoper 柜组合系列.gh