tag:forum.selfhtml.org,2005:/selfInstanz um Methoden errweitern – SELFHTML-Forum2019-12-28T12:01:51Zhttps://forum.selfhtml.org/self/2019/dec/21/instanz-um-methoden-errweitern/1762036#m1762036pl2019-12-21T07:11:20Z2019-12-21T07:11:20ZInstanz um Methoden errweitern<p>Moin,</p>
<p>was in Perl geht:</p>
<pre><code class="block language-perl"><span class="token keyword">require</span> <span class="token string">"Mail"</span><span class="token punctuation">;</span>
<span class="token variable">$this</span><span class="token operator">-></span>sendmail<span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
</code></pre>
<p>d.h., die mit der nachgeladenen Datei eingebrachten Funktionen kann man mit <code>$this</code> aufrufen weil sie zum Namespace der aktuellen Klasse gehören.</p>
<p>In PHP jedoch ist es nicht möglich diese Funktionen mit <code>$this</code> aufzurufen. Wie löst PHP dieses Problem? Geht das evntl. in V > 5.3?</p>
<p>MFG</p>
https://forum.selfhtml.org/self/2019/dec/21/instanz-um-methoden-errweitern/1762037#m1762037Tabellenkalk2019-12-21T08:47:17Z2019-12-21T08:47:17ZInstanz um Methoden errweitern<p>Hallo,</p>
<p>dein Betreff passt nicht zur gestellten Frage, bzw. zu deinem „Problem“.</p>
<p>Um eine Methode eines Objektes aufzurufen, musst du in der Regel erstmal ein solches instanziieren.</p>
<p>Gruß<br>
Kalk</p>
https://forum.selfhtml.org/self/2019/dec/21/instanz-um-methoden-errweitern/1762039#m17620391unitedpower2019-12-21T09:41:11Z2019-12-21T09:41:11ZInstanz um Methoden errweitern<blockquote>
<p>In PHP jedoch ist es nicht möglich diese Funktionen mit <code>$this</code> aufzurufen. Wie löst PHP dieses Problem? Geht das evntl. in V > 5.3?</p>
</blockquote>
<p>Mit <a href="https://www.php.net/manual/en/language.oop5.traits.php" rel="nofollow noopener noreferrer">Traits</a>.</p>
https://forum.selfhtml.org/self/2019/dec/21/instanz-um-methoden-errweitern/1762047#m1762047Rolf B2019-12-21T14:51:05Z2019-12-21T14:51:05ZInstanz um Methoden errweitern<p>Hallo pl,</p>
<p>das hier versteht PHP nicht (mailer.inc enthält nur die function sendMail):</p>
<pre><code class="block bad language-php"><span class="token keyword">class</span> <span class="token class-name-definition class-name">Dings</span> <span class="token punctuation">{</span>
<span class="token keyword">require</span> <span class="token string double-quoted-string">"mailer.inc"</span><span class="token punctuation">;</span>
<span class="token keyword">public</span> <span class="token keyword">function</span> <span class="token function-definition function">MailIt</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token punctuation">{</span>
<span class="token variable">$this</span><span class="token operator">-></span><span class="token function">sendMail</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span>
<span class="token punctuation">}</span>
</code></pre>
<p>Aber du kannst mit anonymen Funktionen (ab 5.3 vorhanden) etwas machen:</p>
<p>Datei mailer.inc</p>
<pre><code class="block bad language-php"><span class="token php language-php"><span class="token delimiter important"><?php</span>
<span class="token keyword">return</span> <span class="token keyword">function</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token punctuation">{</span>
<span class="token keyword">echo</span> <span class="token string double-quoted-string">"I can send a mail\n"</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span>
</span></code></pre>
<p>und die Verwendung:</p>
<pre><code class="block bad language-php"><span class="token keyword">class</span> <span class="token class-name-definition class-name">Foo</span> <span class="token punctuation">{</span>
<span class="token keyword">public</span> <span class="token keyword">function</span> <span class="token function-definition function">DoMail</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token punctuation">{</span>
<span class="token variable">$sendMail</span> <span class="token operator">=</span> <span class="token keyword">include</span> <span class="token string double-quoted-string">"mailer.inc"</span><span class="token punctuation">;</span>
<span class="token variable">$sendMail</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span>
<span class="token comment">// oder so</span>
<span class="token keyword">public</span> <span class="token keyword">function</span> <span class="token function-definition function">MooMail</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token punctuation">{</span>
<span class="token variable">$this</span><span class="token operator">-></span><span class="token property">sendMail</span> <span class="token operator">=</span> <span class="token keyword">include</span> <span class="token string double-quoted-string">"mailer.inc"</span><span class="token punctuation">;</span>
<span class="token punctuation">(</span><span class="token variable">$this</span><span class="token operator">-></span><span class="token property">sendMail</span><span class="token punctuation">)</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span>
<span class="token punctuation">}</span>
</code></pre>
<p>In MooMail sind die Klammern wichtig, sonst sucht er eine Methode sendMail, findet das Property und moppert. PHP ist nicht JavaScript.</p>
<p>Dann ist die anonyme Funktion, die mailer.inc zurückgibt, nur im Kontext der DoMail Methode oder der Foo-Klasse vorhanden.</p>
<p>Aber ich würde das nicht tun. Im Sinne von SoC gehört der Mailer mit sehr hoher Wahrscheinlichkeit in eine eigene Klasse. Damit es keine Namenskollisionen gibt, legen wir auch noch einen Namespace drumherum (ebenfalls ab PHP 5.3):</p>
<p>mailer.inc</p>
<pre><code class="block good language-php"><span class="token php language-php"><span class="token delimiter important"><?php</span>
<span class="token keyword">namespace</span> <span class="token package">rost<span class="token punctuation">\</span>mail</span><span class="token punctuation">;</span>
<span class="token keyword">class</span> <span class="token class-name-definition class-name">Mailer</span> <span class="token punctuation">{</span>
<span class="token keyword">public</span> <span class="token keyword">function</span> <span class="token function-definition function">send</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token punctuation">{</span>
<span class="token keyword">echo</span> <span class="token string double-quoted-string">"I can send a mail\n"</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span>
<span class="token punctuation">}</span>
</span></code></pre>
<p>und die Verwendung:</p>
<pre><code class="block good language-php"><span class="token keyword">class</span> <span class="token class-name-definition class-name">Foo</span> <span class="token punctuation">{</span>
<span class="token keyword">public</span> <span class="token keyword">function</span> <span class="token function-definition function">DoMail</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token punctuation">{</span>
<span class="token keyword">require_once</span> <span class="token string double-quoted-string">"mailer.inc"</span><span class="token punctuation">;</span>
<span class="token variable">$mailer</span> <span class="token operator">=</span> <span class="token keyword">new</span> <span class="token class-name class-name-fully-qualified"><span class="token punctuation">\</span>rost<span class="token punctuation">\</span>mail<span class="token punctuation">\</span>Mailer</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token variable">$mailer</span><span class="token operator">-></span><span class="token function">send</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span>
<span class="token punctuation">}</span>
</code></pre>
<p>Die Mailer-Klasse ist dann auch außerhalb der Foo Klasse verfügbar, Klassendefinitionen sind immer global. Aber das schadet vermutlich nichts.</p>
<p><em>Rolf</em></p>
<div class="signature">-- <br>
sumpsi - posui - clusi
</div>
https://forum.selfhtml.org/self/2019/dec/21/instanz-um-methoden-errweitern/1762099#m1762099pl2019-12-22T11:29:17Z2019-12-22T11:29:17ZInstanz um Methoden errweitern<p>PS; Die Frage, wie man Instanzen um Methoden erweitert wo zum Zeitpunkt der Instanzerstellung noch gar nicht feststeht welche das sind und ob sie überhaupt gebraucht werden ist eine der Kernfragen praktischer OOP.</p>
<p>Schönen Sonntag.</p>
https://forum.selfhtml.org/self/2019/dec/21/instanz-um-methoden-errweitern/1762038#m1762038pl2019-12-21T08:49:59Z2019-12-21T08:49:59ZInstanz um Methoden errweitern<p>Hallo,</p>
<blockquote>
<p>dein Betreff passt nicht zur gestellten Frage, bzw. zu deinem „Problem“.</p>
<p>Um eine Methode eines Objektes aufzurufen, musst du in der Regel erstmal ein solches instanziieren.</p>
</blockquote>
<p>Die Instanz liegt ja vor. Wie gewöhnlich in <code>$this</code></p>
<p>MFG</p>
https://forum.selfhtml.org/self/2019/dec/21/instanz-um-methoden-errweitern/1762040#m1762040pl2019-12-21T10:42:10Z2019-12-21T10:42:10ZInstanz um Methoden errweitern<blockquote>
<blockquote>
<p>In PHP jedoch ist es nicht möglich diese Funktionen mit <code>$this</code> aufzurufen. Wie löst PHP dieses Problem? Geht das evntl. in V > 5.3?</p>
</blockquote>
<p>Mit <a href="https://www.php.net/manual/en/language.oop5.traits.php" rel="nofollow noopener noreferrer">Traits</a>.</p>
</blockquote>
<p>Ein Beispiel wäre gut. Du hast <code>$this</code> als Instanz der Klasse <code>Egal</code> und definierst eine Methode <code>extern()</code> in einem Trait den Du einbindest. Nun sollte man <code>$this->extern()</code> aufrufen können.</p>
<p>Kannst Du in dieser Methode <code>extern()</code> auch weitere Methoden der Klasse <code>Egal</code> mit <code>$this</code> aufrufen?</p>
<p>MFG</p>
https://forum.selfhtml.org/self/2019/dec/21/instanz-um-methoden-errweitern/1762041#m17620411unitedpower2019-12-21T12:01:11Z2019-12-21T12:01:11ZInstanz um Methoden errweitern<blockquote>
<p>Ein Beispiel wäre gut.</p>
</blockquote>
<p>In der Doku findest du auch Beispiele.</p>
<blockquote>
<p>Kannst Du in dieser Methode <code>extern()</code> auch weitere Methoden der Klasse <code>Egal</code> mit <code>$this</code> aufrufen?</p>
</blockquote>
<p>Hast du schon eine Suchmaschine gefragt oder es zumindest mal ausprobiert?</p>
https://forum.selfhtml.org/self/2019/dec/21/instanz-um-methoden-errweitern/1762046#m1762046Rolf B2019-12-21T14:24:43Z2019-12-21T14:24:43ZInstanz um Methoden errweitern<p>Hallo 1unitedpower,</p>
<p>kann man einen Trait nachträglich an eine Klasse ankleben?</p>
<p>Normalerweise sagt die Klasse doch <code>use MailTrait</code> als Teil der <code>class</code> Deklaration</p>
<p><em>Rolf</em></p>
<div class="signature">-- <br>
sumpsi - posui - clusi
</div>
https://forum.selfhtml.org/self/2019/dec/21/instanz-um-methoden-errweitern/1762056#m1762056pl2019-12-21T17:08:18Z2019-12-21T17:08:18ZInstanz um Methoden errweitern<blockquote>
<p>Ein Trait ist ein Begriff aus der objektorientierten Programmierung und beschreibt eine wiederverwendbare Sammlung von Methoden und Attributen, ähnlich einer Klasse. Desweiteren können diese Methoden von Instanzen beliebiger Klassen benutzt werden. Ein Trait selbst ist nicht instanziierbar.</p>
</blockquote>
<p>Anhand dieser Definition (wiki) ist es ja genau das was ich beabsichtige.</p>
<blockquote>
<p>In der Doku findest du auch Beispiele.</p>
</blockquote>
<p>Anhand derer erschließt es sich mir leider nicht inwiefern man mit dem was PHP unter einem Trait versteht obenstehendes Ziel erreicht.</p>
<p>MFG</p>
https://forum.selfhtml.org/self/2019/dec/21/instanz-um-methoden-errweitern/1762054#m17620541unitedpower2019-12-21T16:11:26Z2019-12-21T16:11:26ZInstanz um Methoden errweitern<blockquote>
<p>kann man einen Trait nachträglich an eine Klasse ankleben?</p>
</blockquote>
<blockquote>
<p>Normalerweise sagt die Klasse doch <code>use MailTrait</code> als Teil der <code>class</code> Deklaration</p>
</blockquote>
<p>Was meinst du genau mit nachträglich? Wenn man die use-Deklaration nicht statisch benutzen möchte, dann könnte man zur Laufzeit eine neue Klasse erzeugen, die von der ursprünglichen Klasse erbt und den(?) Trait verwendet:</p>
<pre><code class="block language-php">
<span class="token keyword">class</span> <span class="token class-name-definition class-name">Foo</span> <span class="token punctuation">{</span>
<span class="token punctuation">}</span>
<span class="token keyword">trait</span> <span class="token class-name-definition class-name">Bar</span> <span class="token punctuation">{</span>
<span class="token punctuation">}</span>
<span class="token variable">$foobar</span> <span class="token operator">=</span> <span class="token keyword">new</span> <span class="token keyword">class</span> <span class="token class-name-definition class-name">extends</span> <span class="token class-name">Foo</span> <span class="token punctuation">{</span>
<span class="token keyword">use</span> <span class="token package">Bar</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span>
</code></pre>
<p>Aber mir fällt dafür kein sinnvolles Anwendungsbeispiel ein.</p>
https://forum.selfhtml.org/self/2019/dec/21/instanz-um-methoden-errweitern/1762049#m1762049pl2019-12-21T15:17:39Z2019-12-21T15:21:41ZInstanz um Methoden errweitern<blockquote>
<p>Die Mailer-Klasse ist dann auch außerhalb der Foo Klasse verfügbar,</p>
</blockquote>
<p>So verstehen wir uns miss. Wenn Foo meine Klasse ist, gehts mir nur darum eine Foo-Instanz um die Mailfunktion zu erweitern.</p>
<p>Wobei die Mailfunktion in eine Datei ausgelagert gehört, damit sie auch von Instanzen anderer Klassen genutzt werden kann, nach demselben Mechanismus.</p>
<pre><code class="block language-php"><span class="token comment"># in einer beliebigen Methode einer beliebigen Klasse</span>
<span class="token comment"># haben wir die Instanz in $this</span>
<span class="token comment"># und das soll möglich sein: </span>
<span class="token keyword">require_once</span> <span class="token string double-quoted-string">"Mail.php"</span><span class="token punctuation">;</span>
<span class="token variable">$this</span><span class="token operator">-></span><span class="token function">mail</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
</code></pre>
<p>Mir ist klar, daß hier der Namespace erweitert werden muss. Aber was muss in Mail.php drinstehen? Wenn ich da <code>function mail(){}</code> zu stehen habe, wird diese Funktion in den globalen Namespace geladen. Sie soll jedoch zum Namespace derjenigen Klasse gehören die für Foo die Basisklasse ist.</p>
<p>MFG</p>
<p>Klassenhierarchie</p>
<pre><code class="block language-php"><span class="token keyword">class</span> <span class="token class-name-definition class-name">main</span><span class="token punctuation">{</span><span class="token punctuation">}</span>
<span class="token keyword">class</span> <span class="token class-name-definition class-name">Foo</span> <span class="token keyword">extends</span> <span class="token class-name">main</span><span class="token punctuation">{</span><span class="token punctuation">}</span>
<span class="token variable">$foo</span> <span class="token operator">=</span> <span class="token keyword">new</span> <span class="token class-name">Foo</span><span class="token punctuation">;</span>
<span class="token keyword">require_once</span> <span class="token string double-quoted-string">"Mail.php"</span><span class="token punctuation">;</span>
<span class="token variable">$foo</span><span class="token operator">-></span><span class="token function">mail</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
</code></pre>
https://forum.selfhtml.org/self/2019/dec/21/instanz-um-methoden-errweitern/1762051#m1762051Rolf B2019-12-21T15:44:18Z2019-12-21T15:50:06ZInstanz um Methoden errweitern<p>Hallo pl,</p>
<blockquote>
<p>gehts mir nur darum...</p>
</blockquote>
<p>Lass es mich anders formulieren: ICH WILL ABER. Ja gut. Kann ich ja verstehen. Man macht sich einen Plan und hört dann nicht gerne, dass das keine gute Idee ist.</p>
<p>Habe gerade noch die runkit-Erweiterung gefunden (findest Du im PHP Handbuch), aber ich würde das nicht tun. Diese Erweiterung scheint auch nicht unbedingt gut mit PHP 7 zu funktionieren.</p>
<p>Mit einem einfachen include ist es aber trotzdem nicht getan. Das ist im Konzept von PHP so nicht vorgesehen. Mal eben eine Methode an ein Objekt - oder schlimmer noch, an eine Klasse - zu schrauben, ist eine gefährliche Sache. Das Laufzeitverhalten kann dadurch völlig unvorhersehbar werden, vor allem wenn Vererbung ins Spiel kommt.</p>
<p>Was Du da haben willst, ist selbstmodifizierender Code, und das ist einer der brisantesten Footguns, seit Johnny Neumann Code und Daten in einen Speicher legte.</p>
<p>Siehst Du denn einen gravierenden Vorteil darin, den Mailer als Methode an die aktuelle Klasse zu schrauben, statt einfach ein Objekt einer Workerklasse zu erzeugen? Ich sehe es eher als nachteilig. Das Anschrauben der Methode bedeutet, diese Methode nachher in mehreren Klassen des Systems herumfliegen zu haben.</p>
<blockquote>
<p>Wobei die Mailfunktion in eine Datei ausgelagert gehört, <strong>damit sie auch von Instanzen anderer Klassen genutzt werden kann</strong></p>
</blockquote>
<p>Genau das ist das Signalwort für: Eigene Klasse!</p>
<p>Den Worker mit require_once zu holen bedeutet, die Implementierung genau einmal zu laden und dann nur noch von überall, wo sie gebraucht wird, zu verwenden. Es ist nur eine Codezeile mehr: $mailer = new Mailer();</p>
<p>Wenn es deine Absicht ist, dass der Mailer Methoden oder Eigenschaften der Klasse nutzt, in die er hinein geladen wird, dann warne ich erneut. Auch das führt in den OOS<sup class="footnote-ref"><a href="#fn1" id="fnref1">[1]</a></sup>-Abgrund. Wenn der Mailer Daten braucht, musst Du ihn damit versorgen. Er sollte sie sich nicht implizit selbst holen.</p>
<p>Eine halbwegs transparente Version des "selbst holens" kannst du mit Interfaces erreichen. Der Mailer bekommt beim new ein Objekt übergeben, das ein bestimmtes Interface implementiert. Über dieses Interface kann der Mailer seine Daten abrufen, und er kann mit <code>$dataprovider instanceof IMailerDataProvider</code> auch sicherstellen, dass in $dataprovider eine Implementierung dieses Interfaces geliefert wird.</p>
<p>Wenn Du einfach eine Methode mail bereitstellen musst, weil ein anderes Codestück das erwartet und du die Funktionsprinzipiien deines Perl-Frameworks möglichst unverändert abbilden willst, dann könntest Du die Methode in einer Basisklasse bereitstellen. Die Implementierung kann trotzdem in der Mailerklasse liegen: das bereitgestellte mail() ist lediglich ein Durchlauferhitzer, holt den Mailer mit require_once herein, instanziiert ihn und ruft ihn auf.</p>
<p><em>Rolf</em></p>
<div class="signature">-- <br>
sumpsi - posui - clusi
</div>
<hr class="footnotes-sep">
<section class="footnotes">
<ol class="footnotes-list">
<li id="fn1" class="footnote-item"><p>Objekt-Orientiertes Spaghetti <a href="#fnref1" class="footnote-backref">↩︎</a></p>
</li>
</ol>
</section>
https://forum.selfhtml.org/self/2019/dec/21/instanz-um-methoden-errweitern/1762052#m1762052pl2019-12-21T15:59:19Z2019-12-21T15:59:19ZInstanz um Methoden errweitern<p>In Perl führt da gar nichts in den Abgrund, ganz im Gegenteil: Code wir durch Teilung effizienter. Warum auch soll man einen Haufen Methoden kompilieren wenn man bestimmte Methoden davon nur gelegentlich braucht!?</p>
<p>Genauso kann man das natürlich auch mit Klassen machen und selbstverständlich auch mit PHP Klassen. <a href="https://rolfrost.de/plog.htm" rel="nofollow noopener noreferrer">Meine FW Interfaces</a> hab ich übrigens sowohl in Perl als auch in PHP so implementiert wie Du das beschrieben hast.</p>
<p>MFG</p>
https://forum.selfhtml.org/self/2019/dec/21/instanz-um-methoden-errweitern/1762053#m1762053Christian Krusehttps://wwwtech.de/2019-12-21T16:10:32Z2019-12-21T16:10:32ZInstanz um Methoden errweitern<p>Hallo pl,</p>
<p>you didn‘t get it.</p>
<p>Freundliche Grüße,<br>
Christian Kruse</p>
<div class="signature">-- <br>
<a href="https://wwwtech.de/about" rel="noopener noreferrer">https://wwwtech.de/about</a>
</div>
https://forum.selfhtml.org/self/2019/dec/21/instanz-um-methoden-errweitern/1762055#m1762055pl2019-12-21T16:51:07Z2019-12-21T16:51:07ZInstanz um Methoden errweitern<blockquote>
<p>In Perl führt da gar nichts in den Abgrund, ganz im Gegenteil: Code wir durch Teilung effizienter. Warum auch soll man einen Haufen Methoden kompilieren wenn man bestimmte Methoden davon nur gelegentlich braucht!?</p>
<p>Genauso kann man das natürlich auch mit Klassen machen</p>
</blockquote>
<p>D.h., man kann nicht nur sondern macht es zweckmäßigerweise auch so daß Klassen und -erweiterungen die Aufgabe spezialisieren.</p>
<p>In Perl ist es z.B. möglich, Klassen zu definieren wo sämtliche Methoden aus .so Dateien (XS) oder aus dem FS (Autoload) geladen werden. Zum Vermeiden von Coderedundanzen und zum Aufbau einer Factory ist sowas natürlich eine feine Sache.</p>
<p>Methoden einer Factory werden ja gerade deswegen ins FS ausgelagert wenn sie selber weiteren Code mit require einbinden der zum Ausführen einer Methode benötigt wird, bei der Instanzerstellung jedoch noch gar nicht verfügbar ist (i.e. Late Delegation).</p>
<p>MFG</p>
https://forum.selfhtml.org/self/2019/dec/21/instanz-um-methoden-errweitern/1762059#m1762059Rolf B2019-12-21T18:41:41Z2019-12-21T18:41:41ZInstanz um Methoden errweitern<p>Hallo 1unitedpower,</p>
<pre><code class="block language-php"><span class="token variable">$foobar</span> <span class="token operator">=</span> <span class="token keyword">new</span> <span class="token keyword">class</span> <span class="token class-name-definition class-name">extends</span> <span class="token class-name">Foo</span> <span class="token punctuation">{</span>
<span class="token keyword">use</span> <span class="token package">Bar</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span>
</code></pre>
<p>Das sieht gruselig aus. Da haben sie für PHP 7 aber schwer bei Java abgeguckt...</p>
<p>Tatsächlich, auf diese Weise könnte man die mail-Methode aus einem Mailer-Trait hinzumischen. Aber nur in dieser anonymen Subklasse. Und nicht mit PHP 5.3 </p>
<p><em>Rolf</em></p>
<div class="signature">-- <br>
sumpsi - posui - clusi
</div>
https://forum.selfhtml.org/self/2019/dec/21/instanz-um-methoden-errweitern/1762057#m17620571unitedpower2019-12-21T18:26:59Z2019-12-21T18:26:59ZInstanz um Methoden errweitern<blockquote>
<blockquote>
<p>Ein Trait ist ein Begriff aus der objektorientierten Programmierung und beschreibt eine wiederverwendbare Sammlung von Methoden und Attributen, ähnlich einer Klasse. Desweiteren können diese Methoden von Instanzen beliebiger Klassen benutzt werden. Ein Trait selbst ist nicht instanziierbar.</p>
</blockquote>
<p>Anhand dieser Definition (wiki) ist es ja genau das was ich beabsichtige.</p>
<blockquote>
<p>In der Doku findest du auch Beispiele.</p>
</blockquote>
<p>Anhand derer erschließt es sich mir leider nicht inwiefern man mit dem was PHP unter einem Trait versteht obenstehendes Ziel erreicht.</p>
</blockquote>
<p>Dann geh die Definition dochmal Satz für Satz durch:</p>
<blockquote>
<p>Ein Trait ist ein Begriff aus der objektorientierten Programmierung und beschreibt eine wiederverwendbare Sammlung von Methoden und Attributen, ähnlich einer Klasse.</p>
</blockquote>
<pre><code class="block language-php"><span class="token keyword">trait</span> <span class="token class-name-definition class-name">Foo</span> <span class="token punctuation">{</span>
<span class="token keyword">public</span> <span class="token keyword type-declaration">int</span> attribut <span class="token operator">=</span> <span class="token number">42</span><span class="token punctuation">;</span> <span class="token comment">// <-- Das ist ein Attribut</span>
<span class="token keyword">public</span> <span class="token function">methode</span> <span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token punctuation">:</span> <span class="token keyword return-type">void</span> <span class="token punctuation">{</span><span class="token punctuation">}</span> <span class="token comment">// <-- Das ist eine Methode</span>
<span class="token punctuation">}</span> <span class="token comment">// Das Trait ist eine Sammlung von Methoden und Attributen</span>
</code></pre>
<blockquote>
<p>Desweiteren können diese Methoden von Instanzen beliebiger Klassen benutzt werden.</p>
</blockquote>
<pre><code class="block language-php"><span class="token keyword">class</span> <span class="token class-name-definition class-name">A</span> <span class="token punctuation">{</span><span class="token keyword">use</span> <span class="token package">Foo</span><span class="token punctuation">;</span><span class="token punctuation">}</span> <span class="token comment">// <-- Das ist eine Klasse</span>
<span class="token keyword">class</span> <span class="token class-name-definition class-name">B</span> <span class="token punctuation">{</span><span class="token keyword">use</span> <span class="token package">Foo</span><span class="token punctuation">;</span><span class="token punctuation">}</span> <span class="token comment">// <-- Das ist auch eine Klasse</span>
<span class="token variable">$a</span> <span class="token operator">=</span> <span class="token keyword">new</span> <span class="token class-name">A</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment">// <-- Das ist eine Instanz der Klasse A</span>
<span class="token variable">$b</span> <span class="token operator">=</span> <span class="token keyword">new</span> <span class="token class-name">B</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment">// <-- Das ist eine Instanz der Klasse B</span>
<span class="token variable">$a</span><span class="token operator">-></span><span class="token property">attribut</span><span class="token punctuation">;</span> <span class="token comment">// Die Instanz von A kann Attribute des Traits verwenden</span>
<span class="token variable">$a</span><span class="token operator">-></span><span class="token function">methode</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment">// Die Instanz von A kann Methoden des Traits verwenden</span>
<span class="token variable">$b</span><span class="token operator">-></span><span class="token property">attribut</span><span class="token punctuation">;</span> <span class="token comment">// Die Instanz von B kann ebenfalls Attribute des Traits verwenden</span>
<span class="token variable">$b</span><span class="token operator">-></span><span class="token function">methode</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment">// Die Instanz von B kann ebenfalls Methoden des Traits verwenden</span>
</code></pre>
<blockquote>
<p>Ein Trait selbst ist nicht instanziierbar.</p>
</blockquote>
<pre><code class="block language-php"><span class="token variable">$foo</span> <span class="token operator">=</span> <span class="token keyword">new</span> <span class="token class-name">Foo</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment">// Das geht nicht. Das Trait kann nicht instanziiert werden.</span>
</code></pre>
https://forum.selfhtml.org/self/2019/dec/21/instanz-um-methoden-errweitern/1762058#m1762058Matthias Apselmatthias.apsel@selfhtml.orghttps://brückentage.info2019-12-21T18:39:58Z2019-12-21T18:40:18ZInstanz um Methoden errweitern<p>Hallo 1unitedpower,</p>
<blockquote>
<pre><code class="block language-php"><span class="token keyword">class</span> <span class="token class-name-definition class-name">A</span> <span class="token punctuation">{</span><span class="token keyword">use</span> <span class="token package">Foo</span><span class="token punctuation">;</span><span class="token punctuation">}</span> <span class="token comment">// <-- Das ist eine Klasse</span>
</code></pre>
</blockquote>
<p><code>A</code>? <code>Foo</code>? </p>
<p>Aber schön erklärt.</p>
<p>Bis demnächst<br>
Matthias</p>
<div class="signature">-- <br>
Du kannst das Projekt SELFHTML unterstützen,<br>
indem du bei Amazon-Einkäufen <a href="https://smile.amazon.de/ch/314-570-45498" rel="nofollow noopener noreferrer">Amazon smile</a> (<a href="https://www.amazon.de/gp/help/customer/display.html?ie=UTF8&nodeId=202035970%5D" rel="nofollow noopener noreferrer">Was ist das?</a>) nutzt.
</div>
https://forum.selfhtml.org/self/2019/dec/21/instanz-um-methoden-errweitern/1762060#m1762060pl2019-12-21T18:46:54Z2019-12-21T18:46:54ZInstanz um Methoden errweitern<p>Ahh jetzt verstehe. Löst aber das Problem nicht ganz: Es muss auch einer Möglichkeit geben, in der extern definierten Methode (Trait) auf die Eigenschaften der Instanz welche diese Metode aufruft, zugreifen zu können.</p>
<p>Also</p>
<pre><code class="block language-php"><span class="token variable">$a</span><span class="token operator">-></span><span class="token function">methode</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token comment">// Die Instanz von A kann Methoden des Traits verwenden</span>
</code></pre>
<p>kann man innerhalb <code>methode()</code> auf die Eigenschaften von $a zugreifen und kann $a innerhalb von <code>methode()</code> weitere Methoden aufrufen die in Traits deklariert sind?</p>
<p>MFG</p>
https://forum.selfhtml.org/self/2019/dec/21/instanz-um-methoden-errweitern/1762063#m1762063Der Martin2019-12-21T18:51:35Z2019-12-21T18:51:35ZInstanz um Methoden errweitern<p>Hallo,</p>
<blockquote>
<pre><code class="block language-php"><span class="token keyword">trait</span> <span class="token class-name-definition class-name">Foo</span> <span class="token punctuation">{</span>
<span class="token keyword">public</span> <span class="token keyword type-declaration">int</span> attribut <span class="token operator">=</span> <span class="token number">42</span><span class="token punctuation">;</span> <span class="token comment">// <-- Das ist ein Attribut</span>
<span class="token keyword">public</span> <span class="token function">methode</span> <span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token punctuation">:</span> <span class="token keyword return-type">void</span> <span class="token punctuation">{</span><span class="token punctuation">}</span> <span class="token comment">// <-- Das ist eine Methode</span>
<span class="token punctuation">}</span> <span class="token comment">// Das Trait ist eine Sammlung von Methoden und Attributen</span>
</code></pre>
</blockquote>
<p>an dieser Stelle muss ich mal ketzerisch (oder naiv?) fragen, warum man in der OOP Funktionen einer Klasse nicht mehr Funktionen nennt, sondern Methoden. Das ist mir schon vor vielen Jahren aufgefallen und irgendwie gegen den Strich gegangen, aber eine einleuchtende Erklätung konnte mir noch niemand anbieten.</p>
<p>In C++ beispielsweise ist eine Methode auch nur eine Funktion, nur dass sie indirekt über die Methodentabelle der Klasse aufgerufen wird und als erstes implizites Argument einen Zeiger auf die Instanz (in C++: self) übergeben bekommt.<br>
Also warum ein eigener Fachbegriff?</p>
<p>Ciao,<br>
Martin</p>
<div class="signature">-- <br>
Ich stamme aus Ironien, einem Land am sarkastischen Ozean.
</div>
https://forum.selfhtml.org/self/2019/dec/21/instanz-um-methoden-errweitern/1762062#m1762062pl2019-12-21T18:50:51Z2019-12-21T18:50:51ZInstanz um Methoden errweitern<blockquote>
<pre><code class="block language-php"><span class="token variable">$foobar</span> <span class="token operator">=</span> <span class="token keyword">new</span> <span class="token keyword">class</span> <span class="token class-name-definition class-name">extends</span> <span class="token class-name">Foo</span> <span class="token punctuation">{</span>
<span class="token keyword">use</span> <span class="token package">Bar</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span>
</code></pre>
<p>Das sieht gruselig aus.</p>
</blockquote>
<p>Das ist kein Code den ich morgen noch verstehen würde wenn ich den heute schreibe. MFG</p>
https://forum.selfhtml.org/self/2019/dec/21/instanz-um-methoden-errweitern/1762061#m17620611unitedpower2019-12-21T18:49:42Z2019-12-21T18:49:42ZInstanz um Methoden errweitern<blockquote>
<p>kann man innerhalb <code>methode()</code> auf die Eigenschaften von $a zugreifen und kann $a innerhalb von <code>methode()</code> weitere Methoden aufrufen die in Traits deklariert sind?</p>
</blockquote>
<p>Selbe Gegenfrage wie zuvor: Hast du schon eine Suchmaschine gefragt oder es zumindest mal ausprobiert?</p>
https://forum.selfhtml.org/self/2019/dec/21/instanz-um-methoden-errweitern/1762072#m1762072pl2019-12-21T19:15:55Z2019-12-21T19:15:55ZInstanz um Methoden errweitern<blockquote>
<p>Ahh jetzt verstehe. Löst aber das Problem nicht ganz: Es muss auch einer Möglichkeit geben, in der extern definierten Methode (Trait) auf die Eigenschaften der Instanz welche diese Metode aufruft, zugreifen zu können.</p>
<p>Also</p>
<pre><code class="block language-php"><span class="token variable">$a</span><span class="token operator">-></span><span class="token function">methode</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token comment">// Die Instanz von A kann Methoden des Traits verwenden</span>
</code></pre>
<p>kann man innerhalb <code>methode()</code> auf die Eigenschaften von $a zugreifen und kann $a innerhalb von <code>methode()</code> weitere Methoden aufrufen die in Traits deklariert sind?</p>
</blockquote>
<p>Nach meiner letzten Recherche ist das nicht möglich. PHP Traits stellen nur statische Methoden bereit, hab ich grad eben gelesen. Nette Spielerei </p>
<p>MFG</p>
https://forum.selfhtml.org/self/2019/dec/21/instanz-um-methoden-errweitern/1762064#m1762064pl2019-12-21T18:52:13Z2019-12-21T18:57:46ZInstanz um Methoden errweitern<blockquote>
<blockquote>
<p>kann man innerhalb <code>methode()</code> auf die Eigenschaften von $a zugreifen und kann $a innerhalb von <code>methode()</code> weitere Methoden aufrufen die in Traits deklariert sind?</p>
</blockquote>
<p>Selbe Gegenfrage wie zuvor: Hast du schon eine Suchmaschine gefragt oder es zumindest mal ausprobiert?</p>
</blockquote>
<p>Meine PHP Version <a href="https://forum.selfhtml.org/self/2019/dec/21/instanz-um-methoden-errweitern/1762036#m1762036" rel="noopener noreferrer">kennst Du?</a></p>
<p>Und es kommt nochwas dazu: Die externen Methoden sollen automatisch aufgerufen werden. Also in __call(). Diesen ganzen Komplex kann nur ein Praktiker kennen der schonmal was damit gemacht und auch darüber geschrieben hat. Und auch da macht eine Suchmaschine keinen Sinn, deswegen frag ich ja hier.</p>
<p>MFG</p>
https://forum.selfhtml.org/self/2019/dec/21/instanz-um-methoden-errweitern/1762065#m1762065Christian Krusehttps://wwwtech.de/2019-12-21T18:59:41Z2019-12-21T18:59:41ZInstanz um Methoden errweitern<p>Hallo Martin,</p>
<blockquote>
<p>an dieser Stelle muss ich mal ketzerisch (oder naiv?) fragen, warum man in der OOP Funktionen einer Klasse nicht mehr Funktionen nennt, sondern Methoden. […]</p>
<p>In C++ beispielsweise ist eine Methode auch nur eine Funktion, nur dass sie indirekt über die Methodentabelle der Klasse aufgerufen wird und als erstes implizites Argument einen Zeiger auf die Instanz (in C++: self) übergeben bekommt.<br>
Also warum ein eigener Fachbegriff?</p>
</blockquote>
<p>Weil die Nomenklatur genau diesen Unterschied kennzeichnet. Eine Methode ist eine Funktion, die an ein Objekt oder eine Klasse gebunden ist und deshalb Zugriff auf die internen Datenstrukturen (inklusive andere Methoden) des Objekts oder der Klasse hat.</p>
<p>Oder, um es noch mehr zu simplifizieren: eine Methode ist an ein Objekt oder eine Klasse gebunden. Eine Funktion ist unabhängig von einem Objekt oder einer Klasse. Das ist alles.</p>
<p>Freundliche Grüße,<br>
Christian Kruse</p>
<div class="signature">-- <br>
<a href="https://wwwtech.de/about" rel="noopener noreferrer">https://wwwtech.de/about</a>
</div>
https://forum.selfhtml.org/self/2019/dec/21/instanz-um-methoden-errweitern/1762066#m1762066pl2019-12-21T19:00:19Z2019-12-21T19:00:19ZInstanz um Methoden errweitern<p>Mir geht das auch gegen den Strich. Aber ehe ich das bei jedem meiner Posts erklären muss, verwende ich lieber gleich den Begriff Methode. So hat halt jeder seine Methoden. MFG</p>
https://forum.selfhtml.org/self/2019/dec/21/instanz-um-methoden-errweitern/1762071#m17620711unitedpower2019-12-21T19:15:17Z2019-12-21T19:15:17ZInstanz um Methoden errweitern<blockquote>
<p>an dieser Stelle muss ich mal ketzerisch (oder naiv?) fragen, warum man in der OOP Funktionen einer Klasse nicht mehr Funktionen nennt, sondern Methoden.</p>
</blockquote>
<p>Der Begriff "Objektorientierte Programmierung" wurde in den 70ern das erste mal von Alan Kay verwendet als er mit der Entwicklung von Smalltalk beschäftigt war. In den frühen Veröffentlichungen ist auch schon von Methoden die Rede. Simula ist noch älter als Smalltalk und gilt nach heutigem Maßstab als erste objektorientierte Programmiersprache, aber die Nomenklatur wurde eben von Smalltalk geprägt. C++ und Java sind erst Jahre nach Smalltalk erschienen. Diese Sprachen wurden auch als OOP Sprachen beworben, hatten aber mit Smalltalk und Simula nicht mehr viel zu tun. Alan Kay hat ürbigens mal gesagt, dass er die Wortwahl "objektorientiert" von damals bereut, weil der eigentliche Fokus für ihn auf "message passing" lag und nicht auf "Objekten".</p>
https://forum.selfhtml.org/self/2019/dec/21/instanz-um-methoden-errweitern/1762085#m1762085pl2019-12-22T07:55:52Z2019-12-22T07:55:52ZInstanz um Methoden errweitern<blockquote>
<p>warum man in der OOP Funktionen einer Klasse nicht mehr Funktionen nennt, sondern Methoden</p>
</blockquote>
<p>Der wesentliche Unterschied zur Funktion ist, daß beim Aufruf einer PHP Methode implizit die Instanz übergeben wird. So hat man innerhalb einer Methode Zugriff auf die Eigenschaften der Instanz und kann mit der Instanz weitere Methoden aufrufen.</p>
<p>In PHP ist dieser Sachverhalt durch die vordefinierte Variable <code>$this</code> hardcodiert. In Perl hingegen erfolgt die Übergabe explizit, d.h. entweder über den Pfeiloperator oder die Argumentenliste. Der Aufruf kann also so oder so erfolgen;</p>
<pre><code class="block">$f->foo();
foo($f);
</code></pre>
<p>Und innerhab einer Perl Methode kann man die Instanz benennen wie man will, gewöhnlich wird sie da <code>$self</code> genannt oder auch <code>$this</code> und muss als Solche stets aus der Argumentenliste extrahiert werden</p>
<pre><code class="block">sub foo{
my $self = shift;
}
</code></pre>
<p>Um die Verwirrung komplett zu machen; beim Aufruf einer Klassenmethode die auch statische Methoden genannt werden, wird nicht die Instanz übergeben sondern der Name der Klasse. In Perl;</p>
<pre><code class="block language-perl"><span class="token variable">$f</span> <span class="token operator">=</span> Foo<span class="token operator">-></span>new<span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
</code></pre>
<p>ist der Konstruktor also eine statische Methode welche die Instanz liefert und heißt gewühnlich <code>new()</code> wobei man diese Funktion auch anders nennen kann.</p>
<p>In PHP hingegen wird zwischen new und Konstruktor unterschieden. Noch verwirrender in PHP ist, Eigenschaften der Instanz klassenweit zu deklarieren obwohl noch gar keine Instanz existiert. Man kann aber auch in PHP die Eigenschaften innerhalb des Konstruktors vergeben, so sieht man auch daß die zur Instanz gehören und nicht zur Klasse.</p>
<p>MFG</p>
https://forum.selfhtml.org/self/2019/dec/21/instanz-um-methoden-errweitern/1762076#m17620761unitedpower2019-12-21T19:22:46Z2019-12-21T19:22:46ZInstanz um Methoden errweitern<blockquote>
<p>Meine PHP Version <a href="https://forum.selfhtml.org/self/2019/dec/21/instanz-um-methoden-errweitern/1762036#m1762036" rel="noopener noreferrer">kennst Du?</a></p>
</blockquote>
<p>Du weißt welches Jahr wir schreiben?</p>
https://forum.selfhtml.org/self/2019/dec/21/instanz-um-methoden-errweitern/1762067#m1762067pl2019-12-21T19:05:06Z2019-12-21T19:05:06ZInstanz um Methoden errweitern<blockquote>
<p>Eine Funktion ist unabhängig von einem Objekt oder einer Klasse.</p>
</blockquote>
<p>In Perl ist das nicht zutreffend. Da gibt es nämlich immer eine Klasse main und eine Klasse von der alle Klassen erben (UNIVERSAL). Da kann man sogar Builtinfunktionen überlagern weil das eben auch Methoden sind.</p>
<p>MFG</p>
<p>(Dass man nicht jede Builtinfunktion überlagern kann hat andere Gründe)</p>
https://forum.selfhtml.org/self/2019/dec/21/instanz-um-methoden-errweitern/1762068#m1762068Rolf B2019-12-21T19:09:55Z2019-12-21T19:14:33ZInstanz um Methoden errweitern<p>Hallo Christian,</p>
<p>eigentlich können wir uns ja glücklich schätzen, dass man die Dinger nicht „Empfänger“ (receiver) oder „Kanäle“ genannt hat. Denn die Idee von OOP ist ja <strong>eigentlich</strong>, dass man einen Schwarm von Objekten hat, die sich gegenseitig Botschaften schicken. Hinzu kommen noch Verknüpfungsbeziehungen (Assoziationen) wie Aggregation, Komposition und Vererbung. Und ein Objekt braucht Empfänger, um Botschaften zu verstehen. Oder verschiedene Kanäle, auf denen es unterschiedliche Typen von Botschaften bekommt.</p>
<p>Das, was man bspw. in C++ gemacht hat, nämlich Objekte auf Strukturen, Botschaften auf Funktionsaufrufe und Vererbung auf Schachtelung abzubilden, ist eine Möglichkeit wie man OOP betreiben kann. Vermutlich die performanteste, darum machen es alle Sprachen, die ich kenne, so. Aber es ist nicht die einzige.</p>
<p>Insofern ist es für mich schon ok, dass die Dinger <em>nicht</em> Funktionen heißen, sondern einen eigenen Namen haben. Der Begriff „Methode“ kommt vermutlich daher, dass er semantisch mit "Prozedur" verwandt ist. Und "prozedurale Programmierung" sagt uns ja allen noch was.</p>
<p><em>Rolf</em></p>
<div class="signature">-- <br>
sumpsi - posui - clusi
</div>
https://forum.selfhtml.org/self/2019/dec/21/instanz-um-methoden-errweitern/1762069#m1762069Christian Krusehttps://wwwtech.de/2019-12-21T19:11:14Z2019-12-21T19:11:14ZInstanz um Methoden errweitern<p>Hallo pl,</p>
<blockquote>
<blockquote>
<p>Eine Funktion ist unabhängig von einem Objekt oder einer Klasse.</p>
</blockquote>
<p>In Perl ist das nicht zutreffend.</p>
</blockquote>
<p>Doch, ist es. Du kannst in Perl eine Funktion ggfls. auch als Methode nutzen, aber sie muss damit umgehen können und um den Umstand wissen.</p>
<blockquote>
<p>Da gibt es nämlich immer eine Klasse main und eine Klasse von der alle Klassen erben (UNIVERSAL).</p>
</blockquote>
<p>Du wirfst Package und Class durcheinander. Und nein, das ist nicht dasselbe. Aus der Perldoc: „In Perl, any package <strong>can</strong> be a class. The difference between a package which is a class and one which isn't is based on how the package is used.“ – Hervorhebung von mir. Nur weil das Keyword <code>package</code> dort steht ist es keine Klasse. Und umgekehrt, nur weil das Keyword <code>package</code> dort steht ist es nicht keine Klasse.</p>
<blockquote>
<p>Da kann man sogar Builtinfunktionen überlagern weil das eben auch Methoden sind.</p>
</blockquote>
<p>Du kannst sie überschreiben, weil Perl eine dynamische Sprache ist.</p>
<p>Freundliche Grüße,<br>
Christian Kruse</p>
<div class="signature">-- <br>
<a href="https://wwwtech.de/about" rel="noopener noreferrer">https://wwwtech.de/about</a>
</div>
https://forum.selfhtml.org/self/2019/dec/21/instanz-um-methoden-errweitern/1762070#m1762070Christian Krusehttps://wwwtech.de/2019-12-21T19:14:57Z2019-12-21T19:14:57ZInstanz um Methoden errweitern<p>Hallo Rolf,</p>
<blockquote>
<p>eigentlich können wir uns ja glücklich schätzen, dass man die Dinger nicht „Empfänger“ (receiver) genannt hat.</p>
</blockquote>
<p>Der Empfänger wäre nicht die Methode, sondern das Objekt die Methode wäre die Nachricht, die man an das Objekt schickt.</p>
<p>Es gibt übrigens durchaus Programmiersprachen, die dieses Paradigma versuchen umzusetzen. Die berüchtigste wäre wohl Smalltalk. Aber auch modernere Sprachen wie Obj-C oder Ruby bedienen sich dieses Bildes.</p>
<blockquote>
<p>Das, was man bspw. in C++ gemacht hat, nämlich Objekte auf Strukturen, Botschaften auf Funktionsaufrufe und Vererbung auf Schachtelung abzubilden, ist eine Möglichkeit wie man OOP betreiben kann. Vermutlich die performanteste, darum machen es alle Sprachen, die ich kenne, so. Aber es ist nicht die einzige.</p>
</blockquote>
<p>Du kennst mindestens eine Sprache, deren OO-Konzept anders ist als das von C++. JavaScript. </p>
<p>Freundliche Grüße,<br>
Christian Kruse</p>
<div class="signature">-- <br>
<a href="https://wwwtech.de/about" rel="noopener noreferrer">https://wwwtech.de/about</a>
</div>
https://forum.selfhtml.org/self/2019/dec/21/instanz-um-methoden-errweitern/1762073#m1762073pl2019-12-21T19:18:31Z2019-12-21T19:18:31ZInstanz um Methoden errweitern<blockquote>
<p>Denn die Idee von OOP ist ja eigentlich, dass man einen Schwarm von Objekten hat, die sich gegenseitig Botschaften schicken.</p>
</blockquote>
<p>Ganz bestimmt nicht. Aber ich kenne Einige die so programmieren. MFG</p>
https://forum.selfhtml.org/self/2019/dec/21/instanz-um-methoden-errweitern/1762077#m1762077Rolf B2019-12-21T19:23:13Z2019-12-21T19:28:44ZInstanz um Methoden errweitern<p>Hallo Christian,</p>
<blockquote>
<p>die Methode wäre die Nachricht, die man an das Objekt schickt.</p>
</blockquote>
<p>Äh, nein. Zumindest habe ich das in Smalltalk anders gelernt. Die Botschaft ist das, was der Aufrufer abschickt (Name+Daten) und die Methode ist ein Feature des Empfängerobjekts, das für diese Botschaft zuständig ist.</p>
<blockquote>
<p>Du kennst mindestens eine Sprache, deren OO-Konzept anders ist als das von C++. JavaScript.</p>
</blockquote>
<p>Das Vererbungskonzept ist anders, ja. Objekte sind Strukturen (ok, dynamische Key-Value Listen) und Methoden-Aufrufe sind Funktionsaufrufe. D.h. der Kern der Kommunikation ist immer noch der gleiche.</p>
<p>Eine OOP Sprache mit echtem Messaging, das stelle ich mir so vor, dass jedes Objekt in einem eigenen Thread läuft, Botschaften in eine Input Queue gestellt bekommt, und im Falle von Vererbung die Botschaften, mit denen es nichts anfangen kann, analog zu den JS Prototypen an die nächsthöhere Instanz weiterschickt. Auch Properties werden über Messaging ausgelesen. Keine Ahnung, ob schon mal jemand sowas gebaut hat.</p>
<p>Auf einer etwas höheren Ebene läuft das CTI System von Genesys, das meine Firma einsetzt, so ab. Die Objekte sind eine Menge Dienste, die relativ feingranular aufgeteilt sind und auf einem oder 100 Servern laufen können, und die schicken sich über ein genormtes API eine MASSE an Botschaften via TCP. Wer das API kennt, kann mitfunken. Mach ich fleißig </p>
<p><em>Rolf</em></p>
<div class="signature">-- <br>
sumpsi - posui - clusi
</div>
https://forum.selfhtml.org/self/2019/dec/21/instanz-um-methoden-errweitern/1762074#m17620741unitedpower2019-12-21T19:20:34Z2019-12-21T19:20:34ZInstanz um Methoden errweitern<blockquote>
<p>Nach meiner letzten Recherche ist das nicht möglich. PHP Traits stellen nur statische Methoden bereit, hab ich grad eben gelesen.</p>
</blockquote>
<p>Dann ist deine Recherche wohl nicht gründlich gewesen.</p>
https://forum.selfhtml.org/self/2019/dec/21/instanz-um-methoden-errweitern/1762075#m1762075Christian Krusehttps://wwwtech.de/2019-12-21T19:21:07Z2019-12-21T19:21:07ZInstanz um Methoden errweitern<p>Hallo pl,</p>
<blockquote>
<blockquote>
<p>Denn die Idee von OOP ist ja eigentlich, dass man einen Schwarm von Objekten hat, die sich gegenseitig Botschaften schicken.</p>
</blockquote>
<p>Ganz bestimmt nicht.</p>
</blockquote>
<p>Doch. Genau aus dieser Idee ist modernes OOP entstanden. <a href="https://forum.selfhtml.org/self/2019/dec/21/instanz-um-methoden-errweitern/1762071#m1762071" rel="noopener noreferrer">1UP hat es gut zusammengefasst</a>.</p>
<p>Freundliche Grüße,<br>
Christian Kruse</p>
<div class="signature">-- <br>
<a href="https://wwwtech.de/about" rel="noopener noreferrer">https://wwwtech.de/about</a>
</div>
https://forum.selfhtml.org/self/2019/dec/21/instanz-um-methoden-errweitern/1762091#m1762091pl2019-12-22T09:31:55Z2019-12-22T09:31:55ZInstanz um Methoden errweitern<blockquote>
<blockquote>
<p>Denn die Idee von OOP ist ja eigentlich, dass man einen Schwarm von Objekten hat, die sich gegenseitig Botschaften schicken.</p>
</blockquote>
<p>Ganz bestimmt nicht. Aber ich kenne Einige die so programmieren. MFG</p>
</blockquote>
<p>Auch in Perl treiben manche solche Blüten; ein Objekt für Header (1), eins für Cookies (2), eins für den Body (3). Und diese 3 Objekte werden dann dem Konstruktor für den Useragent übergeben der dann die Requesmethode aufruft. GGf. wird noch ein 4. Objekt für die Parameter benötigt.</p>
<p>Aber dem nicht genug, auch die Response liefert wieder mehrere Objekte; eins für die Header, eins für die Cookies und ein Objekt was eine Methode kennt um an den Body zu kommen.</p>
<p>Und hier im Forum wurde kürzlich gepostet wie man Objekte für thead, row, cell, tbody usw. erstellt und diese dann dem Konstruktor übergibt der eine Tabelle damit erstellen soll.</p>
<p>Das ist OOP zum Selbstzweck und fern jeglicher Praxis.</p>
<p>Schönen Sonntag.</p>
https://forum.selfhtml.org/self/2019/dec/21/instanz-um-methoden-errweitern/1762078#m1762078Christian Krusehttps://wwwtech.de/2019-12-21T19:38:17Z2019-12-21T19:38:17ZInstanz um Methoden errweitern<p>Hallo Rolf,</p>
<blockquote>
<blockquote>
<p>die Methode wäre die Nachricht, die man an das Objekt schickt.</p>
</blockquote>
<p>Äh, nein. Zumindest habe ich das in Smalltalk anders gelernt.</p>
</blockquote>
<p>Smalltalk habe ich nie gelernt, dafür bin ich zu jung (Jahrgang '82). Aber unser Dozent hat uns das so erklärt. Methoden sind die Implementation von Nachrichten, die man an Objekte sendet. Aber nagel mich da nicht drauf fest, verifiziert habe ich das jetzt nicht.</p>
<blockquote>
<p>Eine OOP Sprache mit echtem Messaging, das stelle ich mir so vor, dass jedes Objekt in einem eigenen Thread läuft, Botschaften in eine Input Queue gestellt bekommt, […]</p>
</blockquote>
<p>Du beschreibst bis hierher das <a href="https://de.wikipedia.org/wiki/Actor_Model" rel="nofollow noopener noreferrer">Actor-Modell von Erlang</a> nur dass es hier nicht Objekt heisst (Erlang ist eine funktionale Sprache), sondern Prozess.</p>
<blockquote>
<p>und im Falle von Vererbung die Botschaften, mit denen es nichts anfangen kann, analog zu den JS Prototypen an die nächsthöhere Instanz weiterschickt. Auch Properties werden über Messaging ausgelesen. Keine Ahnung, ob schon mal jemand sowas gebaut hat.</p>
</blockquote>
<p>Mir als language nerd ist zumindest keine Sprache bekannt, dass message passing so… ursprünglich umsetzt.</p>
<p>Freundliche Grüße,<br>
Christian Kruse</p>
<div class="signature">-- <br>
<a href="https://wwwtech.de/about" rel="noopener noreferrer">https://wwwtech.de/about</a>
</div>
https://forum.selfhtml.org/self/2019/dec/21/instanz-um-methoden-errweitern/1762079#m17620791unitedpower2019-12-21T19:48:00Z2019-12-21T19:53:18ZInstanz um Methoden errweitern<blockquote>
<p>Eine OOP Sprache mit echtem Messaging, das stelle ich mir so vor, dass jedes Objekt in einem eigenen Thread läuft, Botschaften in eine Input Queue gestellt bekommt […]. Auch Properties werden über Messaging ausgelesen. Keine Ahnung, ob schon mal jemand sowas gebaut hat.</p>
</blockquote>
<p>Kennst du das <a href="https://en.wikipedia.org/wiki/Actor_model" rel="nofollow noopener noreferrer">Actor Model</a>? Erlang und Elixir sind zwei prominente Vertreter davon, auch wenn sie eher als funktional denn als objektorientiert klassifiziert werden.</p>
<p>Ich selber arbeite gerade übrigens an <a href="http://www.monticore.de/languages/montiarc/" rel="nofollow noopener noreferrer">MontiArc</a>, das ist eine Programmiersprache für verteilte Systeme. System-Designer*innen erstellen damit Modelle und Spezeifikation und im Hintergrund wird automatisch überprüft, ob das Modell die Spezifikation erfüllt. Unser Concurrency-Modell ist dem Actor Model auch sehr ähnlich.</p>
https://forum.selfhtml.org/self/2019/dec/21/instanz-um-methoden-errweitern/1762242#m17622421unitedpower2019-12-27T19:59:14Z2019-12-27T19:59:14ZInstanz um Methoden errweitern<blockquote>
<p>Du beschreibst bis hierher das <a href="https://de.wikipedia.org/wiki/Actor_Model" rel="nofollow noopener noreferrer">Actor-Modell von Erlang</a> nur dass es hier nicht Objekt heisst (Erlang ist eine funktionale Sprache), sondern Prozess.</p>
</blockquote>
<p>Ich bin gerade zufällig über ein <a href="https://www.infoq.com/interviews/johnson-armstrong-oop/" rel="nofollow noopener noreferrer">Interview</a> mit Joe Armstrong, einem der Designer von Erlang, gestolpert, da sagt er den bemerkenswerten Satz:</p>
<blockquote>
<p>[…] Erlang might be the only object oriented language […]</p>
</blockquote>
<p>Und Alan Kay, Designer von Smalltalk und Namensgeber von OOP, <a href="https://www.quora.com/What-does-Alan-Kay-think-about-Joe-Armstrong-claiming-that-Erlang-might-be-the-only-object-oriented-language-and-also-his-thesis-supervisor-s-claim-that-Erlang-is-extremely-object-oriented/answer/Alan-Kay-11?ch=10&share=8e466276&srid=lM1b" rel="nofollow noopener noreferrer">sagt dazu</a>:</p>
<blockquote>
<p>And, he might be right. Erlang is much closer to the original ideas I had about “objects” and how to use them.</p>
</blockquote>
https://forum.selfhtml.org/self/2019/dec/21/instanz-um-methoden-errweitern/1762080#m1762080Christian Krusehttps://wwwtech.de/2019-12-21T19:52:19Z2019-12-21T19:52:19ZInstanz um Methoden errweitern<p>Hallo 1unitedpower,</p>
<blockquote>
<p>Kennst du das <a href="https://en.wikipedia.org/wiki/Actor_model" rel="nofollow noopener noreferrer">Actor Model</a>?</p>
</blockquote>
<p>Hihi.</p>
<blockquote>
<p>Erlang und Elixier sind zwei Prominente Vertreter davon, auch wenn sie eher als funktional denn als objektorientiert klassifiziert werden.</p>
</blockquote>
<p>Das Forum ist übrigens in Elixir geschrieben.</p>
<p>Freundliche Grüße,<br>
Christian Kruse</p>
<div class="signature">-- <br>
<a href="https://wwwtech.de/about" rel="noopener noreferrer">https://wwwtech.de/about</a>
</div>
https://forum.selfhtml.org/self/2019/dec/21/instanz-um-methoden-errweitern/1762081#m17620811unitedpower2019-12-21T20:14:03Z2019-12-21T20:14:03ZInstanz um Methoden errweitern<blockquote>
<blockquote>
<p>Kennst du das <a href="https://en.wikipedia.org/wiki/Actor_model" rel="nofollow noopener noreferrer">Actor Model</a>?</p>
</blockquote>
<p>Hihi.</p>
</blockquote>
<p>Da war ich zu langsam.</p>
<blockquote>
<blockquote>
<p>Erlang und Elixier sind zwei Prominente Vertreter davon, auch wenn sie eher als funktional denn als objektorientiert klassifiziert werden.</p>
</blockquote>
<p>Das Forum ist übrigens in Elixir geschrieben.</p>
</blockquote>
<p>Ich weiß, ich finds beeindruckend, dass du inzwischen die Forensoftware einmal in einer rein prozeduralen Programmiersprache, in einer OOP Sprache und einer funktionalen Sprache geschrieben hast. BTW: Du hättest die Ruby-Version rforum, und die Elixir-Version eforum nennen sollen </p>
https://forum.selfhtml.org/self/2019/dec/21/instanz-um-methoden-errweitern/1762082#m1762082Christian Krusehttps://wwwtech.de/2019-12-21T20:19:20Z2019-12-21T20:19:20ZInstanz um Methoden errweitern<p>Hallo 1unitedpower,</p>
<blockquote>
<p>Ich weiß, ich finds beeindruckend, dass du inzwischen die Forensoftware einmal in einer rein prozeduralen Programmiersprache, in einer OOP Sprache und einer funktionalen Sprache geschrieben hast.</p>
</blockquote>
<p>Manche finden es beeindruckend, andere traurig das Forum ist halt ein Hobby. Es muss mir Spaß machen. Die Implementation in C war der Notwendigkeit geschuldet (damals hatten wir halt keine Hardware), die Implementation in Ruby war Pragmatismus (in Rails kann man halt verdammt schnell entwickeln) und die Implementation in Elixir basiert wieder auf Fandom. Ich mag Elixir wirklich.</p>
<blockquote>
<p>BTW: Du hättest die Ruby-Version rforum, und die Elixir-Version eforum nennen sollen </p>
</blockquote>
<p>Das höre bzw. lese ich nicht zum ersten mal </p>
<p>Freundliche Grüße,<br>
Christian Kruse</p>
<div class="signature">-- <br>
<a href="https://wwwtech.de/about" rel="noopener noreferrer">https://wwwtech.de/about</a>
</div>
https://forum.selfhtml.org/self/2019/dec/21/instanz-um-methoden-errweitern/1762098#m1762098Rolf B2019-12-22T11:19:24Z2019-12-22T11:19:24ZInstanz um Methoden errweitern<p>Hallo pl,</p>
<p>deine Kritik läuft darauf hinaus, dass OOP in Perl <s>hemdsärmelig dazugestrickt</s> sehr offen gestaltet ist, während PHP es systematischer angeht.</p>
<p>Eine Klassendeklaration ist ein Stempel, mit dem Du beliebig viele Objekte erzeugen kannst. Das Protokoll, wie die Objektreferenz den Methoden bekannt gegeben wird, ist festgelegt.</p>
<p>Eine Klassendeklaration in Perl gibt's überhaupt nicht, du segnest einfach ein Objekt mit einem Package und die Funktionen darin sind dann die Methoden. Darum kann man das schlecht vergleichen. Ob ich nun <code>$this</code> vorgekaut bekomme oder es mir explizit heraus<code>shift</code>e, ist vermutlich bis auf ein paar Nanosekunden egal. Aber ich muss in die Methode schauen und gucken ob sie sich ein <code>$self</code> herausholt, um zu wissen, ob sie statisch ist oder nicht.</p>
<p>Die Deklaration von Eigenschaften und Methoden in einer Klassendeklaration hat den zwei Zwecke.</p>
<ol>
<li>
<p>Man sieht deutlich an der Deklaration, was die Klasse enthält und wie es verwendet wird (statisch/Instanz, private/protected/public). In Perl muss ich das Package inspizieren und den Konstruktor finden und verstehen, um das zu wissen.</p>
</li>
<li>
<p>Ich kann Datenkapselung betreiben, indem ich bestimmte Eigenschaften oder Methoden als private oder protected deklariere, so dass sie nur innerhalb der Klasse verfügbar sind. Dadurch verhindere ich, dass Unbefugte den Zustand meines Objekts verändern (ja, ich weiß, die FP-Vertreter wenden jetzt ein, dass ein veränderlicher Objektzustand ohnehin die Quelle der meisten Übel ist). Ob man in Perl überhaupt private Eigenschaften kennt, habe ich nicht herausgefunden.</p>
</li>
</ol>
<blockquote>
<p>In PHP hingegen wird zwischen new und Konstruktor unterschieden</p>
</blockquote>
<p>PHP erledigt einiges der Instanz-Erzeugung eigenständig (Speicher für Eigenschaften allocieren, Objekt mit der Klasse segnen), darum gibt's einen new-Operator der das auslöst. Der Konstruktor muss dann von PHP selbst gefunden werden können, damit man ihn nicht bei jedem new Foo() explizit angeben muss.</p>
<blockquote>
<p>Noch verwirrender in PHP ist, Eigenschaften der Instanz klassenweit zu deklarieren obwohl noch gar keine Instanz existiert.</p>
</blockquote>
<p>Es ist eine Deklaration, mehr nicht. Sie dient - wie oben geschrieben - als Stempel für den Moment, wo die Klasse instanziiert wird. Dass Du undeklarierte Eigenschaften dynamisch hinzufügen kannst, führt aus meiner Sicht zu schwer verständlichem Code. Ab PHP 7.4 wird das weiter verbessert, da geht (optional) dies:</p>
<pre><code class="block language-php"><span class="token keyword">class</span> <span class="token class-name-definition class-name">Foo</span> <span class="token punctuation">{</span>
<span class="token keyword">private</span> <span class="token keyword type-declaration">int</span> <span class="token variable">$i</span><span class="token punctuation">;</span>
<span class="token keyword">public</span> <span class="token keyword">function</span> <span class="token function-definition function">__construct</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token punctuation">{</span>
<span class="token variable">$this</span><span class="token operator">-></span><span class="token property">i</span> <span class="token operator">=</span> <span class="token number">47</span><span class="token punctuation">;</span>
<span class="token variable">$this</span><span class="token operator">-></span><span class="token property">i</span> <span class="token operator">=</span> <span class="token string double-quoted-string">"Hugo"</span><span class="token punctuation">;</span> <span class="token comment">// Fatal error: Uncaught TypeError</span>
<span class="token punctuation">}</span>
<span class="token punctuation">}</span>
</code></pre>
<p>Ohne deklarierte Eigenschaften hättest Du diese Möglichkeit nicht. Ich bin ein Fan von statisch getypten Sprachen, die ersparen viel Kopfschmerz.</p>
<p>Übrigens, für Perl-Nostalgie in PHP kannst Du sowas programmieren (solltest Du aber nicht, jede Sprache hat ihre Idiome und man sollte sie nicht transplantieren):</p>
<pre><code class="block bad language-php"><span class="token keyword">class</span> <span class="token class-name-definition class-name">Foo</span> <span class="token punctuation">{</span>
<span class="token keyword">static</span> <span class="token keyword">function</span> <span class="token function-definition function">new</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token punctuation">{</span>
<span class="token keyword">return</span> <span class="token keyword">new</span> <span class="token class-name">Foo</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span>
<span class="token keyword">function</span> <span class="token function-definition function">__construct</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token punctuation">{</span>
<span class="token comment">// do sth</span>
<span class="token punctuation">}</span>
<span class="token punctuation">}</span>
<span class="token variable">$f</span> <span class="token operator">=</span> <span class="token class-name static-context">Foo</span><span class="token operator">::</span><span class="token function">new</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
</code></pre>
<p>Und eine reservierte Funktion In PHP 5 kannst Du den Konstruktor einer Klasse Foo noch Foo() nennen, ab 7 ist das deprecated und es gibt nur noch __construct.</p>
<p>Das soll jetzt keine Wertung darstellen. PHP gibt Dir die Möglichkeit, mehr zu erzwingen. Perl lässt Dir viel mehr Freiheiten. Aus meiner Sicht sind das Freiheiten, die das Verständnis des Programms erschweren können. Aber das bin nur ich.</p>
<p><em>Rolf</em></p>
<div class="signature">-- <br>
sumpsi - posui - clusi
</div>
https://forum.selfhtml.org/self/2019/dec/21/instanz-um-methoden-errweitern/1762092#m1762092Matthias Apselmatthias.apsel@selfhtml.orghttps://brückentage.info2019-12-22T09:34:44Z2019-12-22T09:34:44ZInstanz um Methoden errweitern<p>Hallo pl,</p>
<blockquote>
<p>Und hier im Forum wurde kürzlich gepostet wie man Objekte für thead, row, cell, tbody usw. erstellt und diese dann dem Konstruktor übergibt der eine Tabelle damit erstellen soll.</p>
</blockquote>
<p>Im Rahmen einer Frage.</p>
<p>Bis demnächst<br>
Matthias</p>
<div class="signature">-- <br>
Du kannst das Projekt SELFHTML unterstützen,<br>
indem du bei Amazon-Einkäufen <a href="https://smile.amazon.de/ch/314-570-45498" rel="nofollow noopener noreferrer">Amazon smile</a> (<a href="https://www.amazon.de/gp/help/customer/display.html?ie=UTF8&nodeId=202035970%5D" rel="nofollow noopener noreferrer">Was ist das?</a>) nutzt.
</div>
https://forum.selfhtml.org/self/2019/dec/21/instanz-um-methoden-errweitern/1762252#m1762252pl2019-12-28T10:39:04Z2019-12-28T10:39:04ZInstanz um Methoden errweitern<blockquote>
<p>Aus meiner Sicht sind das Freiheiten, die das Verständnis des Programms erschweren können. Aber das bin nur ich.</p>
</blockquote>
<p>Du sagst es; sie können. Ob ein Programm verständlich ist oder nicht, hängt jedoch von einer Reihe gänzlich anderer Faktoren ab die mit der Programmiersprache gar nichts zu tun haben.</p>
<p>MFG</p>
https://forum.selfhtml.org/self/2019/dec/21/instanz-um-methoden-errweitern/1762263#m1762263pl2019-12-28T12:01:51Z2019-12-28T12:01:51ZInstanz um Methoden errweitern<blockquote>
<p>Eine Klassendeklaration in Perl gibt's überhaupt nicht, du segnest einfach ein Objekt mit einem Package und die Funktionen darin sind dann die Methoden.</p>
</blockquote>
<p>Kann man machen. Macht aber keiner. Vielmehr tut auch ein Perlentwickler seine Klasse sauber deklarieren;</p>
<pre><code class="block language-perl"><span class="token keyword">package</span> Egal<span class="token punctuation">{</span>
<span class="token keyword">sub</span> <span class="token function">new</span><span class="token punctuation">{</span>
<span class="token keyword">my</span> <span class="token variable">$class</span> <span class="token operator">=</span> shift<span class="token punctuation">;</span>
bless<span class="token punctuation">{</span>
NUM <span class="token operator">=></span> <span class="token number">123</span><span class="token punctuation">,</span>
<span class="token comment"># weitere Eigenschaften</span>
<span class="token punctuation">}</span><span class="token punctuation">,</span> <span class="token variable">$class</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span>
<span class="token punctuation">}</span><span class="token punctuation">;</span>
</code></pre>
<p>und siehe, da man, im Gegensatz zu PHP, praktisch gezwungen ist einen Konstruktor zu schreiben, wird man genau da auch sämtliche Attribute deklarieren. Dasselbe macht man in PHP eben außerhalb des Konstruktors weil eine Deklaration Letzteren nicht zwingend notwendig ist.</p>
<p>Was in PHP (noch) fehlt ist POD, <a href="https://rolfrost.de/file.html" rel="nofollow noopener noreferrer">Beispiel s.o.</a></p>
<p>POD steht für Plain Old Document, mit <code>perdoc File</code> wird sie für obenstehende Package abgerufen. Und wer will kann auch mit <code>pod2html</code> die in der Klasse eingebettete Dokumentation als HTML erzeugen.</p>
<p>MFG</p>
https://forum.selfhtml.org/self/2019/dec/21/instanz-um-methoden-errweitern/1762101#m1762101Rolf B2019-12-22T11:36:24Z2019-12-22T11:36:24ZInstanz um Methoden errweitern<p>Hallo pl,</p>
<p>um deiner Zusammenfassung des Threads meine Zusammenfassung hinzuzufügen:</p>
<p>Es ist das älteste Technologiethema von allen. "Wie" vs "Ob".</p>
<p><em>Rolf</em></p>
<div class="signature">-- <br>
sumpsi - posui - clusi
</div>
https://forum.selfhtml.org/self/2019/dec/21/instanz-um-methoden-errweitern/1762111#m1762111pl2019-12-22T14:18:03Z2019-12-22T14:18:03ZInstanz um Methoden errweitern<p>Oder anders ausgedrückt: Das Organisieren von Code in Methoden ist nur die Fortsetzung des Organisieren von Code in Klassen.</p>
<p>MFG</p>