Ankündigung

Einklappen
Keine Ankündigung bisher.

OOP mit Funktionen?

Einklappen

Neue Werbung 2019

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

  • #31
    Ich als Anfänger möchte mich auch mal zu dem Thema äußern, da ich mich gerade mal wieder mit OOP beschäftige (und deshalb auch auf diese Diskussion gestoßen bin).
    Aber wieso möchte ich mich denn mit OOP beschäftigen?
    Dazu passt eigentlich die Aussage von drsoong sehr gut:

    Zitat von drsoong Beitrag anzeigen
    Die vorherrschende Meinung war halt, dass man ohne OOP zu den gestrigen Deppen gehört.
    Ich denke das ist EIN Grund wieso ich mich damit beschäftige. Ich hab irgendwie immer das Gefühl ich bin nur ein Programmierer zweiter Klasse wenn ich kein OOP benutze, bzw. es ist nicht professionell genug (muss es in meinem Fall zwar nicht sein, aber wer will schon ewig ein Amateur bleiben ).
    Ein anderer Grund ist aber auch der, dass ich bei meinem privaten Projekt mittlerweile bei ca. 6.000 Zeilen Code angekommen bin, Tendenz mit weiteren Funktionalitäten stark steigend. Ich mach mir deshalb schon länger darüber Gedanken ob ich vielleicht die Struktur meines Programms ändern sollte um den Überblick besser behalten zu können. Und da wird ja dann immer OOP ins Spiel gebracht, bessere Lesbarkeit, Wiederverwertbarkeit von Code, etc... alles was hier ja auch schon aufgezählt wurde.

    Ich persönlich würde sagen, dass :
    - es von der Größe des Projekts abhängig ist, ob ich OOP verwende. Und damit meine ich nicht unbedingt nur die Anzahl der Zeilen Code, sondern eher die Komplexität des Projekts
    - es abhängig davon ist ob es ein Projekt für mich persönlich ist, oder ob ich es professionell (also quasi kommerziell) erstelle. Dann würde ich eigentlich OOP voraussetzen.
    - es abhängig davon ist ob ich das Projekt alleine entwickle oder noch andere daran mitarbeiten. Ich schreib mein Programm alleine, weiß also wo ich welche Funktionen mit welchen Parametern, Übergabewerte, Returns etc. habe (noch weiß ich es). Wird es jedoch komplexer und andere arbeiten auch noch am Projekt mit, ich habe also Schnittstellen zu anderen, dann wird es vermutlich kritisch.

    Aber das sind alles Einschätzungen von einem Hobbyprogrammierer wie mir. Das können die Profis unter euch sicher besser beurteilen.

    Trotzdem möchte ich mich aber mit OOP auseinandersetzen und es "erlernen", zum einen aus "Neugier" und zum anderen weil ich mein Projekt vielleicht doch "vereinfachen" kann.

    Und jetzt komm ich zum eigentlichen Punkt der mich immer und immer wieder beschäftigt und welcher drsoong super auf den Punkt gebracht hat :

    Zitat von drsoong Beitrag anzeigen
    Der Nachteil ist vlt., dass man vor lauter Konzepten wie Design-Patterns, Vererbung, Interfaces, Abstraktionen etc. gar nicht mehr erkennt, wie man all das zusammen und sinnvoll verwenden soll.
    Als Anfänger liest man so viel von DesignPattern etc., schaut sich Beispiele an, und versteht meistens nur Bahnhof weil die Zusammenhänge schwierig zu verstehen sind.
    Und da komm ich nun zu BlackScorp . Ich als Anfänger würde es nicht gut finden wenn ich OOP mit Hilfe von Funktionen erklärt bekommen würde. Denn genau dann entstehen ja die Fragen "Hää, wieso soll ich denn das mit Objekten machen, geht doch so viel einfacher.".
    Mich nerven schon immer die Beispiele in den Büchern oder sonstiger Literatur mit einer Klasse Auto, oder Tier, oder sonst was. Denn genau diese "einfachen" Beispielen verleiten einen zu sagen "Das geht mit Spaghetti-Code und Funktionen viel einfacher.".
    OOP ist aber eben ein anderer Ansatz, und da hab ich noch sehr viel Probleme diesen Ansatz auf mein eigenes Projekt zu übertragen.

    Kommentar


    • #32
      Da bekomme ich gerade eine E-Mail in der steht: ""DerAmateur hat dich soeben in einem Beitrag erwähnt.".

      Das hat mich natürlich sofort "alarmiert".

      @DerAmateur: Danke für die positive Erwähnung. Vlt. darf ich Dir folgendes Vorschlagen:

      Vertrau mal darauf, dass die sich hier nicht alle völlig irren und fange mal an, mit einfachen OOP Ansätzen loszulegen. Ich habe auch erst im Laufe der Zeit gemerkt, was mir das bringt.

      Als erstes könntest Du doch mal einen einfachen Autoloader registrieren, siehe spl_autoload_register und freue Dich, dass Deine Klassen dann automatisch eingebunden werden, wenn Du sie brauchst...

      Netten Gruß
      Es ist schon alles gesagt. Nur noch nicht von allen.

      Kommentar


      • #33
        DerAmateur ich kann das völlig nachvollziehen, nur weiß ich dass OOP nicht umbedingt OOP ist nur weil du Klassen benutzt. Als erstest wirst du höchstwahrschienlich statische Methoden in einer Klasse haben weil es für dich aktuell als Sinnvoll erscheint, und dann wirst du von dort aus weiter machen mit Design Pattern usw und selbst nachdem du alle Design Pattern auswendig gelernt hast wirst du dennoch nicht wissen wieso du die eigentlich einsetzt.

        Ich möchte auch nicht an losen Beispielen alles erklären sondern wirklich mit einem Projekt, welches immer komplexer und komplexer wird und sich später komplett umwandelt. Nur Funktionen heißt nicht direkt Spaghetti-Code. Ich habe im Letzten Video ein kleines "Framework" erstellt, damit hast du schon die Möglichkeit Module einzubauen, saubere Routen zu definieren und HTML von PHP zu trennen. Das sind schon mal die Grundlagen wieso ein Spaghetti-Code entsteht. Weil alles zusammen geschmissen wird.

        Ich mache ja an dem Projekt weiter mit weiteren Videos und irgendwann wir das Framework komplett verworfen und ich nutze dann bis dahin ein aktuell Framework. Du kannst gut lesbaren Code auch ohne OOP hinkriegen und auch komplexe Projekte damit umsetzen. Guck dir JavaScript Libraries an. JavaScript(ich weiß, nicht NodeJs) hat keine OOP Funktionalität, du hast keine Interfaces, du kannst nicht ableiten, du kannst nichts als Private/Protected deklarieren, dennoch kommen die komplexesten Libraries bei raus und dennoch werden Deisgn Pattern eingehalten .Es hat ja ein Grund wieso Functional Programming so beliebt ist.

        Für mich ist hier das Thema gegessen ich mach einfach mein Ding und gucke dann was passiert, ewig reden führt ja auch zu nichts
        apt-get install npm -> npm install -g bower -> bower install <package> YOLO https://www.paypal.me/BlackScorp | Mein Youtube PHP Kanal: https://www.youtube.com/c/VitalijMik

        Kommentar


        • #34
          Zitat von drsoong Beitrag anzeigen

          Vertrau mal darauf, dass die sich hier nicht alle völlig irren und fange mal an, mit einfachen OOP Ansätzen loszulegen. Ich habe auch erst im Laufe der Zeit gemerkt, was mir das bringt.

          Als erstes könntest Du doch mal einen einfachen Autoloader registrieren, siehe spl_autoload_register und freue Dich, dass Deine Klassen dann automatisch eingebunden werden, wenn Du sie brauchst...

          Netten Gruß
          Ja das mit dem Autoload hatte ich mir auch schon mal angeschaut, das war sehr interessant. Dann würden die Includes schon mal weniger.

          Die Frage für mich als Anfänger ist ja gerade: Was sind "einfache" OOP-Ansätze? Hast du dann einfach mal aus den bisherigen Funktionen Klassen draus gemacht?

          Kommentar


          • #35
            Zitat von DerAmateur Beitrag anzeigen

            Die Frage für mich als Anfänger ist ja gerade: Was sind "einfache" OOP-Ansätze? Hast du dann einfach mal aus den bisherigen Funktionen Klassen draus gemacht?
            Man sollte einfach versuchen auch in Objekten zu denken beim entwickeln. Man überlegt sich nicht "welche Funktionen" brauche ich, sondern aus welchen Objekten besteht meine Anwendung.
            Objekte sind dabei dann, wie man es oft hört, vergleichbar mit Objekten im echten Leben. Bezogen auf eine PHP Webseite könnte man sich folgende Objekte vorstellen:
            Request, Response, Template, User usw.

            Jetzt mal als nächstes Beispiel ein Counter. Man stellt sich also vor, wie würde so ein Counter aussehen? Wahrscheinlich hat er einen Button + ein Button - und eine Taste zum anzeigen des aktuellen Wertes. Irgendwo intern muss der aktuelle Wert natürlich zwischengespeichert werden.

            Als PHP Objekt könnte so etwas dann wie folgt aussehen:
            PHP-Code:
            class Counter {
              private 
            $value;

                public function 
            __construct(int $startValue) {
                    
            $this->value $startValue;
                }

                public function 
            add() {
                   
            $this->value $this->value 1;
                }

                public function 
            dec() {
                    
            $this->value $this->value 1;
                }

                public function 
            getCurrentValue(): int {
                   return 
            $this->value;
                }
            }

            // Hier werden dann zwei Instanzen der vorher erstellten Klasse instanziert.
            $counter = new Counter(1);
            var_dump($counter->getCurrentValue());  // 1
            $counter->add();
            var_dump($counter->getCurrentValue());  // 2

            $counter2 = new Counter(10);
            var_dump($counter2->getCurrentValue()); // 11
            $counter2->add();
            var_dump($counter2->getCurrentValue()) // 12 
            Man sieht hier also, die Klasse hat auch 3 von Außen ("public") verfügbare Interaktionsmöglichkeiten: add, dec, getCurrentValue. Wenn man so vorgeht, finde ich ist die OOP Programmierung, nicht unbedingt ein Hexenwerk.

            Kommentar


            • #36
              Zitat von DerAmateur Beitrag anzeigen

              Ja das mit dem Autoload hatte ich mir auch schon mal angeschaut, das war sehr interessant. Dann würden die Includes schon mal weniger.

              Die Frage für mich als Anfänger ist ja gerade: Was sind "einfache" OOP-Ansätze? Hast du dann einfach mal aus den bisherigen Funktionen Klassen draus gemacht?
              Die Einfachen Ansätze wären erst mal Klassen ohne Vererbung und ohne Interfaces, alle von einander los gelöst doch du musst erstmal wissen was es so für typische Komponenten gibt in einem Projekt.

              also du musst wissen was von deinem Code zum Bereich "Routing" gehört, du musst wissen was von deinem Code zum "Template" gehört, was ist davon eine "Action" vom Routing. Und was ist "Daten Repository"

              dann musst du in deinem Code immer EVA einhalten. Sobald du diese Teilbereiche hast, kannst du deine Funktionen in Dateien nach den Bereichen aufteilen, danach einfach die Funktionen in Klassen verpacken. Dann merkst du, ach ja die Klassen rufen sich intern auf, eigentlich müssen die von außen konfiguriert werden befor die in Routen aufgerufen werden. Dazu nutzt du dann ein DI-Container und so weiter und so fort Ab hier wird es nicht mehr einfach
              apt-get install npm -> npm install -g bower -> bower install <package> YOLO https://www.paypal.me/BlackScorp | Mein Youtube PHP Kanal: https://www.youtube.com/c/VitalijMik

              Kommentar


              • #37
                DerAmateur Es wäre vielleicht gut, wenn Du wirklich mit Beispielen wie dem Auto, Tisch usw. anfängst. OOP ist ohne jegliche Erfahrung in der Tat schwierig. Als weiterführenden Tipp - auch in Hinblick auf die Vorschläge der anderen - skizziere Deine Applikation doch einfach mal händisch auf einem Blatt Papier. Objekte repräsentieren eben nicht nur Entitäten der "wirklichen Welt" sondern auch abstraktere wie eben z. B. ein HTTP-Request. Versuche, diese Bestandteile in Objekte zu transformieren und in Relation zueinander zu setzen.

                EDIT: Die Sache ist auch die, dass die meisten von einem Entwickler voraussetzen, dass er OOP (wenn auch nicht nach der reinen Lehre beherrscht), einfach weil es durch viele Hochsprachen weiter verbreitet ist (Java, PHP etc.). Außer z. B. Java erfordern es die meisten Sprachen zwar nicht, aber in den letzten Jahrzehnten (?) hat es sich eben doch herauskristallisiert, eben weil es doch _relativ_ leicht erlernbar ist. Eine sich selbst verstärkende Entwicklung also.

                Mittlerweile ist aber das Paradigma der funktionalen Programmierung wieder auf dem Vormarsch, was allerdings wesentlich schwerer zu erlenen ist.

                Kommentar

                Lädt...
                X