Klassen - Verwendung, Verknüpfung, ...

Also ich ärgere mich hier mit Klassen.
Das Erstellen ist ja relativ einfach (google ect). Aber ich bekomm "Kopfschmerzen", wenn es darum geht Klassen richtig einzusetzen und schon von Anfang an die Zugehörigkeit bzw Eigenständigkeit festzulegen.

Wollte mir eine "raw-webpage" basteln. sinn und Zweck des Ganzen: Entpacken, starten - und das wichtigste (db, tables, ordner ...) erstellt sich eigenständig.

Angefangen hatte ich mit den, was bei jeder Webseite passiert - den Fehler. Also Klasse zu Error-loggen erstelt.
Passt auch. Die Klasse ist komplett eigenständig und könnte von jedem sofort benutzt werden.

Das Problem:
Um so mehr man schreit, desto mehr MUSS (?) man die Sachen miteinander verknüpfen, richtig?

Als Bsp.:
1. class FileAccess # schreibt content in file (beim Aufruf von $errors->schreibjetze('text');)
2. class SQL # alles drin und dran für mysql

Um beide zu nutzen muss ich sie ja initialisieren(heisst es so?):
$errors = new FileAccess;
$sql = new SQL;

Jetzt mein Problem damit:
wenn ich im Hauptscript eine sql Query per $sql->... nutze und in der Klasse SQL ein Fehler auftritt,
dann müsste ich ja $errors in die public function mit rein schicken. Somit ist die Klasse SQL abhängig von der anderen Klasse (FileAccess).

Hoffe ich konnte mich verständlich ausdrücken
Jetzt die eigentliche Frage: Ist es denn überhaupt möglich alles voneinander unabhängig zu schreiben? Oder ist das scheiss egal?

Also erzeuge ich keine Objekte wie $sql = new SQL;
und ich ... habs gerade gelesen: http://php.net/manual/de/language.oop5.abstract.php

Wer hat sich denn das ausgedacht?
Aber - ich verstehs und ich denke das krich ich hin =)
Wird nur bissl fummelei sein das jetz alles umzuschreiben.

aber eins versteh ich noch net:

Zitat

// Die abgeleitete Klasse zwingen, diese Methoden zu definieren

Die Klasse, die von der Elternklasse abgeleitet wird, muss diese functions definieren - sonst error?
Was ist der Sinn dahinter?

ne lass mal - hab mir interfaces angesehen und entschieden, dass ich das jetzt nicht brauche

Aber abstract ist gut. Ich kannte schon "static". Wobei man zB eine function aufrufen kann (ClassName::functionName();), ohne ein object von der class zu erstellen.
Aber ich denke mit "abstract class" geht noch mehr.
Hab mal versucht ein grundgerüst zu erstellen:

class FileAccess
{
    public static function write($file,$text)
    {
        echo 'FileAccess --would write "'.$text.'" into file "'.$file.'"<br />';
    }
}




abstract class SQL
{
    public static function connect($config)
    {
        if($config){ /*actually try/catch ...*/
            return 'SQL true; --connected<br />';
        }else{
            self::errorhandler('error[connection failed]','sql_no_con');
            return 'SQL false; --not connected<br />';
        }
    }
    public static function execQuery($sql)
    {
        if($sql){ /*actually try/catch ...*/
            return 'SQL true; --query executed<br />';
        }else{
            self::errorHandler('error[sql query failed]','sql_no_qry');
            return 'SQL false; --query not executed<br />';
        }
    }




    private static function errorHandler($exception,$msg_key)
    {
        global $error_user,$error_log,$msgs,$lang;




        $error_user[] = $msgs[$msg_key][$lang];
        $error_log->write('error.txt',$exception);




        return;
    }
}




class Login extends SQL
{
    public function searchUser()
    {
        return $this->execQuery(false);
    }
}










$lang = 'de'; /*user settings: language*/
$msgs = array( /*array of multi-lang messages*/
    'sql_no_con' => array(
        'de' => 'Error: Verbindung zur Datenbank fehlgeschlagen!',
        'en' => 'Error: connection to the data base failed!',
    ),
    'sql_no_qry' => array(
        'de' => 'Error: query na ...!',
        'en' => 'Error: query no ...',
    ),
);
$error_log = new FileAccess; /*global error log*/
$error_user = array('error one'); /*array of e-messages to print on screen*/




echo SQL::connect(false);




$login = new Login;
echo $login->searchUser();







echo '<pre>$error_user-';
print_r($error_user);

Beim errorHandler() bin ich mir wieder nicht sicher. Aber ich muss ja irgentwo irgentwie die "original"-e-message abfangen und weitergeben .

Ich glaub ja. php.net beschreibt es genauso.
Was ich oben an php code bsp geposted hab ist übrigens quark in sachen abstract, weil das eher ein bsp für static ist.
Abstract hat da drin gar keinen sinn

Also ist das was ich brauch static.

Edit:
Was haltet ihr von dem "Grundgerüst":

class InDateiSchreiben
{/*schreibt alles was reinkommt in die log*/}




class SQL extends InDateiSchreiben
{/*durch "extends" kann ich ja jetzt hier $this->schreiben(); nutzen*/}




class Login extends SQL
{/*und da das hier eine Enkelklasse ist, kann ich ja $this->schreiben() und $this->sqlQuery() nutzen*/}

Ist das korrekt(sinnvoll)?

Ja, also ich hab mich jetzt doch entschieden es so zu lassen wie es schon war.

Eine class für sql, welche alle functionen hat, die ich so brauch.
Query rein, result und/oder fehler raus.

Um die Fehler zu handeln gibts wieder ne extra class -> fehler rein, loggen ect, fertig.

Ansonsten würde ich ja die Klassen nur voneinander abhängig machen. Und das will ich ja nicht.
Ist zwar mehr code im Hauptscript, aber ich kann die Klassen überall nutzen, entfernen usw, ohne dass was passiert.