Zitat von BlackScorp
Beitrag anzeigen
Ankündigung
Einklappen
Keine Ankündigung bisher.
Wozu brauche ich eigentlich eine abstrakte Klasse?
Einklappen
Neue Werbung 2019
Einklappen
X
-
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]
-
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
-
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 {..}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
-
Zitat von litterauspirna Beitrag anzeigenIch 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.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
-
Zitat von echo Beitrag anzeigen- Man kann auch mit "normalen" Klassen alles erreichen, was man mit abstrakten Klassen erreicht
- Die einzigen zusätzlichen Funktionalitäten/Vorteile, die abstrakte Klassen bilden sind:
- Man kann Models besser strukturieren
- Gerade bei Projekten mit mehr als einem Entwickler sinnvoll
- Gerade, wenn man nur alleine für sich programmiert ohne dass andere Entwickler beteiligt sind, kann man durchaus auf abstrakte Klassen verzichten
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 anzeigenAbstrakte 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 {..}
Kommentar
-
Abstrakte Methoden
Ist eine Methoden abstrakt so muss sie in der Kindklassen definiert werden.
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)
PHP-Code:class fisch extends tier{
abstract public function foo();
public function baz(){
//
}
}
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();
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
-
Zitat von mermshausEine Klasse, die eine nicht realisierte abstrakte Methode enthält, ist immer insgesamt abstrakt.
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
-
hts
Zitat von echo Beitrag anzeigenErgo: Abstrakte Methoden in abstrakten Klassen müssen in Kind-Klassen definiert werden, oder??
PHP-Code:abstract class tier
{
abstract public function foo();
}
abstract class fisch extends tier
{
}
class barsch extends fisch
{
public function foo()
{
}
}
$barsch = new barsch();
Kommentar
-
Zitat von litterauspirna Beitrag anzeigen...in abstrakten Klassen hast du aber auch die Möglichkeit sie auf protected und private zu setzen...
Kommentar
-
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 (0 > 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 diese Klasse zum Beispiel
PHP-Code:<?php
/**
* User
* @version 1.4
* @author Splasch
* @Filename: user.php
* Benutzer Verwaltung
**/
if (0 > 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 */
?>
Du kannst also nicht von auserhalb auf die Interne Objekte zugreiffen. Den direkt zugriffe auf abstrace Klassen sind nicht möglich.
Mfg Splasch
Kommentar
-
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.
Zu dem Code selbst fällt mir nicht viel ein. Aber „User extends Gruppe“ finde ich fragwürdig.
Kommentar
-
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.
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.
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
Kommentar