OOP: Subklassen / Subobjekte

**Melewo** · 30.04.2013, 09:38

Du steckst gewiss tiefer in OOP als ich und einige andere haben in Sachen OOP gewiss einiges mehr an Kenntnissen als ich, deshalb nur mal so ein paar allgemeine Gedanken.

Wenn Maschine A zum Beispiel 1000 Stifte pro d und Maschine B 500 Deckel pro d produzieren muss, um sich bezahlt zu machen, dann ist das doch erst einmal gut als Maschinenklasse. Du könntest doch dann eine zweite Klasse für das Auftragsvolumen anlegen. Wenn Du dann die Maschinenklasse nimmst, ein Objekt für Maschine B erzeugst, diesem als Werte für die Eigenschaften die entsprechenden Daten aus der Auftragsklasse zuweist, dann wäre es nach meinen Vorstellungen ausreichen, um auf ein Ergebnis zu kommen, wie:

Code:

Bestellung   Maschine     Zeit     Auslastung
  5.000     500 pro d     10 d        100 %

Das sollte sich sicherlich vereinfachen lassen. Nur würde ich keine Maschinenklasse mit einer Auftragsklasse zusammenwürfeln oder ableiten, da die Maschinenklasse der eigenen Übersicht zur Auswertung der Wirtschaftlichkeit dient, die Auftragsklasse hingegen auch zur buchhalterischen Erfassung. Oder habe ich da jetzt etwas grundsätzlich falsch verstanden?

**Relativity** · 30.04.2013, 10:01

Hallo Melewo,

dank dir für die schnelle Antwort.

Jedes Objekt hat die gleichen Eigenschaften und die Verkettung der Objekte in die Tiefe muss quasi bestehen bleiben, da ich Artikel 2+3 nur unterhalb von Maschine 2 haben möchte in der Auswertung.

Diese sieht für den User hinterher dargestellt ungefähr so aus:

Produktionsauswertung
|
| Maschine 1: (SOLL: 1000 | IST: 800) (M/P/R: 20/5/5)
| -- Artikel 1: (SOLL: 1000 | IST: 800) (M/P/R: 20/5/5)
|
| Maschine 2: (SOLL: 2000 | IST: 900) (M/P/R: 40/10/10)
| -- Artikel 2: (SOLL: 1000 | IST: 400) (M/P/R: 20/5/5)
| -- Artikel 3: (SOLL: 1000 | IST: 500) (M/P/R: 20/5/5)

Aufklappbar ist hinterher bei Artikel 2 dann die Produktionsaufträge.
Diese können weiterhin aufgeklappt werden ins Detail der Arbeitsschritte.

Deswegen die tiefe Verkettung für den loop der HTML Ausgabe,
damit der Loop quasi innerhalb der Objekte stattfinden kann und
nur die Daten ausgibt, die wirklich unter ihm liegen.

**Melewo** · 30.04.2013, 10:25

Ja, so etwas verstehe ich schon Dein Anliegen. Vielleicht sollte ich mich auch zurückhalten mit meinen Antworten, bis jemand mit qualifizierteren Tipps aufwartet.

Sollte nur ganz allgemein sein, weil ich das mehr aus einem betriebswirtschaftlichen Blickwinkel betrachtet habe, wo für jede Maschine ein eigenes Konto angelegt werden könnte, bei größeren Unternehmen auch wird, doch auch kleine Unternehmen mindestens eine AfA-Liste erstellen. Und um so eine Auswertung dann vorzunehmen, da stehen weniger Fragen der Programmierung im Vordergrund, weil das dann nur noch Mittel zum Zweck ist, vielmehr ist die Datenbasis wichtig.

**Guenni61** · 30.04.2013, 14:10

Zitat von Relativity Beitrag anzeigen

Hallo zusammen,
. . .
----------------------------------------------------------------------
Mich erschlägt aktuell die Komplexität der Strings mit welcher ich die unteren Objekte ansprechen muss:
$this->maschine['testmaschine1']->artikel['1000']->prodauf['1215']->proddetail[0]
sowie die Problematik das ich jedes davon noch mit return Funktionen der Variable versehen muss, da die Variablen private sind.
---------------------------------------------------------------------
Gibt es eine "einfachere Möglichkeit" von dem obersten Objekt auf tiefere Subobjekte / die Variablen der Subobjekte zuzugreifen?
Oder ist vllt. mein Lösungsansatz mit der tiefen Verschachtelung komplett falsch?
---------------------------------------------------------------------
Vielen Dank vorab für jede Hilfe.
Relativity.

Hi Relativity,
wie du deine Verschachtelung von Klassen umsetzt, müsstest du vielleicht anhand von Beispielen mal darlegen.

Wenn Klassen von anderen Klassen (Basisklassen) abgeleitet werden, deklariert man die Variablen üblicherweise als protected.
Dann erbt die abgeleitete Klasse die Eigenschaften der Basisklasse. Ihre eigenen Eigenschaften werden sozusagen um die Eigenschaften
der Basisklasse erweitert. Somit kann die abgeleitete Klasse auf die Eigenschaften der Basisklasse zugreifen, als wären es ihre eigenen.

Damit entfällt dann auch solch' ein Konstrukt: $this->maschine['testmaschine1']->artikel['1000']->prodauf['1215']->proddetail[0].

Auch kannst du in der Basisklasse Funktionen definieren, die nichts machen und auch keine Parameter erwarten.
Die abgeleitete Klasse erbt diese Funktion und die kann benutzt werden, als wenn es ihre eigene wäre. Heißt, jede abgeleitete Klasse überschreibt
den Funktionsnamen, übergibt eigene Parameter und macht sonst was.

Ein Beispiel mit Fahrzeugklassen aus einem anderen Beitrag:

PHP-Code:


<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>Untitled</title>
</head>
<body>
<?php
abstract class c_fahrzeug{
 protected $hersteller;
 protected $modell;
 protected $typ;
 protected $baujahr;
 protected $neu;
 public function setze_eigenschaft(){
 
 }
 
 public function zeige_eigenschaft(){
 
 }
};
class c_auto extends c_fahrzeug{
 protected $motor;
 protected $klima;
 protected $navi;
 protected $hifi;
  public function setze_eigenschaft($hersteller,$modell,$motor,$klima="Nein",$navi="nein",$navi="nein"){
  $this->hersteller=$hersteller;
  $this->modell=$modell;
  $this->motor=$motor;
  $this->klima=$klima;
  $this->navi=$navi;
  $this->navi=$navi;
 }
 public function zeige_eigenschaft(){
  echo '<p>Hersteller: '.$this->hersteller.'<p>';
  echo '<p>Modell: '.$this->modell.'<p>';
  echo '<p>Motorbauart: '.$this->motor.'<p>';
  echo '<p>Klimaanlage: '.$this->klima.'<p>';
  // usw. . . .
 }
};
class c_fahrrad extends c_fahrzeug{
 protected $rahmen;
 protected $schaltung;
 public function setze_eigenschaft($hersteller,$modell,$rahmen,$schaltung){
  $this->hersteller=$hersteller;
  $this->modell=$modell;
  $this->rahmen=$rahmen;
  $this->schaltung=$schaltung;
 }
 public function zeige_eigenschaft(){
  echo '<p>Hersteller: '.$this->hersteller.'<p>';
  echo '<p>Modell: '.$this->modell.'<p>';
  echo '<p>Rahmenbauart: '.$this->rahmen.'<p>';
  echo '<p>Schaltung: '.$this->schaltung.'<p>';
 }
};
//Ein Auto
echo "<h3>Ein Auto</h3>";
$auto=new c_auto;
$auto->setze_eigenschaft('VW','Golf VII','Diesel');
$auto->zeige_eigenschaft();
//Ein Fahrrad
echo "<h3>Ein Fahrrad</h3>";
$fahrrad=new c_fahrrad;
$fahrrad->setze_eigenschaft('Koga Miyata','Racer 3400 XS','Kohlefaser','Shimano');
$fahrrad->zeige_eigenschaft();
//Ausgabe der Objekteigenschaften
//Hier sieht man, dass die Klassen Fahrrad und Auto die Eigenschaften von der
//Klasse Fahrzeug geerbt haben. Jedoch belegen die Klassen auto und fahrrad die
//Eigenschaften der Klasse Fahrzeug mit ihren eigenen Werten.
echo '<pre>';
var_dump($auto);
echo '</pre>';
echo '<pre>';
var_dump($fahrrad);
echo '</pre>';
?>
</body>
</html>

Hier siehst du, das die Funktionen Eigenschaften der Basisklasse ausgeben, sowie Eigenschaften der abgeleitenden Klasse.

Gruß
Günni

**Relativity** · 30.04.2013, 14:38

Hallo Günni,

dank dir für die Antwort. Leider geht es nicht in die Richtung, die ich meinte.

Es geht mir nicht um extenden einer Klasse um diese mit Funktionen
oder Variablen zu erweitern, dies ist bereits alles geschehen und funktioniert.

Es geht mir mehr darum, das bei mir Objekte weitere SubObjekte generieren
und diese widerum weitere SubObjekte. Ich versuche es anhand eines
einfachen Beispiels:

Code:

class auswertung {

    private $maschine;
    private $maschine_name;

    function __construct() {
    
        $this->maschine = array();
        $this->create_maschine();
    }

    function create_maschine() {

        $this->maschine[] = new auswertung_maschine();

    }

}


class auswertung_maschine {

    private $artikel;

    function __construct() {

        $this->artikel = array();
        $this->create_artikel();
    }

    function create_artikel() {

        $this->artikel[] = new auswertung_artikel();

    }

}

Maschine[0] ist ein Objekt der Auswertung
Es gibt noch 8 andere Maschinen.

Artikel[0] ist ein Objekt der Maschine[0].
Diese Zuordnung ist wichtig, für die Auswertung und der späteren
Ausgabeschleife der Artikel, die auf der Maschine produziert werden.

Um nun hinterher an den Inhalt von artikel[0] zu kommen muss ich immer
von dem Objekt der Klasse Auswertung über maschine[0] gehen. Daher die
Frage ob es eine Möglichkeit gibt, die Abhängigkeiten der Artikel zu
der Maschine beizubehalten und direkt mit dem Artikel zu arbeiten ohne:

$prodauswertung->maschine[0]->artikel[0]->irgendeinefunktion();

**Melewo** · 30.04.2013, 15:45

Mische mich doch noch einmal ein, weil ich den Sinn nicht nachvollziehen kann. Sind aber wieder nur ganz allgemeine Gedanken. Du hast doch die Datensätze von den einzelnen Maschinen in einer DB zu liegen oder nicht?

Name der Maschine, Anschaffungskosten, Datum der Anschaffung, Datum der Abschreibung, Restwert und dann, was ich nicht hatte, Du aber haben möchtest, so wie ich das verstehe, vielleicht noch ein oder zwei Felder, in denen die täglichen Stückzahlen oder Sunden als Soll enthalten sind, um auf 100 Prozent bzw. auf +/- Null zu kommen.

Und diesen Datensatz kannst Du doch einfach für jede Maschine abrufen und mit der tatsächlich produzierten Stückzahl entsprechend dem Auftragsvolumen verrechnen oder nicht? Dazu sollte doch nach meinen Vorstellungen eine Klasse genügen.

**Relativity** · 30.04.2013, 16:47

Ganz so einfach ist es leider nicht.

Die Datensätze des ERP sehen so aus:

Produktionsauftrag Nummer
Produktions-Artikel
Menge-Soll
Menge-Ist
Arbeiter-Nr
Arbeiter-Zeit
Arbeits-Typ

Auf der Arbeiter-Nummer kann eine Maschinen-Nummer sein, oder ein Arbeiter. Es gibt viele Datensätze zu einem Produktionsauftrag. Jeder Vorgang (Rüsten, Produzieren etc.) ist ein Datensatz. Es kann mehrere Maschinen in einem Produktionsauftrag geben. Die Datensätze die nach einer Arbeiter-Nr kommen, der eine Maschine ist, gehören zu der Maschine.

1;Artikel1;5000;4500;1000;8,5;P
1;Artikel1;5000;4500;1000;1,5;R
1;Artikel1;5000;4500;1010;4,5;P
1;Artikel1;5000;4500;1011;4,5;P
1;Artikel1;5000;4500;1001;8,5;P
1;Artikel1;5000;4500;1010;4,5;P
1;Artikel1;5000;4500;1011;4,0;P

1000 und 1001 wären z.B. Maschinen und 1010 und 1011 wären ein Arbeiter.

Ich habe keine Möglichkeit gefunden es auch nur annähernd irgendwie zu summieren. Daher lasse ich die sql-rows einfach durchlaufen und werte sie manuell aus.

Bitte keine Diskussionen warum das so ist - ich habe es nicht entwickelt - ich kann und darf es auch nicht ändern - es ist nicht mein ERP.

------

Auswerten will ich die SOLL+IST Zahlen, die Maschinen-Stunden,die Rüst-Stunden und Arbeits-Stunden. Die Menge an Arbeitern. Die Abweichungen zu den Vorgabe Werten der Optimal-Auslastung der Maschine.

Zudem soll visualisiert werden welche Artikel auf welcher Maschine produziert werden und wie effektiv.

Zudem soll man durch einen Klick auf den Artikel diesen aufklappen können und die einzelnen Produktionsaufträge sehen.

Diese sollen wiederrum durch einen Klick aufgeklappt werden können für die Details und Arbeitsschritte des Auftrags.

----

Ein Artikel kann auf unterschiedlichen Maschinen laufen.
Ein Produktionsauftrag kann unterschiedliche Maschinen ansprechen.

Es muss somit eine Zuordnung geben zwischen
Maschine<->Artikel<->Produktionsauftrag

Die Maschinen sind unique, die Artikel und Produktionsaufträge nicht.

Ich brauche in den Maschinen, den Artikel und dem Produktionsauftrag die Summen aller Subobjekte damit die Zahlen belegbar sind (Controlling). Beim Aufklappen müssen diese Summen detailliert dargestellt werden.

Loose Objects die man einfach in ner Schleife durchlaufen lässt und
schaut ob sie zur Maschine gehören sind aufgrund der Datenmenge
nicht möglich. Es muss eine direkte und eindeutige Zuordnung geben.

**Melewo** · 30.04.2013, 17:19

Gut, jetzt ist das wenigstens nachvollziehbar, was Du so vorhast.

**Melewo** · 01.05.2013, 06:15

Nachdem keine weiteren Antworten gekommen sind und ich eine Nacht darüber geschlafen habe, sieht der bisherige Weg für mich nach reichlich Unfug aus. Habe mal zwei Jahre an einer Werkbank gestanden, wir mussten jeden Tag ein Buch führen, was gemacht wurde. Und anders kann das wohl auch nicht sein, nur das heute alles mehr elektronisch erfasst wird. Jeder Bauer weiß, welche Kuh wann den Melkstand aufsuchte, zumindest wenn die Kühe einen Chip tragen oder so und der Melkstand etwas neuer ist. Du versuchst das aber alles abzuleiten und das kann nicht der Weg sein.

Lege für jede Maschine ein Arbeitskonto an, in dem fortlaufend aufgeführt wird, wer an der Maschine stand und wie viele Teile von welcher Art für welchen Auftrag (mit Nummer des Auftrages) fertigte. Und durch diesen Arbeitskonten kannst Du dann einen Query machen, mal nach Auftragsnummer sortieren, mal nach Maschine und mal nach Arbeitnehmer oder mal nach Teilenummer, wie es gerade beliebt.

Da lässt sich dann auch Jahre später noch abrufen, das Max Mustermann am 1. April 2006 in der Zeit von 07.00 bis 08.00 Uhr für den Auftrag mit der Nummer 20201012 genau 312 Schlüsselringe an der Maschine mit der Nummer 07 fertigte. Und es lässt sich auswerten, dass Max Mustermann an der Maschine 07 im angegebenen Zeitraum 4 Schlüsselringe über dem Soll lag und deshalb für eine Prämie vorgeschlagen werden kann.
Und Du kannst nach drei Jahren noch auswerten, das vom Auftrag mit der Nummer 20201012 die ersten 312 an der Maschine 07 von Max Mustermann in der Zeit von 07.00 bis 08.00 Uhr an der Maschine 07 gefertigt wurden und die nächsten 188 Schlüsselringe von Susi Musterfrau in der Zeit 08.01 bis 08.48 Uhr an der Maschine 06. Oder Du kannst auswerten, was immer Du auswerten willst.

Das wäre für mich der einzig gangbare Weg, den ich momentan erkennen kann. Soll heißen, Du hast ja alle Werte und Daten, nur die müssen erneut aufbereitet und abgespeichert werden, in verknüpften Tabellen oder wie auch immer, um diese Daten dann mal nach Maschine, mal nach Auftragsnummer, mal nach Artikelnummer, mal nach Arbeitnehmer abrufen zu können.

**Guenni61** · 01.05.2013, 15:43

Zitat von Relativity Beitrag anzeigen

Hallo Günni,
. . .
Maschine[0] ist ein Objekt der Auswertung
Es gibt noch 8 andere Maschinen.
Artikel[0] ist ein Objekt der Maschine[0].
Diese Zuordnung ist wichtig, für die Auswertung und der späteren
Ausgabeschleife der Artikel, die auf der Maschine produziert werden.

Um nun hinterher an den Inhalt von artikel[0] zu kommen muss ich immer
von dem Objekt der Klasse Auswertung über maschine[0] gehen. Daher die
Frage ob es eine Möglichkeit gibt, die Abhängigkeiten der Artikel zu
der Maschine beizubehalten und direkt mit dem Artikel zu arbeiten ohne:
$prodauswertung->maschine[0]->artikel[0]->irgendeinefunktion();

Hi Relativity,
ich hab' das schon verstanden, worauf du hinaus willst. Leg' mal ein Objekt deines Konstrukts an,
und gib das Objekt mit vardump aus.

PHP-Code:


$objekt_auswertung = new auswertung;
echo '<br><pre>';
var_dump($objekt_auswertung);
echo '</pre>';

Ausgabe:
object(auswertung)#1 (2) {
["maschine

rivate"]=>
array(1) {
[0]=>
object(auswertung_maschine)#2 (1) {
["artikel

rivate"]=>
array(1) {
[0]=>
object(auswertung_artikel)#3 (1) {
["menge

rivate"]=>
NULL
}
}
}
}
["maschine_name

rivate"]=>
NULL
}

So ist das nun mal. Wenn man verschachtelt, so kommt man auch nur über den Weg der Verschachtelung an das letzte Element.
Und der Zugriff auf Variablen über eine Funktion bleibt dir wegen private sowieso nicht erspart.

Um noch mal auf mein Beispiel http://www.php-resource.de/forum/php...tml#post666212 zurückzukommen.

Auch hier werden die Abhängigkeiten gewährleistet.

PHP-Code:


<?php
class c_artikel{
      protected $auftragsnummer;
      protected $artikel;
      protected $menge;
      public function auftrag($auftragsnummer,$artikel,$menge){
             $this->auftragsnummer=$auftragsnummer;
             $this->artikel=$artikel;
             $this->menge=$menge;
      }
};
class c_maschine extends c_artikel{
      protected $maschinennummer;
      protected $kapazitaet;
      public function maschine($maschinennummer,$kapazitaet){
             $this->maschinennummer=$maschinennummer;
             $this->kapazitaet=$kapazitaet;
      } 
};
class c_auswertung extends c_maschine{
      public function print_auftrag(){
             echo "<h3>Auftragsnummer: ".$this->auftragsnummer."</h3>";
             echo "<p>Bestellter Artikel: ".$this->artikel."</p>";
             echo "<p>Bestellte Menge: ".$this->menge."</p>";
             echo "<p>Wird produziert auf: ".$this->maschinennummer."</p>";
             echo "<p>Kapazität/h: ".$this->kapazitaet."</p>";
      }  
};
// Erste Maschinenauswertung
$auswertung[0] = new c_auswertung;
$auswertung[0]->auftrag(12345,'Seidenschal Modell 23A5',500);
$auswertung[0]->maschine('A500',300);
$auswertung[0]->print_auftrag();
// Zweite Maschinenauswertung
$auswertung[1] = new c_auswertung;
$auswertung[1]->auftrag(12395,'Oberhemd Modell 124AB5',1500);
$auswertung[1]->maschine('A800',500);
$auswertung[1]->print_auftrag();
echo '<br><pre>';
var_dump($auswertung[0]);
var_dump($auswertung[1]);
echo '</pre>';
?>

Der Zugriff auf Variablen ist hier (m.M. nach) einfacher.

Gruß
Günni

**h3ll** · 01.05.2013, 15:47

Die Ableitung wird hier falsch verwendet. Eine Ableitung ist immer eine ist-Beziehung.

Auto ist ein Fahrzeug
Banane ist ein Obst

Aber ein eine Auswertung ist keine Maschine.

Davon abgesehen solltest du die komische Benennung "c_klassenname" sein lassen. Klassen werden üblicherweise in Camel-Case (Foo, Bar, FooBar) geschrieben. Nicht klein, nicht komplett groß und mit keinen komischen Kürzeln davor.

Außerdem sollten Funktionsnamen immer ein Zeitwort beinhalten, da ein Funktionsname beschreiben sollte, was eine Funktion tut. Und zu einer Tätigkeit gehört eben ein Zeitwort. zB. erstelleDatensatz(), summiereBeitraege(), zeigeErgebnis(), etc.

Und man sollte nicht mehrere Sprachen mischen. Entscheide dich für Englisch oder Deutsch, aber keine Mischung ala "print_auftrag" oder "create_maschine". Sinnvollerweise ist Englisch die bessere Wahl, da Programme international lesbar sein sollten. Außerdem gibts dann keine Probleme, wenn du fremde Softwarepakete einbindest (sonst hättest du ja wieder eine Sprachvermischung).

**Relativity** · 01.05.2013, 18:37

Hallo zusammen,

vielen Dank vorab für die vielen Antworten.

@Melewo:
Nach wie vor stehe ich vor dem gleichen Problem das die Produktionen in unser ERP System eingegeben werden. Aus diesem ERP System kann ich aufgrund der schlechten Datenbanken keine effektive Auswertung der Maschine und der dazugehörigen Arbeitsgänge vornehmen, da sie nicht zugeordnet werden können. Es gibt keine Zuordnung zu dem Arbeiter und der Maschine, da dies einzelne Datensätze sind und diese nacheinander in der Datenbank stehen mit einer Sortiernummer.

Ich müsste somit erstmal Funktionen schreiben die diese Datensätze auslesen und in einer neuen Form in eine SQL schreiben um sie dann auswerten zu können. Daher versuche ich im ersten Schritt die Daten evtl. direkt auswerten zu können indem ich eine Maschinen-Variable habe, diese überschrieben wird wenn eine Datenbank-Zeile mit einer Maschine kommt, und anschließend alles was kommt immer auf diese Maschine geschrieben wird. Sobald ein neuer Produktionsauftrag kommt wird die Maschinenvariable auf einen Default Wert zurückgesetzt.

@Guenni:
Ein extenden der jeweiligen Klassen macht meiner Meinung nach keinen Sinn, da wie bereits von h3ll gesagt, ein Artikel keine Maschine ist, etc. Die Maschinen- und Artikel-Klassen haben bis auf ein paar Variablen keine Gemeinsamkeiten von den Funktionen her.

Das "Hauptproblem" liegt aber wo anders:
Bei deinem Beispiel (erneut vielen Dank für die Mühe), hast du keinen direkten Bezug der Objekte:

Maschine -> Artikel -> Produktionsauftrag

Wenn ich z.B. zwei Artikel habe, würde ich in deinem Beispiel 2x die Maschinen Klasse extenden, bei beiden Artikeln hätten hinterher die Maschinen-Variablen den Initialwert (0 Stück gefertigt), was aber in dem Moment falsch ist, da beim zweiten Extenden die Maschine ja bereits etwas gefertigt hat und diese Stückzahlen ja mit berücksichtigt werden müssen.

Ich müsste somit hinterher stur alle Objekte durchlaufen und die Stückzahlen addieren lassen, was ich recht umständlich finde, da ich loose objects generiere, welche nicht direkt verknüpft sind und somit das Artikel-Objekt nicht mehr in direkter Abhängigkeit steht zu der Maschine auf der es gefertigt wurde.

In meinem Beispiel kommt diese Abhängigkeit zu stande, indem der Artikel immer ein Objekt das Maschinen Objekts ist, auf dem er gefertigt wurde. Somit kann ich innerhalb des Maschinen Objekts einfach mit einem Loop das Objekt-Array durchlaufen lassen und erhalte alle Artikel.

@h3ll:
Das von mir gestellte Beispiel war nur fix runter geschrieben, habe dabei nicht auf die Funktionsnamen etc. geachtet. Verzeih mein Denglisch

Meine "normalen" Funktionsnamen sind immer englisch.

------------------

Ich danke euch somit für all den input den ich erhalten habe, hatte nur gehofft das es vllt. einen "einfacheren" Weg gibt, durch die Objekte auf tiefer gelegene Objekte zuzugreifen und ich evtl. den jeweiligen Befehl dafür nur noch nicht kannte.

Gruß und euch einen schönen 1. Mai

Relativity

**litterauspirna** · 03.05.2013, 08:37

Hallo,

du scheinst da einige gravierende Fehler im Softwaredesign zu haben.

[Produktionsauswertung]
|
[Maschine]
|
[Artikel]
|
[Prod.Auftrag]
|
[Prod.Auftrag.Detail]

Eine Produktionsauswertung erzeugt keine Maschine, sondern es wird ein Maschinenobjekt zur Auswertung benutzt.

Eine Maschine erzeugt zwar Artikel, aber nicht in einer Auswertung, in der existieren schon die Artikel, dass bedeutet es muss hinterlegt werden mit welcher Maschine, welche Artikel für welchen Produktionsauftrag gefertigt wurden.

Ein Artikel erzeugt auch niemals einen Produktionsauftrag, denn der Produktionsauftrag muss schon existent sein um einen Artikel zu fertigen, der Auftrag muss sogar schon existent sein bevor du bestimmst welche Maschine für die Produktion von Artikeln eines Auftrages benutzt wird.

Du könntest zum beispiel deine Maschinen in einer Datenbank hinterlegen mit all ihren Eigenschaften etc. und dir eine Klasse programmieren die immer eine Maschine darstellt, aber in der Lage ist verschiedene Maschinen zu erzeugen. Diese Maschinen Klasse könnte eine Factory Methode haben, die Maschinen Objekte erzeugt. Jedes spezielle Maschinen Objekt implementiert ein Interface. Somit ist in der eigentlichen Maschinen Klasse sicher gestellt das alle wichtigen Methoden eines Maschinen Objektes, die immer benötigt werden, vorhanden sind.

Kurzes Beispiel.

PHP-Code:


/**
 * interface für jede spezielle maschine
 *
 */
interface EngineInterface
{
    public function __construct();
    
    public function setResource($resource);
    
    public function setArticelsProMinute();
}

/**
 * klasse maschine, welche objekte spezieller maschinen erzeugt
 *
 */
class Engine
{
    protected $_engines;
    
    protected $_engineObjects;
    
    public function __construct()
    {
        $this->_engines = new ArrayObject(array());
        $this->_engineObjects = new ArrayObject(array());
    }
    
    public function setEngine($name, $class)
    {
        $this->_engines->offsetSet($name, $class);
        return $this;
    }
    
    public function factory($name)
    {
        if ($this->_engines->offsetExists($name) !== false) {
            $this->_engineObjects->offsetSet($name, new $this->_engines->offsetGet($name));
        }
    }
    
    public function engine($name)
    {
        if ($this->_engineObjects->offsetExists($name)) {
            
            if ($this->_engineObjects->offsetGet($name) instanceof EngineInterface) {
                return $this->_engineObjects->offsetGet($name);
            }
        }
    }
}

/**
 * drehmaschinen klasse
 */
class RotatingEngine implements EngineInterface
{
    public function __construct()
    {
        
    }
    
    public function setResource($resource)
    {
        
    }
    
    public function setArticelsProMinute()
    {
        
    }
}

/**
 * fräßmschineen klasse
 *
 */
class MillingEngine implements EngineInterface
{
    public function __construct()
    {
    
    }
    
    public function setResource($resource)
    {
    
    }
    
    public function setArticelsProMinute()
    {
    
    }
}

/**
 * klasse Produktion
 * hier gehört dann noch ein Auftrags und Auftragsdetails objekt rein
 *
 */
class Production
{
    protected $_engines;
    
    public function __construct()
    {
        
    }
    
    public function setEngines(Engine $engine)
    {
        $this->_engines = $engine;
    }
    
    public function runProduction()
    {
        
    }
}

/**
 * benutzen der ganzen objekte
 */
$production = new Production();
$engines = new Engine();
$engines->setEngine('rotating', 'RotatingEngine')
    ->setEngine('milling', 'MillingEngine');
$production->setEngines($engines);
$production->runProduction();

Dieses Beispiel ist sehr stark vereinfacht, aber so könntest du das vom Grund her aufbauen wenn es z.B. um die Produktion geht. Du kannst natürlich auch dann diese Vorgehensweise für eine Produktionsauswertung nutzen und dort die gleichen Objekte benutzen, bis auf das Production Objekt.

Subklassen gibt so in PHP nicht, dass bietet Java, C++ und C# an, aber leider nicht PHP.

Ich hoffe das hilft dir so ein kleines Stück weiter.

Gruß Litter

[EDIT]
@Guenni61, dein Beispiel von Vererbung (Ableitung) kann man leider falscher nicht darstellen. Eine Maschine ist kein Artikel, sondern eine Maschine produziert einen Artikel, besser sogar sie erzeugt ein Produkt, ein Artikel wird es erst wenn es Angeboten wird zum Kauf und über einen Preis etc. verfügt.

Eine Auswertung ist auch keine Maschine, in einer Auswertung werden höchstens Maschinen die für einen Produktionsauftrag benutzt wurden gelistet mit diversen Detail Auswertungsdaten.

Immer daran denken, eine Vererbung stellt immer (ausnahmslos immer) einen spezialisierten IST Zustand von Klassen (Objekten) dar.

Für den TE wären hier noch Punkte wie Dependensy Injection und Dependensy Injection Container ne gute Sache zum nachlesen.

**Relativity** · 03.05.2013, 09:08

Hallo Litter,

dank dir für deine ausführliche Schilderung.

Wie würdest du in einem solchen Design, wo Maschinen und Artikel (die auf ihnen produziert werden) komplett getrennt sind, eine Schleife bauen, die alle Artikel auflistet, die auf der Maschine produziert werden?

Du hast ja quasi keine Abhängigkeit zwischen Maschine und Artikel und müsstest alle Artikel-Objekte einfach stur durchlaufen lassen bis du eins findest wo die entsprechende Maschine drin vorkommt?

PS: in deine Keywords (Dependensy Inj. ..) lese ich mich heute Abend in Ruhe mal ein.

Gruss
Relativity

OOP: Subklassen / Subobjekte