Bonjour,

Voilà j'entends tellement parler de POO et c'ets vrai que ça à l'air d'être vraiment bien que j'aimerais m'y mettre.

Seulement la doc que j'ai déjà ( bouquin pratique de MySQL et PHP de phillippe Rigaux ) est un peu dur dur au chapitre POO. On attaque directement par la class mysql, les templates et les formulaire... bref une page entière de code à chaque exemple. Pour débutter c'est pas idéal.

J'ai cherché un peu sur le net, je n'ai pas trouvé ce que je cherche : Des exemples concrets d'objets relativement simples.

Si quelqun à des liens sur le sujet, des bouts de code...

Tiens : de quoi commencer pour avoir une première idée

Tiens : de quoi commencer pour avoir une première idée

Merci =)
Voilà le type d'exemple qu'il me fallait

Pour voir si j'ai bien compris, j'ai modifié un peu ton code. Je sais pas si j'ai tord ou non, mais je vois l'objet comme ça :
La calculette à des méthode de calcul, additionner, soustraire, etc, mais aussi une méthode indépendante pour afficher le résultat à l'écran. Donc j'ai séparé le calcul et le retour du résultat.

Donc, première question, es-ce-que mon raisonnement est juste ? Utile, ça c'est autre chose, car après tout si on calcul c'est pour avoir une réponse. Mais bon on pourrais imaginer vouloir garder la réponse pour l'afficher plus tard... Je sais pas ?

Deuxième question : Comment je fait pour afficher le résultat maintenant ? Je suis perdu là

Troisième question : $resultat doit t-il être déclaré private ? Je suis pas sur, peut être parce que j'ai pas bien saisi ce point...

<?php
class calculette
{
    private $chiffre1;
    private $chiffre2;
	//private $resultat;

    public function __construct($c1, $c2)
    {
        $this->chiffre1 = $c1;
        $this->chiffre2 = $c2;
		$this->resultat = NULL;
    }
	
    public function addition()
    {
        $resultat = $this->chiffre1 + $this->chiffre2;
    }
	public function AfficherResultat()
    {
        return ($this->$resultat);
    }
}
?>

<?php
$premier = 292;
$second = 4567;

/* Création de l'objet en utilisant "new" */
$operation = new calculette($premier, $second);

/* On va maintenant récupérer la somme en appelant la méthode de classe addition */
$total = $operation->addition();

/* On affiche le résultat */
echo("<p>La somme de ". $premier ." + ". $second ." est égale à ". $total ."</p>\n");
?> 

[/php]

Donc, première question, es-ce-que mon raisonnement est juste ? Utile, ça c'est autre chose, car après tout si on calcul c'est pour avoir une réponse. Mais bon on pourrais imaginer vouloir garder la réponse pour l'afficher plus tard... Je sais pas ?

On pourait effectivement vouloir conserver le résultat, toute bonne calculette propose les fonctions M+/M- justement destiné à cela Donc ton raisonnement est juste à un petit détail près :

public function addition() 
    { 
        $resultat = $this->chiffre1 + $this->chiffre2; 
    } 

Tu stockes ici le total de l'addition dans une nouvelle variable $resultat et non dans la variable memebre de l'objet (en gros il manque quelque chose pour dire à php qu'il s'agit de l'attribut de l'objet instancié et non d'une nouvelle variable )

Deuxième question : Comment je fait pour afficher le résultat maintenant ? Je suis perdu là

Ta méthode addition() ne retournant plus de valeur, il est inutile de récupérer son résultat dans ta variable $total. En revanche, tu as maintenant dans ton objet une méthode qui te retourne ce résultat. Il te suffit donc d'y faire appel (et éventuellement de stocker le résultat dans $total) après avoir fait l'addition pour qu'elle te retourne la valeur attendue

Troisième question : $resultat doit t-il être déclaré private ? Je suis pas sur, peut être parce que j'ai pas bien saisi ce point...

Y a pas vraiment d'obligation, c'est une question de visibilité.
- Les éléments public sont les plus accessibles : si tu déclares ton attribut comme public, n'importe quelle classe ou script peut faire appel à $operation->resultat pour en lire ou en altérer la valeur.
- Les éléments privés sont les moins accessibles, seule la classe peut y accéder. Ainsi seule ta classe Calculette serait capable de le modifier et tu obliges ainsi les autres classes ou scripts qui veulent y accéder à passer par les méthodes public que tu auras défini.

En gros, si elle est public, je peux instancier l'objet et y coller la valeur "TOTO", et faire planter un script qui s'attendra à trouver un nombre. Si elle est privée et que tu m'obliges à passer par une méthode public pour la mettre à jour, alors tu peux ajouter des contrôles dans cette méthode, t'assurant par exemple qu'au final ta valeur sera bien numérique, qu'une chaine n'excedera pas x caractères, qu'une date sera dans tel format, etc.

Bonjour à tous

J'en profite honteusement de ce topic, qui tente d'aborder les bases de la POO, pour me taper l'incruste afin de poser quelques questions fondamentales, existentielles presque, aux spécialistes de la chose... euh... de l'objet je voulais dire

...

Cet exemple de calculette est en tout point significatif d'une des questions que je me pose à propos de l'utilisation de la POO.

En effet, hormis le fait qu'il ne s'agit après tout que d'un exemple pour aborder les bases de la POO, quel intérêt réel de faire une "class" calculette ?

Je m'explique :

Basiquement, lorsqu'on conçois une "class", c'est pour pouvoir instancier un certain nombre d'objets issue d'elle mais qui, chacun, a un rôle, un comportement ou un traitement un peu particulier au sein du programme... autrement dit, chaque objet sera semblable mais pas identique, quelque chose le distinguera forcément de ses acolytes issus pourtant de la même "matrice"... non ?

Or, justement, dans le cadre d'une calculette, ou de tout autre projet similaire, quel intérêt d'avoir plusieurs objets "calculette" ?

Quelle utilité d'avoir les fonctions encpasulées dans une "class", pour ensuite générer un objet d'elle, alors que ces mêmes fonctions peuvent exister librement, dans une structure de type procédural, et remplir exactement le même rôle ?

Bref, dans un cas de figure de ce type, quel sont les avantages indéniables d'utiliser une approche POO plutôt que procédurale ?

...

Et puis, une autre question qui me taraude depuis fort longtemps, est celle liée aux critères nécessaire à remplir pour qu'un développement à la sauce POO soit justifiée...

Autrement dit, devant un projet de développement à concevoir et à réaliser, quels sont les critères absolument incontestables qui justifient que telle ou telle partie du projet doivent être programmés en POO plutôt qu'en procédural ?

Et cette question se pose pour le projet en entier aussi, quand est-ce utile ou nécessaire de coder en POO et pourquoi ?

...

Bref, comme vous le voyez, j'ai encore le plus grand mal à déterminer avec clarté ce que la POO peut apporter et quand il est pertinent à utiliser... si vous aviez le moindre début d'une piste d'un soupçon d'idée de réponse je suis évidemment preneur !

Merci... à+

Donc ton raisonnement est juste à un petit détail près :

public function addition() 
    { 
        $resultat = $this->chiffre1 + $this->chiffre2; 
    } 

Tu stockes ici le total de l'addition dans une nouvelle variable $resultat et non dans la variable memebre de l'objet (en gros il manque quelque chose pour dire à php qu'il s'agit de l'attribut de l'objet instancié et non d'une nouvelle variable )

hum... peut être que c'ets çia qu'il manque ? :

$resultat = NULL;
$operation = new calculette($premier, $second, $resultat); 

Et pour afficher, c'ets peut être simplement ça ?

$total = $operation->addition();
$resultat = $operation->Afficherresultat();

J'ai pas essayé je suis encore au petit dej

@FredoMkb :
Lorsque tu crée une instance de classe, cette instance a ses propriétés et ses méthode. Une instance parallèle aura les mêmes propriétés et les mêmes méthodes, mais chaque instance aura pour les propriétés des valeurs distinctes qui lui sont propres. Tu as effectivement les mêmes méthodes, mais elles seront appelées différemment selon le besoin de l'une ou l'autre instance que tu manipules. En procédural, il te faudrait utiliser des variables dynamiques ce qui est beaucoup moins pratique.

@supercanard :
Dans le code que tu as modifié, il y avait un bon point de départ que tu sembles avoir laissé tomber : une propriété résultat que tu as finalement commentée. Reprenons-le :

<?php
class calculette
{
    private $chiffre1;
    private $chiffre2;
    private $resultat;

    public function __construct($c1, $c2)
    {
        $this->chiffre1 = $c1;
        $this->chiffre2 = $c2;
        $this->resultat = 0;
    }
    
    public function addition()
    {
        $this->resultat = $this->chiffre1 + $this->chiffre2;
    }
    public function AfficherResultat()
    {
        return ($this->$resultat);
    }
}
?>

<?php
$premier = 292;
$second = 4567;

/* Création de l'objet en utilisant "new" */
$operation = new calculette($premier, $second);

/* On va maintenant faire la somme en appelant la méthode de classe addition */
$operation->addition();
$total = $operation->AfficherResultat();

/* On affiche le résultat */
echo("<p>La somme de ". $premier ." + ". $second ." est égale à ". $total ."</p>\n");
?>

Dans la méthode AfficherResultat(), on récupère la valeur de la propriété $resultat : pour que ça marche, on modifie un petit peu la manière de faire dans la méthode addition() : mais ça veut dire que $resultat est une propriété de l'instance, il faut donc la traiter comme telle.

Tu noteras également que la valeur assignée dans le constructeur est modifié : on fait du calcul, donc "NULL" n'est pas approprié. Lorsque tu utilises une calculatrice, sur l'écran est affiché au départ 0, rien d'autre et ce n'est pas vide non plus. Faisons donc pareil avec notre classe calculette.

Vois ensuite comment est modifiée l'utilisation.

Re...

@FredoMkb :
Lorsque tu crée une instance de classe, cette instance a ses propriétés et ses méthode. Une instance parallèle aura les mêmes propriétés et les mêmes méthodes, mais chaque instance aura pour les propriétés des valeurs distinctes qui lui sont propres. Tu as effectivement les mêmes méthodes, mais elles seront appelées différemment selon le besoin de l'une ou l'autre instance que tu manipules. En procédural, il te faudrait utiliser des variables dynamiques ce qui est beaucoup moins pratique.

Merci Cyrano pour ta réponse, mais... tu vas certainement me trouver obtus et/ou pénible, mais j'ai encore du mal à comprendre le vrai intérêt de la chose...

Si je reprends à mon compte l'exemple de calculette, au lieu de faire ceci avec une "class" :

<?php
$premier = 292;
$second = 4567;

/* Création de l'objet en utilisant "new" */
$operation = new calculette($premier, $second);

/* On va maintenant faire la somme en appelant la méthode de classe addition */
$operation->addition();
$total = $operation->AfficherResultat();

/* On affiche le résultat */
echo("<p>La somme de ". $premier ." + ". $second ." est égale à ". $total ."</p>\n");
?>

Je pourrait tout autant faire cela avec une simple fonction :

<<?php
$premier = 292;
$second = 4567;

// Calcul du total avec la fonction 'addition()'
$total = addition($premier, $second);

/* On affiche le résultat */
echo("<p>La somme de ". $premier ." + ". $second ." est égale à ". $total ."</p>\n");
?>

Beaucoup moins de code, et un résultat en tout point identique (pour cet exemple en tout cas)...

Du coup je me demande : ai-je vraiment besoin d'instancier plusieurs objets issues de la "class" calculette ?

Ou plutôt : quand est-ce que j'ai vraiment besoin d'une "class" et des objets ?


Enfin, tu dis, je cite : "En procédural, il te faudrait utiliser des variables dynamiques ce qui est beaucoup moins pratique."

Aurais-tu un petit exemple ?

J'avoue que j'ai un peu de mal à comprendre... désolé, je suis un vrai boulet sur ce coup... je sais

Merci encore... à+

Merci Cyrano
Ca commence à rentrer, du moins les bases... Après le fait que les classes doivent être conçus pour un usage general et qu'il faut en cumuler d'autres spécialisés, ça pour l'instant j'ai du mal à l'imaginer.

Bref, pour approfondir le problème est maintenant de savoir si tout doit être objet... ça j'ai du mal à comprendre.

Tu vois dans mon code j'ai voulu faire un formulaire qui permette de rentrer les deux nombres a calculer et le type de calcul. Seulement, j'ai fait un mélange d'objet et de procedural, car le type de calcul n'est pas une propriété de l'objet, alors qu'il devrait surement l'être je pense. Mais je n'en suis pas sur, ça rejoint une question que je me pose, tout doit-il être objet ?

Imagineons que oui, en gros le switch que j'ai mis dans mon code devrait donc se retrouver dans la class. A première vue je ferrais une simple méthode 'operation' qui pourrait soustraire, additioner, etc, suivant la valeur de $this->type mais je ne suis pas trop sur...

Donc voici mon mélange procéd/objet qui va te faire hurler je pense :

<?php
class calculette
{
    private $chiffre1;
    private $chiffre2;
    private $resultat;

    public function __construct($c1, $c2)
    {
        $this->chiffre1 = $c1;
        $this->chiffre2 = $c2;
        $this->resultat = 0;
    }
    
    public function addition()
    {
        $this->resultat = $this->chiffre1 + $this->chiffre2;
    }
    public function AfficherResultat()
    {
        return ($this->resultat);
    }
}
?>

<?php
if ( isset( $_POST['c1'] ) )
{
	$premier = $_POST['c1'];
	$second = $_POST['c2'];

	/* Création de l'objet en utilisant "new" */
	$operation = new calculette($premier, $second);

	/* On va maintenant faire la somme en appelant la méthode de classe addition */
	switch( $_POST['type'] )
	{
		case '+' :
		$operation->addition();
		break;
		case '-' :
		$operation->soustraction();
	}
	$total = $operation->AfficherResultat();

	/* On affiche le résultat */
	echo("<p>La somme de ". $premier ." + ". $second ." est égale à ". $total ."</p>\n");
}
?>

<form method="post" action="objet3.php">
<input type="text" name="c1" />
<select name="type">
<option value="+">+</option>
<option value="-">-</option>
</select>
<input type="text" name="c2" />
<input type="submit" />
</form>

@FredoMkb :
L'idée de l'objet, c'est par exemple que tu as des séries de données différentes que tu dois traiter en modifiant certaines d'une manière et d'autres d'une autre manière mais dans les deux cas avec le même outil mais en ayant besoin d'un premier résultat de la première instance pour calculer une valeur dont tu as besoin pour la seconde avant de revenir à la première. Par exemple, tu as une série de données sur laquelle tu dois faire une multiplications et l'autre série qui devront être additionnées en incluant un résultat partiel issu des calculs sur la première série : avec deux instances, tu effectues tes calculs indépendamment. Avec deux instances, tu as deux jeux de propriétés avec des valeurs différentes que tu peux croiser sans pour autant perdre les valeurs de l'une pour pouvoir travailler avec l'autre.

@supercanard :
On ne fait pas du pur objet en PHP comme on fait en Java par exemple. Ce n'est pas que ce soit impossible, mais ce n'est pas fait pour ça.

Le but global, c'est d'ajouter au langage lui-même des fonctionnalités qui n'existent pas en natif. Certains me diront qu'on peut le faire en procédural : c'est vrai. Mais l'intérêt de l'objet est en partie dans ce que j'ai expliqué pour FredoMbk ci-dessus

Merci pour les explications

Bon n'empêche qu'avec tes exemples, corrections de code et explications j'ai l'impression d'avoir compris plus facilement qu'avec un bouquin... Alors merci encore

Je vais tenter de me faire un petit objet pour afficher un formulaire sans avoir a taper tout le html (genre label, input, type, etc...) j'espère que je vais y arriver

Je vais essayer de compléter un peu la réponse de Cyrano vis à vis de FredoMkb. En effet, l'objet n'a rien d'une obligation et que tout ce qu'on fera en objet pourra tout aussi bien être fait en procédural (on arrivait très bien à développer avant de voir débarquer les objets ), mais il apporte quand même quelques avantages : ils permettent de modéliser de façon simple et clair un élément de n'importe quel domaine, parce qu'ils sont réutilisables et parce qu'ils garantissent l'intégrité des données.

Oublions la calculette quelques instant. Elle permet de comprendre comment créer un objet, mais pas forcément de voir l'étendu de ce que l'on peut faire avec. Supposons une classe "Véhicule" avec ses attributs (immatriculation, compteur km, couleur, ...) et ses méthodes (démarrer, se garer, faire la vidange, faire le plein...). Chaque instance de cette classe correspond à un véhicule spécifique : une voiture bleue avec 20.000km, une moto rouge avec 50.000km, etc.

Ce qui fait le succès de la POO c'est principalement :

- L'encapsulation : c'est le fait de rassembler les attributs et les méthodes au sein d'un composant (mon Véhicule) en cachant l'implémentation de l'objet. Cela empêche l'accès aux données par un autre moyen que les services proposés, et permet donc de garantir l'intégrité des données contenues dans l'objet. Tu n'as pas besoin de savoir si la voiture instanciée fonctionne au super, au gazoil, ou au gpl, tu lui demandes juste de faire le plein, et moi je serais certain que tu ne te tromperas pas puisque tu n'auras pas directement accès au réservoir (et mine de rien, pour un travail collaboratif, être sur que les autres ne pourront pas se tromper en manipulant tes objets est un plus non négligeable !)

- L'héritage : cela permet de créer une nouvelle classe à partir d'une classe existante, la classe dérivée contient alors les attributs et les méthodes de sa superclasse. L'intérêt est de pouvoir définir de nouveaux attributs et méthodes pour la classe dérivée, qui viennent s'ajouter à ceux et celles héritées. Une "Voiture" et une "Moto" peuvent ainsi hériter des propriétés propre à n'importe quel "Véhicule" (immatriculation, km, ..) et apporter leurs propriétés spécifiques (toit ouvrant pour la voiture, béquille pour la moto, etc.). Une fois encore, en cas de travail collaboratif, si quelqu'un dérive ta classe, tu es sur que ce que toi tu as implémenté sera disponible dans la sienne, a lui de gérer le fait que s'il fait une classe Vélo, elle devra trouver un moyen de faire le plein (ou alors peut être revoir s'il n'est pas plus judicieux de définir cette méthode dans une classe "Véhicule Motorisé" héritant de "Véhicule" )

- Le polymorphisme : c'est le fait de pouvoir surcharger ou redéfinir une méthode. En java un objet peut avoir plusieurs méthodes portant le même nom, mais dont les paramètres diffèrent. Chacune peut alors avoir un fonctionnement différent selon que tu lui passes un entier en paramètre, ou une chaine, etc. sans nécessiter de tests ou de contrôles supplémentaires. En php, le polymorphisme se traduit surtout par la surcharge dans une classe dérivée. Ma "Voiture a essence" qui hérite de "Véhicule" réagira à la commande "faire la plein" en allant à la pompe et en remplissant le réservoir, tandis que ma "Voiture Electrique" ira recharger la batterie en la branchant a une prise electrique. L'intérêt c'est que pour toi, tout cela est entièrement transparent, tout ce que tu as à faire, c'est appeller la méthode "faire le plein" de ton Véhicule quand tu auras détecté qu'il est sur la réserve


Tes objets sont ensuite réutilisable par n'importe qui sur le projet, voire pour d'autre projet (et sans risque d'altérer l'intégrité des données), ils peuvent être appliqués à n'importe quel domaine (pourquoi pas une calculette scientifique qui hériterait des fonctions de base de notre calculette et proposerait également des log ou des exponentielles, surchargeant la fonction addition pour que le calcul se fasse en binaire ou en héxa, etc. )

Pour ma part, je commence à comprendre l'intérêt et le fonctionnement mais seulement en théorie ou alors en pratique sur des choses simples.

Bon j'ai voulu créer un objet pour mettre en pratique. L'idée au départ était de créer un formulaire, mais je n'ai pas réussi, car l'objet en question à comme propriétés des champs, qui ont eux même des propriétés (label, valeur etc... )... alors là je bloque.

Du coup je montre le code, au risque d'abuser, si quelqun se sent de me mettre sur une piste comment créer cet objet formulaire...

Là, je dois dire que tu t'attaques à forte partie. Construire une classe de génération de formulaire est un problème ardu et beaucoup s'y sont cassé les dents avant d'arriver à un système satisfaisant, je parle par expérience personnelle et je ne suis pas le seul dans ce cas ici.

Je te recommande quelque chose de moins complexe : une connexion à un serveur de base de données par exemple avec des méthodes pour exécuter une requête et en récupérer le retour. Ça va te donner de la matière pour te faire la main.

Là, je dois dire que tu t'attaques à forte partie. Construire une classe de génération de formulaire est un problème ardu et beaucoup s'y sont cassé les dents avant d'arriver à un système satisfaisant, je parle par expérience personnelle et je ne suis pas le seul dans ce cas ici.

Je te recommande quelque chose de moins complexe : une connexion à un serveur de base de données par exemple avec des méthodes pour exécuter une requête et en récupérer le retour. Ça va te donner de la matière pour te faire la main.

Oki bon ben alors je vais rester dans les formulaires mais cette fois coté vérification.

Pour l'instant mon objet ne vérifie qu'une seule chose, mais je pourrais y rajouter une vérification de valeurs numériques, de structure d'email, etc..

Avant d'aller plus loin je voudrais jute savoir si je suis bien parti ?

La seule intérogation que j'ai pour l'instant c'est comment faire si au lieu de vérifier tout le tableau $_POST, je ne voulais vérifier seulement les champs que je veut. Il faudrait donc passer les champs en argument dans l'appel de la méthode $VerifForm -> ChampVides();... enfin je crois ^^

<?php
class VerifFormulaire
{
    private $donnees;

	public function __construct( $donnees )
    {
        $this -> donnees = $_POST;
		$this -> NbChampsVides = 0;
		$this -> cle = NULL;
		$this -> valeur = NULL;
		$this -> ErreursForm = NULL;
    }
    
    public function ChampVides()
    {
		foreach( $this -> donnees as $this -> cle => $this -> valeur )
		{
			if ( $this -> valeur == NULL )
			{
				$this -> NbChampsVides++;
			}
		}
    }
	public function AfficherErreurs()
	{
		if ( $this -> NbChampsVides != 0 )
		{
			$this -> ErreursForm .= $this -> NbChampsVides.' champ(s) vide(s)';
		}
		return $this -> ErreursForm;
	}
}
?>

<?php
if ( isset( $_POST['Champ1'] ) )
{
	$VerifForm = new VerifFormulaire( $_POST );
	$VerifForm -> ChampVides();
	$ErreursForm = $VerifForm -> AfficherErreurs();
	echo $ErreursForm;
}
?>

<form method="post" action="form2.php">
<input type="text" name="Champ1" />
<input type="text" name="Champ2" />
<input type="submit" />
</form>