[PHP] CD-Archiv in OOP programmierbar?

Muuhmann

Lieutenant
Registriert
Sep. 2004
Beiträge
782
Hey Guys!

Ich will mir in Verbindung mit PHP5 und MySQL ein CD-Archiv schreiben. Nun hatte ich schon vorher eine Variante gebastelt, wollte jetzt aber alles nochmal neu machen und dabei wollte ich eigentlich OOP verwenden. Leider empfinde ich das jetzt als schwierig mich in dieses ganze OOP-Getue einzudenken.
z.B. sollen ja alle Daten in eine Datenbank geschrieben werden, was bringt es mir also, Klassen aufzubauen und Objekte zu erzeugen?
Außerdem habe ich ein Problem mit dem Aufbau der Klassen und des ganzen Scripts sowieso.
Wie sieht das z.B. mit den "INSERT"-Befehlen aus? Sollen diese nun Methoden der Klasse "Programme" sein oder ganz "normale" Funktionen oder nochnichmals das?

Wie ihr seht, kann ich mich nicht wirklich in diese OOP-Materie eindenken. Vielleicht bringt es ja was, wenn ich mal meine Überlegungen mit einbringe.
Also das hier ist was ich mir bis jetzt theoretisch(!) ausgedacht habe, so für den aufbau der Klassen:
PHP:
<?php
class cd{
  var $bid  //ID desjenigen, der die CD ausgeliehen hat
  var $title  //Titel halt
  var $quantity //Anzahl der CDs
  var $discription //Beschreibung
  var $date //datum der letzten Änderung
}

class moviez extends cd{
  var $genre

  function insert($id, $title, ...) { //ganzen übergabe Variablen halt
    /* soll jetzt hier der INSERT-Befehl hin oder sowas wie $thist->title[$id] = $title */
  }
  function update(...) {
    //s. insert
  }
  function delete(...) {
    //s. insert
  }
}

class appz extends cd{
  //das gleiche wie bei "class moviez" nur in Grün ;)
}
?>


Die Tabelle ist so aufgebaut:

Code:
-- phpMyAdmin SQL Dump
-- version 2.7.0-pl1
-- http://www.phpmyadmin.net
-- 
-- Host: localhost
-- Erstellungszeit: 14. April 2006 um 19:52
-- Server Version: 5.0.18
-- PHP-Version: 5.1.1
-- 
-- Datenbank: `cd_archiv_v2`
-- 

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

-- 
-- Tabellenstruktur für Tabelle `borrowed`
-- 

CREATE TABLE `borrowed` (
  `id` int(10) unsigned NOT NULL,
  `name` varchar(50) collate latin1_german1_ci NOT NULL,
  PRIMARY KEY  (`id`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1 COLLATE=latin1_german1_ci COMMENT='Tabelle für alle die CDs ausleihen';

-- 
-- Daten für Tabelle `borrowed`
-- 


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

-- 
-- Tabellenstruktur für Tabelle `movies`
-- 

CREATE TABLE `movies` (
  `id` int(10) unsigned NOT NULL auto_increment COMMENT 'id der CD',
  `bid` int(10) unsigned default NULL COMMENT 'id der Person die ausgeliehen hat',
  `titel` varchar(100) collate latin1_german1_ci NOT NULL,
  `genre` varchar(100) collate latin1_german1_ci NOT NULL,
  `quantity` int(10) unsigned NOT NULL,
  `discription` mediumtext collate latin1_german1_ci NOT NULL,
  `date` date default NULL,
  PRIMARY KEY  (`id`),
  KEY `titel` (`titel`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1 COLLATE=latin1_german1_ci COMMENT='Tabelle für Filme' AUTO_INCREMENT=1 ;

-- 
-- Daten für Tabelle `movies`
-- 


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

-- 
-- Tabellenstruktur für Tabelle `progs`
-- 

CREATE TABLE `progs` (
  `id` int(10) unsigned NOT NULL auto_increment COMMENT 'id der CD',
  `bid` int(10) unsigned default NULL COMMENT 'id der Person die ausgeliehen hat',
  `titel` varchar(100) collate latin1_german1_ci NOT NULL,
  `type` enum('CD','DVD') collate latin1_german1_ci NOT NULL,
  `quantity` int(10) unsigned NOT NULL,
  `discription` mediumtext collate latin1_german1_ci NOT NULL,
  `date` date default NULL,
  PRIMARY KEY  (`id`),
  KEY `titel` (`titel`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1 COLLATE=latin1_german1_ci PACK_KEYS=0 COMMENT='Tabelle für Programme, Spiele, etc.' AUTO_INCREMENT=1 ;

-- 
-- Daten für Tabelle `progs`
--

Mir scheint der Nicht-objektorientierte Aufbau des Scripts wesentlich einfacher und logischer, aber wie gesagt, wenn's geht würde ich es schon gerne in OOP aufbauen!

Danke für eure Hilfe,
Muuhmann
 
Du denkst insofern falsch, als dass du dir kein astreines CD-Objekt vorstellen kannst. Überlege dir doch, was für Eigenschaften eine CD im wahren Leben hat:

Titel, Interpret, Erscheinungsdatum,Musikstücke....

Code:
class CD {
   private $_titel;
   private $_interpret;
   private $.....

   public function CD($titel,$interpret,.......) {
       $this->_titel = $titel;
       $this->_interpret = $interpret;
       ........
   }

   //Methoden/Funktionen, die eine CD besitzt
}
Die OOP soll vor allem das Handling mit vielen Datensätzen erleichtern. Wenn du über ein Webinterface-Formular nun eine CD einträgst, so kannst du die eingegebene Daten in einer neuen Instanz von "CD" ablegen und später ganz einfach mit den Daten spielen. Um den Interpret einer CD zu erfragen, geht das halt immer mit $meineCD->interpret. Der Interpret selbst könnte auch wieder eine Instanz einer "Interpret"-Klasse sein, anstatt einer einfachen Variablen. So könnte der Interpret genauer beschrieben werden (Vorname,Nachname,Geburtsdatum...) und du könntest bspw. über $meineCD->interpret->geburtsdatum das Geburtsdatum des Interpreten deiner CD abrufen.

Natürlich kannst du das Spiel weitertreiben und dir eine "CD-Sammlung" abstrahieren:

Code:
class CDSammlung {
    private $_cds;
    private $_cdanzahl;

    public function CDSammlung() {
         $this->_cdanzahl = 0;
         $this->_cds = new array(); //ka ob das stimmt..kann kein PHP ;)
    }

    public function Add($cd) {
        $this->_cds[$this->_cdanzahl++] = $cd;
    }
    
    public function Remove($cd) {
        ........
    }

     //Weitere Methoden einer CD-Sammlung
}
Was ein CD-Objekt und ein CD-Sammlung-Objekt aber nicht beschreibt ist, wie eine CD irgendwo abgespeichert wird. Dafür ist dann wiederum ein anderes Objekt zuständig, z.B. eine "CD-Datenbank", welche z.B. zum Abspeichern CD-Objekte entgegen nimmt oder ganze CD-Sammlungen:

Code:
class CDDatenbank {
    //Methoden wie Add,Remove... welche die einzelnen CD-Objekte in einer
    //Datenbank abspeichern.
}
Das Prinzip einer solchen Datenbank-Schnittstelle sollte auch schnell deutlich werden. Hast du irgendwann mal vor, die Datenbank zu ändern, z.B. von MySQL auf kA.., so musst du dir lediglich eine neue CDDatenbank-Klasse erstellen, welche du dann an der entsprechenden Stelle instanzierst (anstatt der bisherigen DB-Klasse) - alles andere bleibt unangetastet.
 
Zuletzt bearbeitet:
mhmh

das klingt einleuchtend. ich danke dir schonmal für deine Erklärung. Ich denk das hat mich was weiter gebracht.
Ich würde aber auch gerne noch andere Meinungen einholen ;)
 
was fuer tipps? womit hast du noch probleme?
 
z.B. was bedeutet das "_" vor den Variablen von kuehnch ? Hab das irgendwie in keinem Buch bis jetzt gesehen, was das bedeuten soll

bzw wieso er das gemacht hat... das es nichts besonderes bedeutet weiß ich .. aber waurm? was war die intention dahinter? übersichtlicher?
 
Zuletzt bearbeitet:
Würd ich doch mal behaupten, ansonsten sind's globale, von PHP beanspruchte Variablen: '$_GET', '$_POST', '$_SERVER'´etc.

//edit: oh erst grad gesehen was Du meinst. Siehe Satz 1...
 
mhmh.. sagt mir jetzt nicht viel ;D

also.. Ich komme damit irgendwie nciht klar, wie ich die Klassen aufbaue.. Ich möchte ja, dass alles auf MySQL basiert, also habe ich mir eine MySQL-Klasse geschrieben, damit's auch schön OOP ist...
Aber Wozu brauche ich jetzt die CD-Klassen? die Daten werden ja (eigentlich) direkt in die DB geschrieben und direkt aus ihr ausgelesen, dafür brauch ich dann doch keine CD-Klassen mehr, oder?
Oder soll ich das so programmieren, dass die Daten aus der Datenbank in das CD-Objekt eingelesen werden und ich dann statt mit "normalen" variablen wie $interpret , dann mit $objekt->interpret auf den Interpreten zu greife?

Wie ihr seht habe ich gravierende Probleme mich von dem prozedualen zu lösen und mich in das objekt orientierte einzudenken..
Ist für mich alles ziemlich verwirrend..
 
Muuhmann schrieb:
mhmh.. sagt mir jetzt nicht viel ;D

also.. Ich komme damit irgendwie nciht klar, wie ich die Klassen aufbaue.. Ich möchte ja, dass alles auf MySQL basiert, also habe ich mir eine MySQL-Klasse geschrieben, damit's auch schön OOP ist...
Aber Wozu brauche ich jetzt die CD-Klassen? die Daten werden ja (eigentlich) direkt in die DB geschrieben und direkt aus ihr ausgelesen, dafür brauch ich dann doch keine CD-Klassen mehr, oder?
Oder soll ich das so programmieren, dass die Daten aus der Datenbank in das CD-Objekt eingelesen werden und ich dann statt mit "normalen" variablen wie $interpret , dann mit $objekt->interpret auf den Interpreten zu greife?

Wie ihr seht habe ich gravierende Probleme mich von dem prozedualen zu lösen und mich in das objekt orientierte einzudenken..
Ist für mich alles ziemlich verwirrend..

Also vielleicht solltest du dich erstmal damit befassen was OOP eigentlich genau ist. Die Datenbank dient "lediglich" dazu die Daten zu speichern, das kann aber auch alles andere sein z.B. gewöhnliche Dateien, eine Tabelle auf einer Website (wäre zwar schwachsinnig aber prinzipiel möglich). Objekte dienen dazu das ganze Programm abstrakt zu halten. Du kannst mit den Objekten, wie in deinem Fall eine CD arbeiten ohne zu wissen wo etwas hinerlegt ist. Um allerdings wirklich von OOP sprechen zu können, sollte dein GESAMTES Programm auf OO basieren.

Deine DB könntest du z.B. als CD-Archiv bezeichnen. Nun könntest du dir vorstellen in diesem Archiv arbeitet eine Person der dieses Archiv bis ins kleinste Detail kennt. Dem sagst du was du haben willst das wären die Methoden. Ein kleines Beispiel:

CD-Archiv:
existieren_cds_mit_n_liedern( n ) (Rückgabe: Ja/Nein )
gib_mir_alle_cds_des_interpreten( interpret ) (Rückgabe: CDs)
usw.

Wenn du also etwas aus diesem Archiv haben möchtest kommst du an keinem punkt mit der Datenbank direkt in Berührung, was auch genau das Ziel von OOP ist. Wie das ganze intern funktioniert ist dabei auch vollkommen unwichtig. Gerade aus diesem Grund tuen sich viele Leute schwer die von prozeduraler auf OO-Programmierung umsteigen. Wenn du das Prinzip korrekt verstanden hast, musst du dich auch nicht mehr um korrekte Werte kümmern, ein Objekt kann nur korrekte Werte zurückliefern (mal vorausgesetzt die Klasse ist korrekt designt). Deshalb ist es auch wichtig zuerst das Klassenmodell zu entwerfen BEVOR du mit der implementierung beginnst. Und dabei ist es meist am einfachsten sich an der Realität zu orientieren.

CD:
gib_mir_den_interpreten()
gib_mir_die_anzahl_der_titel()
gib_mir_die_spielzeit_von( titelnr )
gib_mir_die_spielzeit_von( liedname )
gibt_es_auf_der_cd_das_lied ( liedname )
usw.

Am Beispiel der CD wirst du aber bereits merken das es durchaus Sinn macht die CD nicht für sich allein zu sehen, da die CD strenggenommen nur ein Datenträger ist und verschiedene Lieder beinhaltet die für sich eigentlich auch bereits eine Klasse darstellen.

Als Tipp (auch wenn mich dafür wohl einige foltern werden) ließ dir mal das Buch "Objektorientierte Programmierung mit Java" (ISBN: 3-8273-7073-6) durch, dannach sollte dir klar sein was genau ein Objekt ist. Das Buch ist zwar für Java behandelt aber OOP mehr im allgemeinen und ist vom Aufbau her klar an Anfänger gerichtet.
 
jepp das ist es. Allerdings sei vorgewarnt du lernst dort "nur" die Konzepte von OOP.
 
also nichts, was noch mehr mit java zutun hätte?
mir wurde nämlich jetzt schon ziemlich oft empfohlen mich in java einzuarbeiten..
 
Zwangsläufig ja, aber es wird dir nicht vermittelt wie ein Javaprogramm in dem Sinn aufgebaut ist. Es bringt dir allerdings die Konzepte näher und das finde ich ist ersteinmal bedeutend wichtiger als die Syntax einer bestimmten Sprache zu beherrschen. Aber gerade als Anfänger solltest du ersteinmal die Konzepte kennen und ob in 15 Jahren noch in Java entwickelt wird sei mal dahingestellt. Aber wie gesagt die Konzepte sind das entscheidende und die werden sich so schnell nicht ändern.
 
Zurück
Oben