Ankündigung

Einklappen
Keine Ankündigung bisher.

Wozu brauche ich eigentlich eine abstrakte Klasse?

Einklappen

Neue Werbung 2019

Einklappen
X
  • Filter
  • Zeit
  • Anzeigen
Alles löschen
neue Beiträge

  • #16
    Zitat von BlackScorp Beitrag anzeigen
    hm.. ich verwende es in meiner page klasse . die basis klasse hat die methode displayHTMLCode() als abstrakt und die kindklasse legt fest, was dargestellt werden soll danach kann ich beliebige page mit der methode displayHTMLCode aufrufen, es kommt dann je nach klasse ein anderer inhalt... bin aber auch noch am üben
    Ich kann mich grad nicht wirklich in dein Beispiel rein versetzen, aber es sollte Aufgabe des Views sein Dateien mit Html Code zu laden und die Daten die im Html ausgegeben werden sollten vom Controller überstellt werden.
    Aus dem Dynamo Lande kommen wir. Trinken immer reichlich kühles Bier. Und dann sind wir alle voll, die Stimmung ist so toll. Aus dem Dynamo Lande kommen wir.
    [URL]http://www.lit-web.de[/URL]

    Kommentar


    • #17
      O.K., ich denke, langsam habe ich's kapiert:
      • Abstrakte Klassen zwingen den/die Programmierer eine gewisse Logik und Struktur ein zu halten.
      • Innerhalb abstrakter Klassen können abstrakte Methoden aufgeführt und Methoden konkret definiert werden - das unterscheidet sie von Interfaces. In Interfaces darf es nämlich nur abstrakte Methoden geben.
      • Ist eine Methoden abstrakt so muss sie in der Kindklassen definiert werden.
      • Aus einer abstrakten Klasse kann niemals direkt ein Objekt erzeugt werden (in meinem Code-Bsp. aus Posting 1 z.B.: new tier; geht nicht! Es geht nur class giraffe extends tier {..}


      Das ist zumindest meine Zusammenfassung aus diesem Thread.

      Kommentar


      • #18
        Abstrakte Klassen zwingen den/die Programmierer eine gewisse Logik und Struktur ein zu halten.
        Naja nicht so direkt, abstrakte Klassen zwingen den Programmierer zu gar nichts, sie bieten ihm nur eine ideale Schnittstelle die sie in vielen Klassen verwenden können. Beispiele gab es ja genug. Keine Programmierer wird gezwungen eine Logik einzuhalten, denn ein Programmierer kann seine logische herangehensweise trotzdem behalten und die ihm zur Verfügung gestellte Schnittstelle nutzen.

        Innerhalb abstrakter Klassen können abstrakte Methoden aufgeführt und Methoden konkret definiert werden - das unterscheidet sie von Interfaces. In Interfaces darf es nämlich nur abstrakte Methoden geben.
        In Interfaces gibt es soweit ich weis gar keine abstrakten Methoden. Richtig ist aber das Methoden in Interfaces nur deklariert werden können, also so in der Art von Prototypen. Der Unterschied liegt auch darin das man in abstrakten Klassen Properties definieren und verwenden kann, bei Interfaces nicht. Ich glaube es ist auch so das Methoden in Interfaces nur public sein können, in abstrakten Klassen hast du aber auch die Möglichkeit sie auf protected und private zu setzen, in wie fern was Sinn macht kommt auf den Anwendungsfall an.

        Ist eine Methoden abstrakt so muss sie in der Kindklassen definiert werden.
        Nein sie muss nicht definiert werden, sie muss einfach nur aufgeführt werden. Das heist beim parsen des PHP Codes muss die abstrakte Methode in der erbenden Klasse vorhanden sein. Definiert muss sie nicht zwingend sein. Sie muss nur so vorkommen wie sie in der abstrakten Klasse deklariert wurde, also mit genau der Anzahl an Parametern.

        Aus einer abstrakten Klasse kann niemals direkt ein Objekt erzeugt werden (in meinem Code-Bsp. aus Posting 1 z.B.: new tier; geht nicht! Es geht nur class giraffe extends tier {..}
        Das hast du richtig erkannt.
        Aus dem Dynamo Lande kommen wir. Trinken immer reichlich kühles Bier. Und dann sind wir alle voll, die Stimmung ist so toll. Aus dem Dynamo Lande kommen wir.
        [URL]http://www.lit-web.de[/URL]

        Kommentar


        • #19
          Zitat von litterauspirna Beitrag anzeigen
          Ich kann mich grad nicht wirklich in dein Beispiel rein versetzen, aber es sollte Aufgabe des Views sein Dateien mit Html Code zu laden und die Daten die im Html ausgegeben werden sollten vom Controller überstellt werden.
          das gilt aber nur wenn man MVC verwendet, da ich noch nicht soweit bin, verwende ich normale klassen mit bisschen vererbung usw... und da funktioniert es halt ganz gut mit abstrakten klassen zu hantieren.
          apt-get install npm -> npm install -g bower -> bower install <package> YOLO [URL]https://www.paypal.me/BlackScorp[/URL] | Mein Youtube PHP Kanal: [url]https://www.youtube.com/c/VitalijMik[/url]

          Kommentar


          • #20
            Zitat von echo Beitrag anzeigen
            1. Man kann auch mit "normalen" Klassen alles erreichen, was man mit abstrakten Klassen erreicht
            2. Die einzigen zusätzlichen Funktionalitäten/Vorteile, die abstrakte Klassen bilden sind:
              1. Man kann Models besser strukturieren
              2. Gerade bei Projekten mit mehr als einem Entwickler sinnvoll
            3. Gerade, wenn man nur alleine für sich programmiert ohne dass andere Entwickler beteiligt sind, kann man durchaus auf abstrakte Klassen verzichten
            Theoretisch kannst du auch ohne OOP alles erreichen, was du mit OOP erreichen kannst. OOP (etwa normale Klassen) ist ein High-Level-Hilfsmittel, sozusagen ein in Syntax gegossener Standardbauplan für Quellcode. Klassen strukturieren und hierarchisieren und simplifizieren den Quellcode eines Projekts, indem gleichartige Funktionalität gekapselt und mit Sichtbarkeiten versehen wird. Das schafft eine definiertere Schnittstellenlogik zwischen einzelnen Klassen und einzelnen Programmteilen und verringert die Komplexität, denn von außerhalb einer Klasse sind nur noch die öffentlichen Methoden ansprechbar. Du hast als Entwickler an einer bestimmten Stelle der Anwendung dann nicht mehr die Wahl zwischen 300 möglichen Funktionsaufrufen, sondern nur noch zwischen denjenigen, die dein aktueller Klassenkontext bereitstellt.

            Interfaces und abstrakte Klassen sind dann noch einmal weitere Hilfsmittel, Struktur in die Codebasis zu bringen.

            Ein Interface ist vor allem interessant für Calltips außerhalb der Vererbungshierarchie. Sagen wir, ich habe eine Methode log, der irgendein Objekt übergeben werden kann, das nichts zu können braucht, außer eine Methode getLastEvent zu implementieren. Ob ich irgendeine Instanz von Tier damit loggen will oder eine Instanz meiner Klasse XMLParser, ist egal. Ich definiere also: function log(Loggable $obj). Damit kann der Methode nur noch ein Objekt übergeben werden, das dieses Interface implementiert. Das verringert wiederum die Komplexität.

            Wollte ich statt des Interfaces eine Klasse verwenden (also Loggable als Klasse definieren), müsste ich Tier und XMLParser und was sonst noch so geloggt werden können soll von Loggable ableiten. Wenn ich eine Klasse definiere, die selbst nicht geloggt werden können soll, aber deren Kindklassen eventuell geloggt werden könnten, muss ich dennoch die Elternklasse von Loggable erben lassen, da den Kindklassen sonst die Funktion nicht zur Verfügung steht (keine Mehrfachvererbung möglich). Soll eine Klasse nicht nur „loggable“ sein, sondern auch noch „searchable“ oder so, müsste Loggable von Searchable abgeleitet werden oder umgekehrt, was dann allerdings alle Klassen, die wiederum davon abgeleitet werden, sowohl loggable als auch searchable machen würde, sodass keine Unterscheidung mehr möglich wäre. Das klappt also vorne und hinten nicht. Deshalb gibt es Interfaces.

            Abstrakte Klassen sind ebenfalls wichtige Calltips, bieten dazu aber noch die Möglichkeit der Redundanzvermeidung. Sobald ich ein Set von Klassen habe, die sich manche Funktionalität teilen, in anderen Funktionen aber abweichen, können abstrakte Klassen sinnvoll sein. Nehmen wir die Klasse XMLParser. Die hat vielleicht eine Methode loadFromFile, eine Methode parse und soll zudem loggable sein. Analog dazu gibt es nun weitere Parser. Zum Beispiel den CSSParser. Seine Methode loadFromFile ist funktional identisch mit der von XMLParser und auch diese Klasse soll wie jeder Parser loggable sein.

            Was mache ich? Ich erstelle abstract class ParserAbstract implements Loggable, definiere darin die abstrakte Methodensignatur für eine Methode parse und füge außerdem den konkreten Code der Methode loadFromFile hinzu, da dieser überall identisch ist. Wenn ich Lust habe und es sinnvoll ist, implementiere ich auch gleich die getLastEvent-Methode aus Loggable. XMLParser und CSSParser brauchen dann nur noch davon zu erben und jeweils die Methode parse zu implementieren. So wird redundanter Code vermieden (siehe auch DRY-Prinzip).

            Erneut der Vergleich mit einer „normalen“ (nicht abstrakten) Elternklasse Parser: Diese müsste zusätzlich die Methode parse implementieren, die dann in jeder erbenden Parser-Klasse überschrieben werden müsste. Das muss der Programmierer im Kopf behalten, denn es ist in der Syntax nicht mehr offensichtlich und es wird auch keine Fehlermeldung generiert, wenn die Methode nicht überschrieben wird. Zudem wäre die Elternklasse Parser instanziierbar. Dass das inhaltlich keinen Sinn ergibt, muss der Programmierer ebenfalls im Kopf behalten. Anders gesagt: Die Komplexität in der Anwendung ist höher als beim Einsatz einer abstrakten Klasse.

            So wie normale Klassen und Sichtbarkeiten die Komplexität einer Codebasis verringern, tun dies auch Interfaces und abstrakte Klassen. Zudem werden bereits zur Compile-Zeit Fehlermeldungen geworfen, wenn der Programmierer gegen eine Regel verstößt oder die Realisierung einer abstrakten Methode vergessen hat.

            Zitat von echo Beitrag anzeigen
            Abstrakte Klassen zwingen den/die Programmierer eine gewisse Logik und Struktur ein zu halten.
            Ja, im Prinzip trifft es das, wenn du „zwingen“ nicht als negativ empfindest. (Zwang ist meist gut, weil eindeutig.) Sie sind unter anderem ein Werkzeug, Flüchtigkeitsfehler zu vermeiden.

            Innerhalb abstrakter Klassen können abstrakte Methoden aufgeführt und Methoden konkret definiert werden - das unterscheidet sie von Interfaces. In Interfaces darf es nämlich nur abstrakte Methoden geben.
            Zur Unterscheidung siehe auch oben. Zudem ist der Punkt, dass Interfaces der Vererbungshierarchie enthoben sind (also auch zu abgeleiteten Klassen hinzugefügt werden können, deren Elternklasse das Interface nicht implementiert hat), in PHP sehr wesentlich.

            Ist eine Methoden abstrakt so muss sie in der Kindklassen definiert werden.
            Fast. Auch die Kindklasse kann wiederum als abstrakt markiert werden und muss dann nicht alle Methoden implementieren, sondern gibt diese Aufgabe an die „Enkel“ ab. Eine Klasse, die eine nicht realisierte abstrakte Methode enthält, ist immer insgesamt abstrakt.

            Aus einer abstrakten Klasse kann niemals direkt ein Objekt erzeugt werden (in meinem Code-Bsp. aus Posting 1 z.B.: new tier; geht nicht! Es geht nur class giraffe extends tier {..}
            Passt.

            Kommentar


            • #21
              Abstrakte Methoden

              Ist eine Methoden abstrakt so muss sie in der Kindklassen definiert werden.
              ..wurde tw. verneint.

              PHP-Code:
              <?php
              abstract class tier{

                abstract public function 
              foo();

                public function 
              bar(){
                  
              //
                
              }

              }

              class 
              fisch extends tier{

                public function 
              baz(){
                  
              //
                
              }
                
              }

              $fisch = new fisch();
              ====>
              Fatal error: Class fisch contains 1 abstract method and must therefore be declared abstract or implement the remaining methods (tier::foo)
              auch
              PHP-Code:
              class fisch extends tier{
              abstract public function 
              foo();
                public function 
              baz(){
                  
              //
                
              }
                

              feuert einen Fatal error.

              Nur:
              PHP-Code:
              <?php
              abstract class tier{

                abstract public function 
              foo();

                public function 
              bar(){
                  
              //
                
              }

              }

              class 
              fisch extends tier{
              public function 
              foo(){}
                public function 
              baz(){
                  
              //
                
              }
                
              }

              $fisch = new fisch();
              funktioniert!

              Ergo: Abstrakte Methoden in abstrakten Klassen müssen in Kind-Klassen definiert werden, oder??

              Zum Thema Zwang: De facto ist es schon ein Zwang. Aber positiv betrachtet (siehe auch mermshaus Post) hilft es einfach nur dem Programmierer, nix zu vergeßen.

              Kommentar


              • #22
                Zitat von mermshaus
                Eine Klasse, die eine nicht realisierte abstrakte Methode enthält, ist immer insgesamt abstrakt.
                Du kannst deine schöne Vererbungshierarchie nur dann instanziieren, wenn du schließlich eine Klasse hast, in der sämtliche abstrakten Methoden implementiert vorliegen.

                Bitte die Doku dazu lesen:

                - http://php.net/manual/en/language.oop5.abstract.php

                (Edit: Hm, die könnte an der Stelle ausführlicher sein…)

                PHP-Code:
                abstract class lebewesen
                {
                    abstract public function 
                foo();
                }

                abstract class 
                tier extends lebewesen
                {
                    abstract public function 
                bar();

                    public function 
                baz() {}
                }

                class 
                fisch extends tier
                {
                    public function 
                foo() {}
                    public function 
                bar() {}
                }

                $fisch = new fisch(); 

                Kommentar


                • #23
                  Zitat von echo Beitrag anzeigen
                  Ergo: Abstrakte Methoden in abstrakten Klassen müssen in Kind-Klassen definiert werden, oder??
                  Letztendlich ja, meine "kleinlichen" Vorposter meinten soetwas:
                  PHP-Code:
                  abstract class tier
                  {
                    abstract public function 
                  foo();
                  }

                  abstract class 
                  fisch extends tier
                  {  
                  }

                  class 
                  barsch extends fisch

                      public function 
                  foo()
                      {        
                      }
                  }

                  $barsch = new barsch(); 
                  Die ebenfalls abstrakte Kindklasse "fisch" implementiert nicht die Methode "foo". Erst in der nächsten Vererbungsstufe wird die Methode implementiert.

                  Kommentar


                  • #24
                    @hts
                    Danke, jetz kapier ich.

                    Ja, man nuss da echt total umdenken, wenn man 1.Laie ist und 2.die ganze Zeit nur mit Spaghetti-Code herum gemacht hat.

                    Kommentar


                    • #25
                      Meiner Meinung nach ist "die Methode muss existieren" und "die Methode ist definiert" das selbe.

                      Kommentar


                      • #26
                        Zitat von litterauspirna Beitrag anzeigen
                        ...in abstrakten Klassen hast du aber auch die Möglichkeit sie auf protected und private zu setzen...
                        Ich bin mir gerade nicht ganz sicher, aber private dürfte nicht funktionieren.

                        Kommentar


                        • #27
                          Mit einer abstracten Methode hast du die Möglichkeit sicherzustellen das alle das ein und selbe Objekt , Variable verwenden nicht verwechseln mit dem Singlton.

                          So ist möglich das man über die Abstracte mehre Objekte verwalten kann und damit auch Kontrollieren das nur erlaubte sachen durchgeführt werden können. Kurz gesagt man baut sich ein Schutz system auf das verhindert das man unbeabsichtig laufzeitfehler miteinbaut.

                          Hier mal ein Beispiel was ich vor langen mal geschrieben habe. (Verwaltet mehre Objekte)

                          PHP-Code:
                          <?php
                          /**
                          * Abstrace Gruppen 
                          * @version 1.2
                          * @author Splasch
                          * @Filename: absgruppen.php
                          * Benutzer Verwaltung
                          **/ 
                          if (version_compare(PHP_VERSION'5'))
                          {
                              die(
                          'Dieses File wurde generiert für PHP 5');
                          }
                          abstract class 
                          Absgruppen
                          {
                              private 
                          $gruppen = array(); # Gruppen Objekte 
                              
                          private $allName = array(); # Namen aller Instanzierten Gruppen
                          /**
                          * Neue Gruppe den User hinzufügen
                          * @param $gruppe Objekt 
                          * @param $name String
                          * @return void
                          */
                          abstract public function addGruppe(Gruppe $gruppe,$name); 
                          /**
                          * Neues Objekt der Gruppe in Array Speichern und den Gruppen Namen
                          * @param $gruppe Objekt 
                          * @param $name String
                          * @return void
                          * Nur hinzufügen wenn das Objekt noch nicht vorhanden ist
                          */
                          function setGruppe(Gruppe $gruppe,$name)
                          {
                           if(
                          is_object($this->gruppen[$name]))
                              {
                                  echo 
                          "Gruppe <b>".$name."</b> schon drin.<br>";
                            return;
                           }
                           
                          $this->gruppen[$name]=$gruppe;
                           
                          $this->allName[]=$name;
                          }
                          /**
                          * Gibt das Angeforderte Gruppen Objekt zurück
                          * @param $index String
                          * @return gruppen Objekt
                          */
                          function gibGruppe($index)
                          {
                              return 
                          $this->gruppen[$index];
                          }
                          /**
                          * Gibt die Namen Aller Gruppen zurück
                          * @param 
                          * @return array
                          */
                          function gibGrupNames()
                          {
                              return 
                          $this->allName;
                          }
                          }
                          ?>
                          Wie du hier sieht können auch Abstracte Klassen eigene Methoden beinhalten. Du kannst aber nie aus einer Abstracten Klasse direkt ein Objekt erstellen. Dies ist nur über die erbenden Klassen von der abstracten Klasse möglich.

                          Wie diese Klasse zum Beispiel
                          PHP-Code:
                          <?php
                          /**
                          * User
                          * @version 1.4
                          * @author Splasch
                          * @Filename: user.php
                          * Benutzer Verwaltung
                          **/ 
                          if (version_compare(PHP_VERSION'5'))
                          {
                              die(
                          'Dieses File wurde generiert für PHP 5');
                          }
                          class 
                          User extends Absgruppen 
                          {
                              protected 
                          $user_id 0;       # Benutzer Nummer
                              
                          protected $user_name '';    # Benutzer Name
                              
                          protected $user_mail '';    # E-Mail Adresse 
                          /**
                          * User Profil Eigenschaften füllen
                          * @param $profil array
                          * @return null
                          */
                          public function __construct($profil)
                          {
                              if(
                          is_array($profil))
                              {
                                  
                          $this->user_id=$profil['id'];
                                  
                          $this->user_name=$profil['name'];
                                  
                          $this->user_mail=$profil['mail'];
                              }
                              return 
                          false
                          }
                          /**
                          * Neue Gruppe den User hinzufügen
                          * @param $gruppe Objekt 
                          * @param $name String
                          * @return void
                          */
                          public function addGruppe(Gruppe $gruppe,$name)
                          {
                              
                          $this->setGruppe($gruppe,$name);
                          }
                          /**
                          * Gibt das Angeforderte Gruppen Objekt zurück
                          * @param $index String
                          * @return gruppen Objekt
                          */
                          public function getGruppen($index)
                          {
                              return 
                          $this->gibGruppe($index);
                          }
                          /**
                          * Gibt die Namen Aller Gruppen zurück
                          * @param 
                          * @return array
                          */
                          public function getGrupNames()
                          {
                              return 
                          $this->gibGrupNames();
                          }
                          /* end of class User */
                          ?>
                          Dadurch hat man eine Vorlage geschaffen an die sich die anderen erbende Klassen halten müssen. Dadurch wird eben verhindert das man umbewußt laufzeitfehler mit einbaut. Da alles Zentrall von einer stelle aus gerregelt wird.

                          Du kannst also nicht von auserhalb auf die Interne Objekte zugreiffen. Den direkt zugriffe auf abstrace Klassen sind nicht möglich.

                          Mfg Splasch

                          Kommentar


                          • #28
                            Mit einer abstracten Methode hast du die Möglichkeit sicherzustellen das alle das ein und selbe Objekt , Variable verwenden nicht verwechseln mit dem Singlton.
                            Glaube, die Gefahr ist eher gering. Ich weiß nicht, wie du das genau meinst, aber „das alle das ein und selbe Objekt , Variable verwenden“, ist so definitiv nicht richtig.

                            So ist möglich das man über die Abstracte mehre Objekte verwalten kann und damit auch Kontrollieren das nur erlaubte sachen durchgeführt werden können. Kurz gesagt man baut sich ein Schutz system auf das verhindert das man unbeabsichtig laufzeitfehler miteinbaut.
                            Das ist relativ richtig, wenn du damit Type-Hinting umschreiben möchtest. Das ist allerdings keine besondere Eigenschaft abstrakter Klassen. Kindklassen können zudem die Methoden der Elternklasse überschreiben. (Ich habe einen gewissen Verdacht, dass es darum gehen könnte.)

                            Zu dem Code selbst fällt mir nicht viel ein. Aber „User extends Gruppe“ finde ich fragwürdig.

                            Kommentar


                            • #29
                              Naja nicht so direkt, abstrakte Klassen zwingen den Programmierer zu gar nichts, sie bieten ihm nur eine ideale Schnittstelle die sie in vielen Klassen verwenden können.
                              Stimmt nicht. Solange man das zugrundeliegende Pattern nutzen will (also die Basisklasse oder aber eine Klasse, die bspw. ein Objekt des abstrakten Typs komponiert), ist man de facto gezwungen, das Interface zu bedienen.
                              Ist eine Methoden abstrakt so muss sie in der Kindklassen definiert werden.
                              Nein sie muss nicht definiert werden, sie muss einfach nur aufgeführt werden.
                              Stimmt nicht. Sie muß definiert werden oder darf nicht aufegführt sein! Siehe obige Ausführungen zum Thema abstract erbt von abstract.

                              Sinnvoll für den Einsteiger ist machmal vielleicht, rückwärts zu denken.
                              1. Welche konkreten Objekte brauche ich
                              2. Welche Gemeinsamkeiten (funktional, also Methoden, und semantisch also bspw, alles Tiere, Säugetiere ...) haben diese Objekte. Hieraus erstellen wir Elternklassen
                              3. Welche diese Elternklassen sind überhaupt noch eigenständige Objekte? Definieren manche nur noch bestimmte Helper oder eine funktionale Basis, ohne selbständig lauffähig zu sein? Sind sie semantisch abstrakt, also eben „Tier“, mit dem der „Bauer“ als Begriff nichts anfangen kann? -> als abstrakt deklarieren (muss dabei nicht zwingend abstrakte Methoden fordern/definieren)
                              4. Objektverknüpfungen. Werden diese Objekte in anderen verwendet? Reichen die bisher herausgebildeten abstrakten Klassen, um die erwarteten Objekte zu charakterisieren?
                              4a. Wenn ja: die abstrakte Klasse als Type Hint verwenden, die alle erwarteten Objekte charakterisiert (das muss nicht die allgemeinste Klasse in der konkreten Klassenhierarchie sein!)
                              4b. Wenn nicht: werden nur bestimmte Verhalten des Objekts erwartet (nicht aber ein semantischer Kontext), ist es vielleicht sinnvoll, zusätzlich ein Interface zu definieren, das nur (!) die Methoden definiert, das der jeweilige Kontext von allen gültigen Parameter-Objekten benötigt. Da man mehrere Interfaces implementieren kann, ist es möglich, hier Teil-Schnittstellen zu definieren, bspw. render() für ein anzeigbares Objekt oder die klassischen Schnittstellen für ArrayAccess oder Traversable.
                              4bff. Hinterher kontrollieren, ob das Interface die abstrakten Methoden besser repräsentiert, als die vorher verwendete abstrakte Basisklasse. Evtl. entspr. Methoden aus der abstrakten Klasse herausnehmen und statt dessen das Interface implementieren.
                              [COLOR="#F5F5FF"]--[/COLOR]
                              [COLOR="Gray"][SIZE="6"][FONT="Georgia"][B]^^ O.O[/B][/FONT] [/SIZE]
                              „Emoticons machen einen Beitrag etwas freundlicher. Deine wirken zwar fachlich richtig sein, aber meist ziemlich uninteressant.
                              [URL="http://www.php.de/javascript-ajax-und-mehr/107400-draggable-sorttable-setattribute.html#post788799"][B]Wenn man nur Text sieht, haben viele junge Entwickler keine interesse, diese stumpfen Texte zu lesen.“[/B][/URL][/COLOR]
                              [COLOR="#F5F5FF"]
                              --[/COLOR]

                              Kommentar

                              Lädt...
                              X