Con-f-use ich möchte Dir in einigen Punkten widersprechen in JS kann man schon OOP programmieren wenn man es darauf anlegt.Sogar Vererbung ist möglich aber man hat hier klar seine Grenzen.
Es gibt auch sowas wie öffentliche und private Methoden man muss ja nicht immer alles gleich in einer Funktion mit this.irgendwas deklarieren.
Richtig man sieht meistens sowas wie :
Code:
function foo() {
}
foo.prototype.bar = function () {}
Diese Funktion ist dann auch öffentlich zugänglich und wäre eingentlichdas gleiche wie:
Code:
function foo() {
this.bar = function () {}
}
Aber das geht auch
Code:
function foo() {
function bar() {} // die ist privat auf da wirst nie zugriff von aussen bekommen können
}
Vererbung
Code:
function foo() {
this.test = function () {
alert("hallo welt");
}
}
function bar() {
}
bar.prototype = new foo();
var test = new bar();
test.test();
Überschreiben von Methoden
Code:
function foo() {
this.bar = function () {
alert('foobar');
}
this.initfoo() = function () {
this.bar();
}
}
function foo2 () {
this.constructor(this); //ohne dies würde initfoo die Funktion bar aus foo aufrufen
this.bar = function () {
alert('barfoo');
}
}
foo2.prototype = new foo();
var test = new foo2();
test.initfoo();
Große Schwachstelle
Code:
function foo() {
this.bar = function () {
alert('foobar');
}
this.initfoo() = function () {
this.bar();
}
}
function foo2 () {
this.bar = function () {
alert('barfoo');
}
}
foo2.prototype = new foo();
function foo3 () {
//man könnte nun meinen das er nun bei foo2 rauskommt
//aber es geht gleich hoch bis foo()
this.constructor(this);
this.bar = function () {
alert('überschrieben barfoo');
}
}
foo3.prototype = new foo2();
Das soll heißen man kann nicht direkt auf den Constructor von foo2() zugreifen mehr er wandert gleich bis an die Spitze der Nahrungskette foo() hoch.
Singleton Patterns kann man ebenfalls umsetzen mit Hilfe von new Object() sowie kann man auch Object als "statische Klasse" missbrauchen.
Also man kann damit schon sehr viele hübsche Sachen machen auch nützliche.
Mhm mein erstes Projekt mit volles Rohr javascript OOP war
http://www.bitraum.de und zwar gibt es da als gutes Beispiel auch eine Fenster Klasse.
Fenster davon leiten sich ab BaseWindow und ExtendedBaseWindow , beide kann man schliessen ExtendedWindow hat noch nen paar Extras mit Drinnen wie schließen und in die Taskleiste verschieben oder vergrössern,verkleinern und den Resize Button unten rechts.
Von ExtendedWindow leitet sich ab FileWindow welches ein spezielles Template nutzte und noch ExtendedFileWindow wo man noch zwischen den Code und Beispiel hin und herschalten konnte. Zum Beispiel
2. Beispiel
Ich habe 2 Klassen Load und Preload. Load würde für sich alleine gut arbeiten , wollen wir aber nun noch ein Preload Bildchen reinhaun dann starte ich die Klasse Preload und gebe dem ganzen noch ein Load Object mit auf den Weg was geladen werden soll.
Somit kann ich x Preloader schalten und jeder würde für sich sein einges Load Object abhandeln ob Bilder oder Ajax Content je nachdem was man möchte.
Also da ist schon viel drinnen es ist immer nur die Frage wie weit man es ausreizen möchte.