Bonjour, je début dans le domaine et il y a des concepts que je n'arrive pas à assimiler

Je vais au distributeur automatique pour retirer de la tune. J'entre ma carte bleue (mes identifiants quoi). A partir de là, la machine sait si je suis un particulier ou un professionnel et me propose les services auquel j'ai droit.

je vois deux classes, particulier et professionnel, qui ont leurs propres méthodes. Elles héritent d'une classe client qui lorsqu'on l'instancie va récupérer toutes ses infos et donc déterminer si le client un pro ou un particulier.

Déjà je me retrouve coincé car de ce j'ai compris, je ne peux pas instancier la classe parent client, je dois instancier ses enfants, or je ne sais pas à la base si le client est un particulier ou un professionnel.

SI quelqu'un me comprend, pourrait-il m'expliquer? Merci

si j'ai bien compris, il te suffit d'appelé la class pro ou prive qui sont toutes deux des enfants (ou extentions) de la class client

class pro extends client{

  function __construct(){
    parent::__construct();

..

}

Voila ...

Bonjour,

c'est ça mais dans mon raisonnement on ne sait pas si le client est un pro ou un particulier donc laquelle des deux classes je dois appeller

Lorsque le membre s'identifie (avec sa CB), tu lui attribut une valeure en relation avec sa condition (privé ou pro) ... sinon, comment peux tu gérer ses autorisations ... ?

donc en fait je dois faire un traitement en dehors de la classe pour identifier le client? pour pouvoir ensuite appeler la bonne classe.

du coup, ce n'est pas la classe client qui se charge de le faire car moi je pensais que c'était son but à la base.

Salut,
tu peux procéder de cette façon, en créant une méthode statique qui te retournera une instance de ton choix en fonction du type de client :

class Client
{
   public static function factory()
   {
      if (...)
      {
         return (new Professionel());
      }
      else
      {
         return (new Particulier());
      }
   }
}

class Professionel extends Client {}

class Particulier extends Client {}

Et pour l'instance :

$client = Client::factory();

C'est une façon assez élégante puisque la méthode pour choisir entre Professionel ou Particulier se situe dans ta classe Client.

ça a l'air d'etre tout à fait ça, je vais développer sur cette base pour voir.

Je pensais que la classe client devait être abstraite c'est pour ça que je disais que je pouvais pas l'appeller. Mais en fait je n'ai pas de besoin de ça. Est ce que je dois pas créer une instance de client avant,
càd $client = new client();

Merci beacoup, merci beaucoup

Non justement.
C'est le principe des méthodes statiques.
Tu travail sur la classe et non sur l'objet.

Du coup, tu peux faire directement

$client = Client::factory();

Sans avoir besoin de déclarer un nouvel objet $client.

Cf le chapitre sur les classes statiques de la documentation php.

Effectivement, il faut donner les données d'authentification de la carte bleue comme paramètres à la fonction statique de l'objet Client pour que la classe client sache quel sous-type instancier : particulier ou professionnel.

<pre>
<?php
class Client
{
   public static function getClient($CB_Data)
   {
      if ($CB_Data['type'] != "particulier")
      {
         return (new Professionel());
      }
      else
      {
         return (new Particulier());
      }
   }
}

class Professionel extends Client 
{
}

class Particulier extends Client 
{
} 

//
$CB_Data = array('type'=>'particulier', 'nom'=>'Dupont', 'prenom'=>'jean');
$mon_client = Client::getClient($CB_Data);
//
print_r($CB_Data);
print_r($mon_client);
?>
</pre>

en fait le type n'est pas renseigné, je crée un constructeur dans la classe client qui va se charger de vérifier que le gars existe. Si il existe, ben je connais son nom, prénom etc ainsi que sa catégorie. Donc voila le principe, je crois c'est une bonne chose que l'utilisateur n'aie pas d'accès à cette propriété.

J'espère que lorsque je vais appeler la méthode statique, est ce que le constructeur sera exécuté également.


Bon voila voila premier problème

class client{
public $type;

public function __construct(){
// vérifie les données ici
$this->type = 'particulier';
}

public static function getClient(){
if($this->type == 'particulier') return (new Particulier()); 
} 

}

class Particulier extends client {
} 

$mon_client = client::getClient();
echo $mon_client->type; 

c'est le test que je veux faire pour le moment
j'ai un problème au niveau de la portée des variables
$this->type ne marche pas dans la méthode statique, j'ai essayé membre::type je crois c'est ça non plus

De toutes façons, tu as besoin d'un constructeur, pour remplir les objets particulier ou professionnel automatiquement selon la construction via client.

Je m'explique: Le déclencheur est la carte CB, dont les données seront envoyées à la classe Client via la fonction statique qui authentifie le client selon les données de la carte CB et décide d'instancier un objet particulier ou professionnel. En suite, quand un objet est instancié, le constructeur (préférablement celui centralisé dans la classe Client) doit retrouver les données du client traité et construire l'objet convenablement. Car il ne faut pas croire que la fonction statique pourra alimenter des objets. C'est à chaque objet de s'auto-construire. C'est pour ça qu'un constructeur est obligatoire si l'objet doit remplir ses propriétés automatiquement à partir de la base selon des paramètres déclencheurs.

Voici un exemple de ce mécanisme:

<pre>
<?php
class Client
{
   public  $nom;
   public  $prenom;
   public  $type;
   
   public function __construct($CB_Data=null)
   {
		$data = $this->getData($CB_Data);
		if ($data != null)
		{
			$this->nom = $data['nom'];
			$this->prenom = $data['prenom'];
			$this->type = $data['type'];
		}
   }
   
   public static function getClient($CB_Data)
   {
		$data = Client::getData($CB_Data);
		return  $data['type'] != 'particulier' ?  new Professionel($CB_Data) : new Particulier($CB_Data);
   }
   
   public function getData($CB_Data)
   {
   		// Simulation de recherche des données client
   		if ($CB_Data['nom']== 'Dupont' && $CB_Data['prenom']== 'Jean' && $CB_Data['secret']== '123')
		{
			return array('nom'=>'Dupont', 'prenom'=>'Jean', 'type'=>'particulier', '...'=>'...'); //données de la base de données
		}
		return null;
   }
}

class Professionel extends Client 
{
}

class Particulier extends Client 
{
} 

//
$CB_Data = array('nom'=>'Dupont', 'prenom'=>'Jean', 'secret'=>'123');
$mon_client = Client::getClient($CB_Data);
//
echo "<p>Données de la carte CB :</p>";
print_r($CB_Data);
echo "<p>Objet Client identifié:</p>";
print_r($mon_client);
?>
</pre>

La fonction statique getClient reçoit les paramètres du tableau $CB_Data, recherche le client et notamment son type pour décider d'instancier un objet particulier ou professionnel, et par la même, retransmet les paramètres du tableau $CB_Data au constructeur de l'objet instancié.
De cette manière, l'objet instancié, utilise le constructeur de la classe mère Client pour remplir ses propriétés héritées.
Le constructeur de la classe Client, ici, sert plus pour construire les sous-objets particulier et professionnel.
La fonction statique getClient, ne doit pas utiliser directement les propriétés de la classe Client car elle n'a pas pour vocation de construire un objet Client et de toutes façon, quand elle s'exécute dans un mode statique, elle ne pourra pas accéder à des propriétés non statiques et ça sert à rien dans notre cas, car elle pourra utiliser la fonction getData pour obtenir directement les données de la base de données du client recherché et en autre son type, pour décider quel sous-objet instancier.


----
Moralité: Veillez sur la relation avec votre famille, car vous pouvez vous retrouver à travers elle.

Merci beaucoup, ton exemple est du grande aide. C'est un très bon exercice et je dois approfondir tout ça

Hey ,

Pas lu mais un conseil : toujours commencer par le papier et le crayon, toujours . Un petit dessin est tellement plus efficace que des heures de codage …