Bonjour.

Je fais des progrès en php mais ce n'est pas encore ca.
Bon je voulais savoir comment s'y prendre si on veut utiliser l'attribut d'une autre classe ou un objet dans une autre classe.
Par exemple:-une classe utilisateur
-une classe article.

Je pose un article donc j'utilise un objet de classe article cependant comment je fais quand je veux utiliser par exemple le nom de l'utilisateur pour dire qui a posté ce message.

Merci d'avance.

Tu peux par exemple avoir dans ta classe un attribut privé $authorId, et une méthode getAuthorInformations(), qui renverra une instance de ta classe utilisateur a laquelle ta méthode aura passé $this->authorId en paramétre lors de l'instanciation de la classe.
Ex:

<?php
class utilisateur {
	public function __construct($userId) {
		//récuperation des informations concernant l'utilisateur
	}
	/**
	 * Something else
	 */
}
class article {
	private $authorId = null;
	/**
	 * Something else
	 */
	public function getAuthorInformations() {
		return new utilisateur($this->authorId);
	}
	/**
	 * Maybe something else again
	 */
}

$article = new article($articleId);
$articleAuthorInformation = $article->getAuthorInformations();

Salut ,

Si ton utilisateur est déjà instancié en amon , tu peux aussi simplement passer la ressource en paramétre à une méthode te ta classe article .

L'objet sera passé automatiquement par référence ( depuis PHP5 ) .

class Utilisateur{

     private $_nom = null;

     private $_prenom = null;



    //Accesseurs
    public function set_nom( $value = null ){

         if( $value != null ){

              $this->_nom = $value;

         }

     }


     public function set_prenom ( $value = null ){
   
        if( $value != null ){

             $this->_prenom = $value;

        } 
  
     }


    /*
    *  Retourne l'utilisateur courant
    */
    public function quiSuisJe(){
 
         echo "Je suis l'utilisateur $nom $prénom .";

    }

    ... 

}

class Article{


     public function a_ui_est_article( $utilisateur = null ){

          if( $utilisateur != null ){

               $utilisateur->quiSuisJe();     

          }else{

               //gestion d'exception ... 
 
          }

     }

}

Tu peux donc faire ceci :

$p_utilisateur = new Utilisateur();

$p_utilisateur->set_nom( "Moulin" );
$p_utilisateur->set_prenom( "jean" );

$p_article = new Article();
$p_article->a_ui_est_article( $p_utilisateur );

Ce qui va afficher :
Bonne continuation
Ch.

Hello,

...

//...
public function quiSuisJe(){
    echo "Je suis l'utilisateur $this->_nom $this->_prenom .";
}
//...

...

Bien que la méthodologie soit juste, il y a cependant une petite erreur que je me permets de rectifier.

Bonne journée à vous

Merci de l'aide.
Une petite question encore.
A quoi sert vraiment les getters et les setters?

C'est pour mieux atomiser le code, rendre les choses plus claires et plus indépendantes.

Effectivement c'est une question qui se pose naturellement lorsqu'on vient du procédural et que l'on a tendance à faire un code le plus concis possible.

Ici c'est plus verbeux mais finalement on y gagne en maintenance et en facilité de programmation.

Pour donner un exemple moins atomisé et en reprenant l'exemple de stopher on pourrait regrouper les setter dans la construction de la classe Utilisateur

class Utilisateur 
{
     private $_nom = null;

     private $_prenom = null;

     public function __construct($nom = null, $prenom = null)

    {
     if( $nom != null )  $this->_nom = $nom;
     if( $prenom != null )  $this->_prenom = $prenom;
    }


    public function quiSuisJe()
    {
     echo "Je suis l'utilisateur $this->_nom $this->_prenom .";
    }
 }



class Article{

     public function a_qui_est_article( $utilisateur = null ){

          if( $utilisateur != null ){

               $utilisateur->quiSuisJe();    

          }else{

               //gestion d'exception ...
          }
     }

}

$p_utilisateur = new Utilisateur('Moulin','Jean');

$p_article = new Article();

$p_article->a_qui_est_article( $p_utilisateur );

On fait exactement les mêmes contrôles que précédemment mais ne serait-ce que quand je déclare ma classe new Utilisateur, il faut que je sache dans quel ordre renseigner les paramètres -> mon exemple est moins facile à utiliser .

Et si je dois rajouter des paramètres (age, sexe, téléphone etc.) on voit qu'il y a plus de simplicité à le faire avec un setter spécifique pour chaque paramètre -> mon exemple est moins facile à faire évoluer .

Idem si chaque paramètre doit faire l'objet d'un contrôle spécifique, le fait de lui attribuer une fonction spécifique rend les choses plus claires.

Merci de l'aide.
Une petite question encore.
A quoi sert vraiment les getters et les setters?

Un énorme avantage des getters et setters en tant que méthode est qu'on a une plus forte abstraction. Qui dit abstraction, dit maintenance et flexibilité accrues. Pourquoi ?

Pour la maintenance, c'est facile. Si tu changes la structure de tes données, tu as juste à réécrire deux méthodes pour résoudre tous les problèmes de compatibilités et de dépendances. On n'accède pas directement à la donnée, mais à travers des méthodes, c'est ça l'astuce.

Pour la flexibilité (et la modularité), c'est moins évident à comprendre mais pas innaccessible. Imagine deux classes ; tu peux créer un héritage et donc des surcharges. Les classes enfants peuvent définir un tout autre comportement pour ces méthodes, mais ça reste invisible à l'utilisateur. Ça peut souvent te sauver la vie quand tu as des encapsulations de classes peu courantes. Mais pour l'utilisateur, rien ne change : il reste avec ses deux méthodes.

L'abstraction est une des plus grandes forces du paradigme objet. N'hésitez pas à en abuser !

L'abstraction est une des plus grandes forces du paradigme objet. N'hésitez pas à en abuser !

La philosophie aussi

La philosophie est une des grandes forces du paradigme objet ?

On peut trouver des points communs dans la mesure où en philosophie tu peux abstraire un objet de son contexte pour créer un univers de réflexion

Uè, sauf que nous c'est concret (… … oui, l'abstrait est concret ici ).

Hywan, faudrait l'appeler Prof.

mouarf.

Donc si j'ai bien tout compris si j'ai besoin d'un attribut d'une classe pour une méthode d'une autre classe,
j'utilise les setters si je dois modifier la valeur ou lui en donner une. Par contre si j'ai besoin de la valeur
d'un attribut j'utilise un getter.

J'ai fait deux classes:
-une connexion (PDO)
-une article.

<?php
/*classe de connexion*/
class Connexion{

	private $PARAM_hote; 
	private $PARAM_port;
	private $PARAM_nom_bd; 
	private $PARAM_utilisateur;
	private $PARAM_mdp;
	
	public function __construct($PARAM_hote, $PARAM_port, $PARAM_nom_bd, $PARAM_utilisateur, $PARAM_mdp)
		{
			$this->PARAM_hote=$PARAM_hote;
			$this->PARAM_port=$PARAM_port;
			$this->PARAM_nom_bd=$PARAM_nom_bd;
			$this->PARAM_utilisateur=$PARAM_utilisateur;
		}
		
	public function connexion($PARAM_hote, $PARAM_port, $PARAM_nom_bd, $PARAM_utilisateur, $PARAM_mdp)
		{
			try
				{
					$connexion=new PDO('mysql:host='.$PARAM_hote.';port='.$PARAM_port.';dbname='.$PARAM_nom_bd, $PARAM_utilisateur, $PARAM_mot_passe);
				}
			catch(Exception $e)
				{
					echo "une erreur de connexion est apparue";
					die();
				}
			
		}
}
?>

Je devrais utiliser cette méthode dans la classe article comme certains me l'ont expliqué comme stopher l'a fait?
Pour initialiser les attributs j'utilise les setters getters? Si oui dans la classe?[/color]

J'ai fait deux classes:
-une connexion (PDO)
-une article.

Habituellement on a plutôt l'habitude d'utiliser un singleton pour établir une connexion à une bdd.
C'est plus souple d'emploi, tu pourras l'appeler de n'importe où sans avoir à te soucier de l'interaction avec tes autres classes.
On en parlait ici il y a peu de temps php-oriente-objet/portee-global-connexion-t248818.html avec des exemples.

Uè, sauf que nous c'est concret (… … oui, l'abstrait est concret ici ).

Un discours théorique sans exemple à la clé reste souvent très abstrait même s'agissant d'un sujet concret. La concrétisation du passage de connaissance se fait par une mise en perspective qui demande souvent un exemple d'application
Sinon ça ressemble à un discours entre camarades de classe (je veux dire personnes de même niveau) qui même s'il est tout à fait pertinent, risque d'être complètement hermétique pour ceux qui ont quelques années de moins de connaissances sur le sujet.
Pour dire que j'ai l'impression que tu tiens le même discours quelque soit la personne à laquelle tu t'adresses, ce qui fait que je perçois plus dans tes propos l'affirmation d'une "philosophie" de développement, plutôt qu'une réponse concrète à une demande précise, ou une mise en perspective pour les faire apprécier simplement.

Bah je dois avouer que je n'ai lu le sujet qu'en diagonal et que j'ai répondu de façon générale. À lui d'appliquer ma définition à son problème. C'est toujours mieux dans ce sens plutôt que dans l'autre (i.e. on a vulgarisé et il faut trouver une règle générale). Mais j'admets que je pourrais donner un exemple, sauf que pour le problème des getters et setters, c'est pas ultra simple comme exemple. Il faut déjà un « bon » niveau objet pour comprendre l'utilité. Donc j'enseigne cette philosophie que les personnes comprendront plus tard je l'espère .

Et sinon, une citation que j'aime bien : « Un texte sans contexte est un prétexte » .