[Erledigt] Beziehungen zwischen Objekten

[MaxC]

Hallo,

ich versuche gerade ein kleines Projekt von mir mittels OOP umzusetzen.
Habe eine grundlegende Frage die ich auch nach dem Lesen von einigen Einsteigertutorials für mich nicht beantworten kann oder vielleicht auch einfach nicht verstehe

Ich versuche es mal anhand eines Beispieles zu erklären:

Es gibt ein Objekt "Person". Adresse, Telefon, .... und einige Setter- bzw. Gettermethoden.

Weiters das Objekt "Produkt". Eine Kennzahl, eine Beschreibung, Preis, ...

Einer Person können nun mehrere Produkte zugeteilt werden.
Also Person 1 besitzt Produkt 2, Produkt 4 und Produkt 5.

Wie ich das in der Datenbank löse ist mir vollkommen klar...
Aber wie stelle ich so eine 1:n Beziehung OO dar?
In dieser Beziehung möchte ich auch noch berücksichtigen das einer bestimmetn Person auf ein bestimmtes Produkt ein Preisnachlass gewährt werden kann (der vom DB-Design her in der Relationstabelle abgespeichert wird).

Mein bisheriger Ansatz ist ein Array "products" im Objekt "person" welches die (Datenbank-)ID's sowie den jeweiligen Preisnachlass enthält.

Aber ich vermute mal das das nicht die schönste Art ist soetwas zu lösen, oder?

Hat hier vielleicht jemand ein kleines Beispiel für mich wie soetwas gelöst wird? Oder einfach das richtige Stichwort nach dem ich suchen muss?

Schonmal Danke!

[nikosch]

Vielleicht ein neues Objekt „Customer“, das eine Person und ein Array von Produkten assoziiert. Kann auch ein von Person geerbtes Objekt sein.

das einer bestimmetn Person auf ein bestimmtes Produkt ein Preisnachlass gewährt werden kann

Für sowas musst Du erstmal die Bedingung formulieren, unter der das erfolgt. Zum Beispiel könnte „Stammkunde/RegularCustomer“ eine Spezialisierung von „Person“ bzw. „Customer“ sein, für die eine andere Preisberechnung erfolgt. In diesem Fall muss die kalkulierende Instanz das allerdings wissen.

[mimomamu]

Mein bisheriger Ansatz ist ein Array "products" im Objekt "person" welches die (Datenbank-)ID's sowie den jeweiligen Preisnachlass enthält.

Ist OK so.

Aber ich vermute mal das das nicht die schönste Art ist soetwas zu lösen, oder?

Warum vermutest du das?

Hat hier vielleicht jemand ein kleines Beispiel für mich wie soetwas gelöst wird?

class Person {
  /**
   * @pre $percentage >= 0 && $percentage <= 100
   */
  public function setDiscount(Product $p, $percentage) {
    $this->discounts[$p->ID] = $percentage;
  }

  public function getDiscount(Product $p) {
    return isset($this->discounts($p->ID)) ? $this->discounts($p->ID) : 0;
  }

  public function hasProduct(Product $p) {
    return isset($this->discounts($p->ID));
  }

  public function disconnectProduct(Product $p) {
    unset($this->discounts[$p->ID]);
  }
} 

[MaxC]

@nikosch
Super, danke!
So 100%ig sicher ob ich das richtig verstanden habe bin ich noch nicht. Aber ich werds gleich mal versuchen umzusetzen.

@mimomamu
Kann ich nicht genau sagen warum. Es erschien mir zwar logisch und einfach aber... tja, keine Ahnung. Vielelicht zu einfach? Und so "objektlos" *g*

[fab]

Was genau willst du denn mit der Beziehung Person<->Produkt modellieren? "besitzt" und "bekommt Preisnachlass" ergibt einzeln zwar Sinn aber zusammen nicht wirklich oder? Geht es also wirklich um Besitz eines Produktes oder einfach nur um bestimmte Bedingungen in Zusammenhang mit dem Produkt?

[Asipak]

Was genau willst du denn mit der Beziehung Person<->Produkt modellieren?

Vielleicht kauft sie (die Person) die Produkte ja ein. In dem Zusammenhang könnte man die Produkte auch erst in einen Warenkorb legen und den Warenkorb dann der Person zuweisen. Die Lösung ist die Gleiche.
Schieb die Produkte in die Klasse Warenkorb (dafür eignet sich wieder ein Array) und den Warenkorb in eine Eigenschaft der Klasse Person.

[nikosch]

In dem Zusammenhang könnte man die Produkte auch erst in einen Warenkorb legen und den Warenkorb dann der Person zuweisen. Die Lösung ist die Gleiche.

Naja, genau betrachtet ist diese Variante sogar besser, weil sie dem üblichen Shopprinzip entspricht. Erst zusammstellen, dann personalisieren (Login oder Eingabe der Adressdaten).

und den Warenkorb in eine Eigenschaft der Klasse Person.

IMHO andersherum. Assoziiere im Warenkorb eine Käufer-Property mit der Person. Jetzt kann man z.B. $this->Buyer->isRegularCustomer() oder $this->Buyer->isGetPaymentType() abfragen und der Warenkorb(!) weiß dann, was er an Nachlässen anbieten kann (Skonto bei Bankeinzug, Stammkundenrabatt oder sonstwas).

[Asipak]

Jau, für die Anwendung ist das wirklich besser. Den Warenkorb muss ich ja später auch noch auswerten können. Da wäre es bitter, wenn der Kunde fehlen würde.

[fab]

Ok bei einem Warenkorb würde es Sinn machen. Aber wie ihr schon gesagt habt modelliert man den wieder ganz anders, deshalb fragte ich nach dem Zweck...

[litterauspirna]

class Person {
  /**
   * @pre $percentage >= 0 && $percentage <= 100
   */
  public function setDiscount(Product $p, $percentage) {
    $this->discounts[$p->ID] = $percentage;
  }

  public function getDiscount(Product $p) {
    return isset($this->discounts($p->ID)) ? $this->discounts($p->ID) : 0;
  }

  public function hasProduct(Product $p) {
    return isset($this->discounts($p->ID));
  }

  public function disconnectProduct(Product $p) {
    unset($this->discounts[$p->ID]);
  }
} 

Warum übergibst du denn an jede Methode die Klasse bzw. das Objekt via Type Hinting? Wäre es nicht sinnvoller es einmal im Constructor via Typehinting zu übergeben, so kannst du ganz bequem durch die ganze Klasse mit dem instanzierten Objekt arbeiten und musst bei jedem Methodenaufruf erneut das Objekt übergeben.

So ist das besser denke ich.

class Person {

protected $p;

  public function __construct(Product $p){
    
       $this->p = $p;
  }

  /**
   * @pre $percentage >= 0 && $percentage <= 100
   */
  public function setDiscount($percentage) {
    $this->discounts[$this->p->ID] = $percentage;
  }

  public function getDiscount() {
    return isset($this->discounts($this->p->ID)) ? $this->discounts($this->p->ID) : 0;
  }

  public function hasProduct() {
    return isset($this->discounts($this->p->ID));
  }

  public function disconnectProduct() {
    unset($this->discounts[$this->p->ID]);
  }
} 

Gruß Litter

[Dormilich]

Warum übergibst du denn an jede Methode die Klasse bzw. das Objekt via Type Hinting?

nun ja, es könnte mehrere Produkte pro Person geben ...

[litterauspirna]

Ja ok es könnte mehrere Produkte pro Person geben, aber diese werden doch alle in dieser einen Klasse abgearbeitet, also übergebe ich die einmal an den Konstruktor und arbeite in der gesamten Klasse mit dem einen Objekt. Und wenn in dem Objekt ein Array mit mehreren Produkten steckt dann braucht man das doch nicht in jeder Methode erneut wiedergeben.

Es ist ja nicht falsch, aber meiner Meinung nach nur unnötig.

[Asipak]

Nein, es ist ja kein Array, sondern eine Instanz der Klasse Product. In dem Beispiel werden die Produkte, die eine Person besitzt, in einer Eigenschaft der Klasse Person gesammelt. Da eine Person mehrere Produkte besitzen/kaufen/was auch immer kann, macht es keinen Sinn, ein einziges Produkt über den Konstruktor zu übergeben.

[litterauspirna]

Na da kann ich doch aber in besagter Klasse oder einer anderen die zu dem Kunden gehörenden Produkte in ein Array schreiben und dann dieses als Objekt zurück geben. Also von mir aus ein Warenkorbobjekt. Und dann kann ich genau dieses Objekt was ein Array mit den ganzen Produkten enthält an den Konstruktor übergeben und dann in der abgebildeten Klasse weiterarbeiten.

Oder aber wenn ein Produkt ein Objekt ist und diese Objekte gehören dann zu einem Kunden, dann kann ich diese entestehenden Produkt Objekte in ein Array schreiben, dieses dann an den Konstruktor der abgebildeten Klasse geben und habe den selben Effeckt ohne jedesmal in jeder EMthode da das Objekt als Type Hinting zu übergeben.

[Asipak]

Ja, aber wie nikosch schon gesagt hat, macht es mehr Sinn, die Person dem Warenkorb zuzuordnen, eben aus genannten Gründen:

Jetzt kann man z.B. $this->Buyer->isRegularCustomer() oder $this->Buyer->isGetPaymentType() abfragen und der Warenkorb(!) weiß dann, was er an Nachlässen anbieten kann (Skonto bei Bankeinzug, Stammkundenrabatt oder sonstwas).

Selbst wenn du die Produkte in einem Array der Klasse "Person" übergeben würdest, würde dir immer noch ein Parameter fehlen, über den du ein Produkt aus deiner Produktpalette ansprechen kannst.

// ...

public function getDiscount() {
  return isset($this->discounts($this->p->ID)) ? $this->discounts($this->p->ID) : 0;
}

// ...

Hier hast du dir ja noch kein Produkt ausgesucht. Viel gespart hättest du also nicht.

[edit]

Btw. wer sagt überhaupt, dass die Produkte nicht über den Konstruktor übergeben werden. Vom Konstruktor ist doch gar nichts zu sehen. Für die Methode ist erst mal nur die ID des Produkts interessant, litter.