ugrás a tartalomhoz

JavaScript öröklődés

vbence · 2008. Ápr. 22. (K), 12.30
Tudom.. szegénységi bizonyítvány, DE igazán most szembesültem vele, hogy nem tudom, hogy lehet egy származtatott JS objektumból meghívni az ős (időközben felülírt) metódusát. Pl:

Szulo  = function() {
}

Szulo.prototype.metodus = function (a, b) {
}

Gyerek = function() {
}
Gyerek.prototype = new Szulo();

Gyerek.prototype.metodus = function (a, b, c) {
    // itt valami feldolgozás
    Szulo.prototype.metodus.call(this, a, b);
}
Kérdés: van-e ennél szebb megoldás, ha nincs, akkor miért nincs? :) Ugyanez aprobléma akonstruktorral...
‹ jQuery: a this az eseménykezelő metódust tartalmazó osztály legyen IE vs FF box model ›
 ■
1

pedig én is kiváncsi voltam

toxin · 2008. Ápr. 23. (Sze), 09.22
de senki nem reagál? :(

szóval a konstruktorokat még csak-csak összeláncolom 

			var FooA = function(){
				this.a = "A";				
			};
			FooA.prototype.aP="pA";
			
			var FooB = function(){
				this._baseInic_ = FooA;
				this._baseInic_();
				this.b = "B";
			};			
			FooB.prototype = new FooA();
			FooB.prototype.pB="pB";
			FooB.prototype.constructor = FooB;
			
			var FooC = function(){
				this._baseInic_ = FooB;
				this._baseInic_();
				this.c = "C";
			};			
			FooC.prototype = new FooB();
			FooC.prototype.bC="pC";
			FooC.prototype.constructor = FooC;
			
			fooC = new FooC();
			console.dir(fooC);
a konstruktorok saját metódussá tételével, a másikra passz, mert az általam ismert klasszikus örökítést szimuláló JS bővítmények is call,apply-ra építenek:
http://dean.edwards.name/weblog/2006/03/base/
http://javascript.crockford.com/inheritance.html

utóbbi kommentezve is megtalálható a CHAPTER 3 - Creating Reusable Code alatt

üdv Csaba
18

john resig szerint base a nyerő

Hodicska Gergely · 2008. Május. 9. (P), 14.08
John Resig szerint a Base az egyik legtutibb OOP framework javascripthez. Van némi rálátása a témára, ő írta a jQueryt és vezeti a FUEL fejlesztését, hihetünk neki.


Üdv,
Felhő
2

Első megoldás

vbence · 2008. Ápr. 25. (P), 11.41
Az elő szörnyeteg, amit összeütöttem így néz ki:

extend = function (baseClass, extension) {

	var proto = new baseClass();
	
	var ThisClass = function () {
		this.base = baseClass.prototype;
		this.baseConstructor = baseClass;
		this.construct.apply(this, arguments);
	}
	ThisClass.prototype = proto;
	
	for (i in extension)
		ThisClass.prototype = extension[i];
	
	return ThisClass;
}

// használata pedig
Gyerek = extend2(Szulo, {
	construct : function (a, b) {
		alert("Gyerek konstruktor: " + a + ", " + b);
		this.baseConstructor.call(this, a, -1);
	}
	,
	metodus : function (c) {
		alert("Gyerek metodus: " + c);
		this.base.metodus.call(this, -1);
	}
});
A konstruktort a construct nevű "mágikus" metódus valósítja meg (a valódi konstruktort az extend fv hozza létre a [i]base paraméterek beállítására). Itt is callt kell használni, annyi előnye viszont van, hogy a gyerekosztályban nem kell beleégetnia szülő nevét (mobilisabb), és persze a this.base rövidebb a domain.cosomag.Osztaly.prototype -nál (ami nem szabadna, hogy szempont legyen...)

Persze az a szörnyen idegesítő dolog így is benne van a dologban, hogy létrehozunk egy Szulo példányt, a prototípust, ami így paraméterek nékül hibásan és persze fölöslegesen inicializálódik, hacsak nem kezeljük le ezt is külön a konstruktorban, ami az egyik legidegesítőbb dolog.

Ezért a prototípust így is létrehozhatjuk:

	var dummyBase = function () {};
	dummyBase.prototype = baseClass.prototype;
	var proto = new dummyBase();
A prototípuslánc megfelelően inicializádik, és a konstruktort pedig úgy is egy külön mezőben (baseConstructor) tároljuk. Nem azt mondom, hogy megold mindent, de ez már egy olyan alap, amin talán tudnék dolgozni...
3

Kutakodtam

zila · 2008. Ápr. 25. (P), 13.01
Ezt találtam: http://www.sitepoint.com/blogs/2006/01/17/javascript-inheritance/
4

Köszi

vbence · 2008. Ápr. 25. (P), 13.45
Elolvastam. Csak megerősített, hogy senki se tudja, igazán mit csináljon a kérdésben, meg, hogy kinek a pap... A megoldásokat böngészve igazán nem találtam olyat, ami jobban megfelelne a kiötlött extend módszernél.

Talán el kéne felejteni mindent, amit az OO-ról tudunk, és megtanulni prototípus-orientáltan(?) programozni. A kérdés csak az, hogy olyat hogy kell... :)

Az egész dolog azért jött elő mert egy nagyobb kliensoldali alkalmazás előtt állok. Kíváncsi lennék, hogy mások hogyan írnak "nagyobb" kódokat ezzel az izével.
5

open laszlo, .NET megoldása

Hodicska Gergely · 2008. Ápr. 25. (P), 18.12
Eléggé kiestem ebből a témából, így már nem emlékszem a konkrétumokra a cikkben, de az még rémlik, hogy annó elég érdekes volt.
http://weblog.openlaszlo.org/archives/2006/02/class-based-oop-in-javascript-done-right/

Ezenkívül szerintem amit még érdmes megnézned az a .NET Ajax része. Elvileg ott megcsinálták a .NET framework egy részének portolását, amihez elkészült egy olyan réteg is, ami támogatja az OOP-t. Sajnos már erről is csak ennyi rémlik, de az valszeg egy elég mature megoldás lehet, ha utána tudtak rá építeni.


Üdv,
Felhő
6

AJS

ksgy · 2008. Ápr. 25. (P), 21.34
orangoo labs fele oop js-ben
7

Köszi

vbence · 2008. Ápr. 26. (Szo), 10.02
A minket érdeklő rész az ez:

AJS.Class = function(members) {
    var fn = function() {
        if(arguments[0] != 'no_init') {
            return this.init.apply(this, arguments);
        }
    }
    fn.prototype = members;
    AJS.update(fn, AJS.Class.prototype);
    return fn;
}
AJS.Class.prototype = {
    extend: function(members) {
        var parent = new this('no_init');
        for(k in members) {
            var prev = parent[k];
            var cur = members[k];
            if (prev && prev != cur && typeof cur == 'function') {
                cur = this._parentize(cur, prev);
            }
            parent[k] = cur;
        }
        return new AJS.Class(parent);
    },

    implement: function(members) {
        AJS.update(this.prototype, members);
    },

    _parentize: function(cur, prev) {
        return function(){
            this.parent = prev;
            return cur.apply(this, arguments);
        }
    }
};
Ez a _parentize (29. sor) nagyon tetszetős megoldás: minden frissített metódust beburkol egy saját függvénybe, ami a this.parent-be betölti a szülő azonos nevű függvényét. Zseniális.. ez hogy nem nekem jutott eszembe? :)

a 4. sorban a return-t nem igazán értem.
8

szép is ezen gondolkozni :)

toxin · 2008. Ápr. 27. (V), 12.01
nem volt jó :D , lehet hogy ez se, de hátha más is szórakozik ilyesmivel, miközben várja a bútorszállítókat :)))

			Function.prototype.method = function(name,func){
				this.prototype[name] = func;				
			};
			
			var Class = function(parent,instance){
				var nullfunc = function(){},				
					klass = function(){	
						this._constr.apply(this,arguments);
					};
				
				if(typeof parent != "function") {
					instance = parent;					
					var	_constr	= parent.constr || nullfunc;					
				}else{ 
					klass.prototype = new parent;
					klass.prototype.constructor = parent;										
					var	_constr		= instance._constr = instance.constr || nullfunc;
				};			
				delete(parent.constr);
				delete(instance.constr);									
				klass.method("_constr",_constr);
				for (var method in instance){
					if (klass.prototype[method]) {
						klass.method((method == "_constr" ? "_base" :"_base_") + method,(function(klass,method){
							var parentClass = klass.prototype;												
							return function(){								
								var oldParentClass = parentClass;
								parentClass = parentClass.constructor.prototype;								 									
								var ret = parentClass[method].apply(this,arguments);
								parentClass = oldParentClass;
								return ret;
							};
						})(klass,method));
					}; 
					klass.method(method, instance[method]);
				};				
				return klass;						
			};
			
			var FooA = Class({
				
				methodA : function() {
					console.log("a");
				},
				
				methodB : function(text){
					console.log(arguments.callee == FooB.prototype.methodB);	 			
				}				
			});
			
			var FooB = Class(FooA,{
				constr : function() {
					this.b = "b";					
				},
				methodA : function() {
					console.log("b");
					this._base_methodA();
				},
				
				methodB : function(text){
					console.log(arguments.callee == FooB.prototype.methodB);
					this._base_methodB();					
				}
			});
			
			var FooC = Class(FooB,{
				constr : function(param) {
					this.c = "c";
					this.param2 = param;
				}, 
				methodA : function() {
					console.log("c");
					this._base_methodA();
					this._base_methodA();							
				}
			});
			
			var FooD = Class(FooC,{
				constr : function(param) {
					this.d = "d";
					this.e = "e";
					this.param = param;
					this._base_constr(param);
				}, 
				methodA : function() {
					console.log("d");
					this._base_methodA();
				},
				
				methodB : function(text){					
					this._base_methodB();					
				}
				
			});			
						
			     foo = new FooD("parameter");
				 foo.methodA();
				 foo = new FooD("parameter");
				 console.log("---");
				 foo.methodA();
				 console.log("---");
			  	 foo = new FooC("parameter");
				 foo.methodA();
				 foo = new FooD("parameter");
				 console.log("---");
				 foo.methodB();
				 foo = new FooD("parameter");
				 console.log("---");
				 foo.methodB();
kössz Tibi :))

üdv Csaba
9

Hazudnék

vbence · 2008. Ápr. 28. (H), 17.53
... ha azt mondanám, hogy minden részében értem :)
12

melyik része

toxin · 2008. Ápr. 29. (K), 09.09
kis javítás, ahol kommenteztem is

			Function.prototype.method = function(name,func){
				this.prototype[name] = func;
				return this;			
			};
			
			var Class = function(parent,instance){
				var nullfunc = function(){},				
					klass = function(){
						// konstruktort a szignatúrájának megfelelő paraméterszámmal kell hívni
						if (arguments.length == this._constr.length)	
						this._constr.apply(this,arguments);						
					};
				
				if(typeof parent != "function") {
					instance = parent;					
					var	_constr	= parent.constr || nullfunc;					
				}else{ 
					klass.prototype = new parent;
					klass.prototype.constructor = parent;										
					var	_constr		= instance._constr = instance.constr || nullfunc;
				};			
				delete(parent.constr);
				delete(instance.constr);									
				klass.method("_constr",_constr);
				for (var method in instance){
					if (klass.prototype[method] && typeof klass.prototype[method] == "function") {
						klass.method((method == "_constr" ? "_base" :"_base_") + method,(function(klass,method){
							var parentClass = klass.prototype;												
							return function(){								
								var oldParentClass = parentClass;
								parentClass = parentClass.constructor.prototype;								 									
								var ret = parentClass[method].apply(this,arguments);
								parentClass = oldParentClass;
								return ret;
							};
						})(klass,method));
					}; 
					klass.method(method, instance[method]);
				};				
				return klass;						
			};
			/* 
             * nem hagyományos módon létrehozott objektum, konstruktort kapunk vissza
             */
			
			Szulo = Class({
				constr : function(a,b){
					 console.log("Szulo konstruktor: " + a + ", " + b);
				},
				metodus : function(c){
					console.log("Szulo metodus: " + c);
                	this.c = c;
				},
				metodus2 : function(c){
                	return ("Szulo metodus2: " + c);
            	}
			});
            
			Gyerek = Class(Szulo,{
				constr : function(a,b){
					console.log("Gyerek konstruktor: " + a + ", " + b);
                    this._base_constr(a, -1);
				},
				metodus: function(c){
                    console.log("Gyerek metodus: " + c);
                    this._base_metodus(-1);
                },
                metodus2: function(){
                    console.log(this._base_metodus2(this.c));
                }
			});            
            
            var o = new Gyerek(3, 4); // példányosítás  
            o.metodus(5);
            o.metodus2();
            console.log(o.c == -1); // a true a jó
most elviekben ugyanazt a kimenet produkálja mint vbence-jé, csak itt Class-okkal konstruktorokat gyártunk már alapból, és azokat példányosítjuk

üdv Csaba
14

Még egyszer nekiugrom majd...

vbence · 2008. Ápr. 29. (K), 11.39
Egyelőre eléggé összezavar, hogy az egyparaméteres és kétparaméteres változatát egy függvényben oldaottad meg... még amikor lesz több időm átböngészem figyelmesebben.
10

Második megoldás

vbence · 2008. Ápr. 28. (H), 18.36
Egy call nélküli változat. Itt this.base.metodus() formában hívhatjuk az eredeti metódusokat. Olyan metódusokra is igaz, amiket nem írtunk felül, úgyhogy valamivel szabadabb a dolog. A módszer lelke az, hogy az új osztályunkból származtatunk még egy újabbat, aminek az éreintett metódusait kézel átírjuk, hogy az eredetieket hívják.

extend = function (baseClass, extension) {
	
	/*
	 * Saját konstruktor gyártása a származtatott "osztály" számára.
	 */
	var ThisClass = function () {
		
		/*
		 * A bezárt függvények metódusok lesznek (saját this-szel), ezért az aktuális objektumra mutató referenciát
		 * a thisObject segédváltozó segítségével érik majd el.
		 */
		var thisObject = this;

		/*
		 * Az eredeti metódusokhoz való hosszáférés ezen az objektumon keresztül fog történni.
		 */
		var D1 = function () {};
		D1.prototype = this;
		
		/*
		 * Ezen a ponton a this.base bármely metódusának hívása a this azonos metódusának hívásával egyenlő.
		 */
		this.base = new D1();
		
		/*
		 * A felülírt metódusaink eredeti változatának meghívására saját (wrapper) metódusokat adunk a this.base-hez.
		 */
		for (i in extension)
			if (typeof(extension[i]) == "function")
				this.base[i] = function () { baseClass.prototype[i].apply(thisObject, arguments); };
		
		/*
		 * Az eredeti konstruktor meghívásának lehetőségére újabb wrapper funkció.
		 */
		this.baseConstructor = function () {baseClass.apply(thisObject, arguments); };
		
		/*
		 * A construct nevű metódus futtatása (saját konvenció, hogy a származtatott objektum is rendelkezhessen konstruktorral).
		 */
		this.construct.apply(this, arguments);
	}
	
	/*
	 * baseClass "néma" példányosítása: megkapjuk az eredeti prototípusláncot a konstruktor futtatása nélkül
	 * lehetne (ekkor viszont lefutna a baseClass konstruktor is):
	 *  ThisClass.prototype = new baseClass();
	 */
	var dummyBase = function () {};
	dummyBase.prototype = baseClass.prototype;
	ThisClass.prototype = new dummyBase();
	
	/*
	 * Az kiterjesztett metódusokat az új "osztályba" másoljuk.
	 */
	for (i in extension)
		ThisClass.prototype[i] = extension[i];
	
	/*
	 * Az új "osztály" visszaadása.
	 */
	return ThisClass;
}
Példa a használatra:

/*
 * Hagyományos módon létrehozott objektum a kompatibilitás személtetésére.
 */
 
Szulo = function (a, b) {
	alert("Szulo konstruktor: " + a + ", " + b);
}

Szulo.prototype.metodus = function (c) {
	alert("Szulo metodus: " + c);
	this.c = c;
}

Szulo.prototype.metodus2 = function (c) {
	alert("Szulo metodus2: " + c);
}


/*
 * Kiterjesztjük a Szulo-t.
 */

Gyerek = extend(Szulo, {
	construct : function (a, b) {
		alert("Gyerek konstruktor: " + a + ", " + b);
		this.baseConstructor(a, -1);
	}
	,
	metodus : function (c) {
		alert("Gyerek metodus: " + c);
		this.base.metodus(-1);
	}
});


var o = new Gyerek(3, 4);	// példányosítás
o.metodus(5);	// felülírt metódus
o.metodus2(6);	// érintetlen metódus a Szulo-ből
alert(o.c == -1);	// a true a jó
A legszebb az lenne, ha this.base(); -ként lehetne hívni az eredeti konstruktort az eddigi előnyök mellett, de arra abszolút ötletem sincs.
11

és ilyenkor miért ez történik ? ]:)

toxin · 2008. Ápr. 29. (K), 09.06

            /* 
             * Hagyományos módon létrehozott objektum a kompatibilitás személtetésére.
             */
            Szulo = function(a, b){
                console.log("Szulo konstruktor: " + a + ", " + b);
            }
            
            Szulo.prototype.metodus = function(c){
                console.log("Szulo metodus: " + c);
                this.c = c;
            }
            
            Szulo.prototype.metodus2 = function(c){
                console.log("Szulo metodus2: " + c);
            }
            
            
            /* 
             * Kiterjesztjük a Szulo-t.
             */
            Gyerek = extend(Szulo, {
                construct: function(a, b){
                    console.log("Gyerek konstruktor: " + a + ", " + b);
                    this.baseConstructor(a, -1);
                },
                metodus: function(c){
                    console.log("Gyerek metodus: " + c);
                    this.base.metodus(-1);
                },
                metodus2: function(){
                    this.base.metodus2(this.c);
                }
            });
            
            
            var o = new Gyerek(3, 4); // példányosítás  
            o.metodus(5); // felülírt metódus  
            o.metodus2();
            console.log(o.c == -1); // a true a jó
kimenet :
Gyerek konstruktor: 3, 4
Szulo konstruktor: 3, -1
Gyerek metodus: 5
Szulo metodus2: -1
Szulo metodus2: undefined
false


magyarán nálad a 

                    for (i in extension) 
                        if (typeof(extension[i]) == "function") 
                            this.base[i] = function(){
                                baseClass.prototype[i].apply(thisObject, arguments);
                            };
baseClass.prototype[i] = ...

i utolsó lehetséges értékét tárolta for-al töltött változoknál a scope elkapás nem müxik, ezért a

               metodus: function(c){
                    console.log("Gyerek metodus: " + c);
// ez is a  Szulo.prototype.metodus2-t hívja meg
                    this.base.metodus(-1);
                },
                metodus2: function(){
// ez is a  Szulo.prototype.metodus2-t hívja meg
                    this.base.metodus2(this.c);
                }
            });
            
            
            var o = new Gyerek(3, 4); // példányosítás  
            o.metodus(5); // felülírt metódus  
            o.metodus2();
            console.log(o.c == -1); // a true a jó   
//-t hívta meg
, megoldás

                    for (i in extension) 
                        if (typeof(extension[i]) == "function") 
                            this.base[i] = (function(){
                                var baseFunc = baseClass.prototype[i];
                                return function(){
                                    baseFunc.apply(thisObject, arguments);
                                };
                            })();
körbe kell venni egy anonym függvénnyel és elkapni a scope-t (lásd nálam un.-t), javítás után a kimenet

Gyerek konstruktor: 3, 4
Szulo konstruktor: 3, -1
Gyerek metodus: 5
Szulo metodus: -1
Szulo metodus2: -1
true


ami nekem jobban tetszik, másrészt a base-ből hívott return-al visszaadott értékeket is le kéne tudni kezelni,
nézd : o.metodus2()-> Gyerek.metodus2 -> Szulo.prototype.metodus2

 /* 
             * Hagyományos módon létrehozott objektum a kompatibilitás személtetésére.
             */
            Szulo = function(a, b){
                console.log("Szulo konstruktor: " + a + ", " + b);
            }
            
            Szulo.prototype.metodus = function(c){
                console.log("Szulo metodus: " + c);
                this.c = c;
            }
            
            Szulo.prototype.metodus2 = function(c){
                return ("Szulo metodus2: " + c);
            }
            
            
            /* 
             * Kiterjesztjük a Szulo-t.
             */
            Gyerek = extend(Szulo, {
                construct: function(a, b){
                    console.log("Gyerek konstruktor: " + a + ", " + b);
                    this.baseConstructor(a, -1);
                },
                metodus: function(c){
                    console.log("Gyerek metodus: " + c);
                    this.base.metodus(-1);
                },
                metodus2: function(){
                    console.log(this.base.metodus2(this.c));
                }
            });
            var o = new Gyerek(3, 4); // példányosítás  
            o.metodus(5);
            o.metodus2();
            console.log(o.c == -1); // a true a jó
kimenete
Gyerek konstruktor: 3, 4
Szulo konstruktor: 3, -1
Gyerek metodus: 5
Szulo metodus: -1
undefined
true


javítás, i elé azért teszek egy var-t ne szennyezzünk

                     /* 
                     * A felülírt metódusaink eredeti változatának meghívására saját (wrapper) metódusokat adunk a this.base-hez.
                     */
                    for (var i in extension) 
                        if (typeof(extension[i]) == "function") 
                            this.base[i] = (function(){
                                var baseFunc = baseClass.prototype[i];
                                return function(){
									//a szükséges plussz return
                                    return baseFunc.apply(thisObject, arguments);
                                };
                            })();
kimenet
Gyerek konstruktor: 3, 4
Szulo konstruktor: 3, -1
Gyerek metodus: 5
Szulo metodus: -1
Szulo metodus2: -1
true


üdv Csaba

folyt: 12-es ben,
cserébe javítottam az enyémet is egy picit, most annak kimenetet is un. mint ennek, van benne egy csak örökösítést szolgláló konstruktor hívás... most ugyanott tartunk, csak én bemásoltam az adott proto-ba az szülő elem adott metódusát hívó függvényt, nálam nincs külön this.base.foo hanem this._base_foo -n keresztül lehet un. csinálni, kivéve

itt this.baseConstructor van és nincs this.base.construct vs nálam this._base_constr is van :)
13

Két pont

vbence · 2008. Ápr. 29. (K), 11.30
Mindkét pont jogos, a kaluzúrát valóban elnéztem, a return szintén olyan dolog, ami nem árt ;)

Effektív különbség kevés van a két megközelítés között, ami erénye az általam felvázolt módszernek, hogy a this.base-en keresztül bármelyik metódust lehe hívni az "ősosztályból", olyat is, amit nem írtunk felül. (Így mobilisabb a kód).
15

írnál erre példát

toxin · 2008. Ápr. 29. (K), 15.01
csak mert ... :)

             var A = Class({
                methodA: function(){
                    console.log("a");
                    this.methodA_AA();
                },
                methodAA: function(){
                    console.log("aa");
                },
                methodA_AA: function(){
                    console.log("végig öröklődőtt C-ből is elérhető")
                }
            });
            var B = Class(A, {
                methodA: function(){
                    console.log("b");
                    this.methodAA();
                },
                methodAA: function(){
                    console.log("bb");
                    this._base_methodA();
                    this.methodBB();
                },
                methodBB: function(){
                    console.log("nem irtam felül,átöröklődött C-be is");
                    console.log(arguments.callee == C.prototype["methodBB"]);
                }
            });
            var C = Class(B, {
                methodA: function(){
                    console.log("c");
                    this._base_methodA();
                }
            });
            
            c = new C;
            c.methodA();
kimenet
c
b
bb
a
végig öröklődőtt C-ből is elérhető
nem irtam felül,átöröklődött C-be is
true


kérdéses ugye B:methodAA

üdv Csaba
16

Amire gondolok

vbence · 2008. Ápr. 30. (Sze), 09.13


// Van egy osztaly egy metodussal
 var A = Class({  
    methodA: function(a){  
        console.log(a);  
    }
});

// örkítjük
var B = Class(A, {

    // szigorítjuk a methodA feltételét  
    methodA: function(a){
        if (a != null)
            this._base_methodA(a);
    }, 
 
    methodB: function(){
        // itt viszont null-lal is kell dolgozzunk, úgyhogy az eredeti methodA-t használjuk
        this._base_methodA(null);
    }
});
Mi történik, ha már nincs szükség a methodA szigorítására, ezért töröljük a B classból? Ekkor a methodB-ben található this._base_methodA már undefined lesz, és a kód megszűnik működni.

Persze, lehet azt mondani, hogy körültekintően kell refaktorizálni, de én fontosak érzem, hogy ami egyszer működött, az mindig működjön. (Más kérdés, hogy kifejezetten nevelő hatású lehet, ha rá van kényszerítve a felhasználó, hogy időről időre átböngéssze a kódját :)
17

OFF: szigorítás öröklődéskor

Hodicska Gergely · 2008. Május. 9. (P), 14.06
A konkrét témától eltekintve elég rossz a példa. Ilyet nem illik csinálni, egy leszármazott interfésze nem lehet szűkebb, mint az ősé, különben ugrott a polimorfizmus.


Üdv,
Felhő
19

Bocsánat :)

vbence · 2008. Május. 10. (Szo), 15.00
Egyszerűen nem jutott eszembe semmilyen példa...