Логика не совсем верная. В JS нет классов как таковых, но можно писать "как бы", при этом требуеться чётко знать границу между членами прототипа и собственными членами обьекта. Первые это общие на все обьекты от конструктора свойства, вторые это личные у каждого обьекта свои свойства.
Второй концептуальный момент, в конструкторе создавая методы через this.method = function ты для каждого обьекта создаёшь новую функцию, т.е. этот метод не являеться чем то общим для всех a1. Closures конечно вещь эффективная, так что потерь производительности в принципе нет.
Третьим концептуальным моментом назовём, на первый взгляд кривую, фичу, когда свойство constructor у обьекта сменяеться с A на B если прототипу его конструктора (A) был присвоен другой обьект порождённый от другого конструктора (B). Также следует отметить что все свойства прототипа установленные ранее будут потеряны, мы ведь замещаем его новым обьектом. Лучше перечитать это снова 
Собираем до кучи всё сказанное выше, соображаем: в JS "ООП" устроен несколько иначе, заменив прототип другим обьектом мы не наследуем, мы в прямом смысле (ну почти  ) говорим "этот обьект эквивалентент другому", даже instanceof это докажет.
Ну и заключением всего поста будет код как можно провернуть таки наследование в стиле Java:
| Код | //это будет наш предок, обращаем внимание на поле создаваемое в конструкторе
function parentA(val){
this.value = val;
}
//а это метод *прототипа*, не личное поле как value ;-)
parentA.prototype.print = function(){
//про личное поле value снова напомню, его нет в прототипе, оно создаёться в конструкторе
alert("From parent A, value: " + this.value);
}
//подопытный номер два, будет "наследовать" parentA
function childB(){
//отмечаем момент - нет никакого поля value
//раз нет классов с конструкторами, нет и "цепочки вызвовов конструкторов" как в Java ;-)
//для тестов смысла apply (см. ниже) можно здесь поставить
//this.value = 70
//и поиграться с типом вызовов на прямую или через apply/call - советую сделать ;-)
}
//parentA и childB совершенно разные конструкторы порождающие разные обьекты со своими разными print
childB.prototype.print=function(){
alert("From child B, we have no value ;-)");
//мы этот метод скопируем позже, но если кому то захочеться вызвать print до
//чудесного превращения childB -> parentA, то предотвратим бесконечную рекурсию
if(this.constructor.prototype.print != arguments.callee)
this.constructor.prototype.print.apply(this, arguments); //вызываем метод "предка"
//почему apply? а потому что это просто функция, на ком вызвали, туда this и укажет.
//вызовем на прямую this будет указывать на оригинальный обьект-прототип функции parentA
//напомню оригинальный обьект-прототип это обьект порождённый от конструктора, но
//при этом не имеющий полей установленных конструктором, т.е. конструктор не отрабатывает.
//этот обьект существует у всех функций и являеться пустым обьектом пока мы сами
//прототип не заполним, что мы и делали.
}
var dummy = new childB(); //это ещё old school обьект))
//запомнили эту строчку, естественно alert будет
if(dummy instanceof childB) alert("dummy is childB!");
childB.prototype=new parentA(45);
//конецептуальный момент! =)
if(dummy instanceof childB) alert("dummy is childB!"); //подсказка: ничего здесь не будет
//а почему? а потому что главного якудзу prototype дома childB убил и поставил себя на его место
//выходец из дома parentA. Все созданные ранне обьекты служат прошлому (реально убьёт его сборщик
//мусора когда все порождённые обьекты будут убраны) хозяину, тенью висящий среди них и никто не
//назовёт новый childB своим домом :)
//это телодвижение >перезаписывает< метод print у ранее созданного обьекта parentA, создавая тем
//самым >локальный (собственный для обьекта)< метод(а вообще поле) print.
//при этом помним про замещённый конкструктор childB на childA, следовательно можем добраться до
//прототипа предка. Есессно это всё доступно только для обьектов порождённых после текущих телодвижений.
childB.prototype.print = dummy.print;
var ob1=new parentA(90);
var ob2=new childB();
ob1.print(); //вызвыаем метод прототипа
ob2.print(); //заклинание: "вызываем локальный метод обьекта стоящего в текущий момент прототипом конструктора childB"; повторять до полного просветления.
dummy.print(); //не, ну старые обьекты есессно имеют свой старый обьект прототип и их конструктор никуда не делся
alert(dummy.constructor == childB); //мало того он всё тот же старый childB
alert(childB.prototype.value); //и ведь childB имеет теперь поле (локальное кстати) от обьекта порождённого parentA
alert(dummy.constructor.value); //но таки здесь таки один из редких "магических" моментов JS - value мы не видим, т.к. в constructor у нас лежит instance функции childB со своим старым прототипом.
|
Медитируем. Совет: не стоит выделывать Java из JS, обратись к изяществу Ruby
Помни что классы в Java это в первую очередь прямое отображение "физики" (размеры структур в памяти и т.д.), а т.к. Java с жёсткими типами в корне отличаеться от JS с duck-typing'ом, то приведение параллелей ни к чему хорошему не приведёт. Ruby чистый ООП скриптовый с "динамическими" типами язык. Вот так и стоит писать под JS. Примеры можно глянуть в http://prototype.conio.net/ фреймворке.
Думаю сим длинным постом дал пищу для ума
P.S. нашёл в prototype.js пару упущений и один серьёзный глюк, уже задумал prototyped.js на базе первого 
P.P.S однако заработался... прихожу на форум редко, пишу длиннющие посты... =) |
