非哥 请

  function New(aClass, aParams)  //创建对象的函数，用于任意类的对象创建
    {
        function new_()    //创建对象的临时函数壳
        {
            this.Type = aClass;    //我们也给每一个对象约定一个Type属性，据此可以访问到对象所属的类
            if (aClass.Create)
              aClass.Create.apply(this, aParams);  //我们约定所有类的构造函数都叫Create，这和DELPHI比较相似
        };
      new_.prototype = aClass;    //这个用法奇怪啊
        return new new_();
    }; 背景：
  //语法甘露：
    var object =    //定义小写的object基本类，用于实现最基础的方法等
    {
        isA: function(aType)   //一个判断类与类之间以及对象与类之间关系的基础方法
        {
            var self = this;
            while(self)
            {
                if (self == aType)
                  return true;
                self = self.Type;
            };
            return false;
        }
    };
    
    function Class(aBaseClass, aClassDefine)    //创建类的函数，用于声明类及继承关系
    {
        function class_()   //创建类的临时函数壳
        {
            this.Type = aBaseClass;    //我们给每一个类约定一个Type属性，引用其继承的类
            for(var member in aClassDefine)
                this[member] = aClassDefine[member];    //复制类的全部定义到当前创建的类
        };
        class_.prototype = aBaseClass;
        return new class_();
    };
    
    function New(aClass, aParams)   //创建对象的函数，用于任意类的对象创建
    {
        function new_()     //创建对象的临时函数壳
        {
            this.Type = aClass;    //我们也给每一个对象约定一个Type属性，据此可以访问到对象所属的类
            if (aClass.Create)
              aClass.Create.apply(this, aParams);   //我们约定所有类的构造函数都叫Create，这和DELPHI比较相似
        };
        new_.prototype = aClass;
        return new new_();
    };    //语法甘露的应用效果：    
    var Person = Class(object,      //派生至object基本类
    {
        Create: function(name, age)
        {
            this.name = name;
            this.age = age;
        },
        SayHello: function()
        {
            alert("Hello, I'm " + this.name + ", " + this.age + " years old.");
        }
    });
    
    var Employee = Class(Person,    //派生至Person类，是不是和一般对象语言很相似？
    {
        Create: function(name, age, salary)
        {
            Person.Create.call(this, name, age);  //调用基类的构造函数
            this.salary = salary;
        },
        ShowMeTheMoney: function()
        {
            alert(this.name + " $" + this.salary);
        }
    });    var BillGates = New(Person, ["Bill Gates", 53]);
    var SteveJobs = New(Employee, ["Steve Jobs", 53, 1234]);
    BillGates.SayHello();
    SteveJobs.SayHello();
    SteveJobs.ShowMeTheMoney();
    
    var LittleBill = New(BillGates.Type, ["Little Bill", 6]);   //根据BillGate的类型创建LittleBill
    LittleBill.SayHello();
    
    alert(BillGates.isA(Person));       //true
    alert(BillGates.isA(Employee));     //false
    alert(SteveJobs.isA(Person));       //true
    alert(Person.isA(Employee));        //false
    alert(Employee.isA(Person));        //true

解决方案 »

  1.   

    那个是 prototype 链用于实现继承的效果
      

  2.   

    prototype实际上就是一个对象链。
      

  3.   


    <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
    <HTML>
     <HEAD>
      <TITLE> New Document </TITLE>
      <META NAME="Generator" CONTENT="EditPlus">
      <META NAME="Author" CONTENT="">
      <META NAME="Keywords" CONTENT="">
      <META NAME="Description" CONTENT="">
     </HEAD> <BODY>
      <script>
    var b=function() {             
    }   
    b.prototype.p=1;   
                       
    var c=new b();   
    alert(c.p);
    c.p=2;     
    alert(c.p);
      </script> </BODY>
    </HTML>prototype 属性  必须是用 function 声明的对象才有
      

  4.   

    javascript定义类的函数加prototype是什么意思这里的解释很有意思。
      

  5.   


    <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
    <HTML>
     <HEAD>
      <TITLE> New Document </TITLE>
      <META NAME="Generator" CONTENT="EditPlus">
      <META NAME="Author" CONTENT="">
      <META NAME="Keywords" CONTENT="">
      <META NAME="Description" CONTENT="">
     </HEAD> <BODY>
      <script>
    var b=function() {             
    }   
    b.prototype.p=1;   
                       
    var c=new b();   
    alert(c.p);
    c.p=2;     
    alert(c.p);
    var plglenn=new b();
    alert(plglenn.p);
      </script> </BODY>
    </HTML>为什么输出  1  2   1  
    而不是  1   2    2
      

  6.   

    var plglenn=new b();
    alert(plglenn.p);重新实例化了一下~~
      

  7.   

    var c=new b();  
    alert(c.p);// 1 
    c.p=2;    
    alert(c.p);// 2 之所以 var c=new b();  
    alert(c.p);// 1 就是因为 prototype 链的原因 c 因为是 function 声明的对象所以有 prototype 属性 c 没有 p 属性，但 会去找c 的隐含 prototype 属性，是引用值. 就找到了 b ，因为b 有p 属性，所以就返回了 b.p 也就是 1 当c 有p 属性时 就覆盖了 父类 (可以这样理解) 的 p 属性 这时 c.p 就是 设置的值了
      

  8.   

    效果和var c=new b();   
    alert(c.p);
    一样的~
      

  9.   

    你声明的var plglenn=new b();输出的b.prototype.p=1;   
      

  10.   


    当然不会是 1 2 2 ， 你可以从继承的角度来看这个问题plglenn 继承自 b ，那么 它的p 属性如果没有设置的话，自然是 b 的p 属性  也就是 1
      

  11.   


    当然不会是 1 2 2 ， 你可以从继承的角度来看这个问题plglenn 继承自 b ，那么 它的p 属性如果没有设置的话，自然是 b 的p 属性  也就是 1b是什么？是一个虚构的类，还是真实的对象？对象？
      

  12.   

    依靠 prototype ，来实现 面向对象语言的特性
      

  13.   

    javascript 中 没有类。b 是对象，用 function 定义的对象
      

  14.   

     <script>
    var b=function() {             
    }   
    b.prototype.p=1;   
                       
    var c=new b();   
    alert(c.p);
    c.p=2;     
    alert(c.p);
      </script>比如现实中的继承：
    有两种：
    假设蒋涛的儿子叫小蒋蒋
    A   蒋大刚有一辆奔驰车，有一个房子，有一个老婆
    小蒋蒋  要继承蒋涛的奔驰车，房子  
    这样其实不是我们程序重的继承吧B     蒋大刚有一辆奔驰车，有一个房子，有一个老婆
    小蒋蒋  自己创造  要购买了奔驰车，房子    （不过和将大纲的一样罢了）
     
    我觉得我们谈的继承和现实不同罢了，应该叫  【盗版】    
    继承在中文是只有一个，盗版在中文中是两个
    而强语言中的继承，因为祖先是类，这是不存在的，而js祖先就是对象了
      

  15.   

    var Annimal=function() {             
    }   
    Annimal.prototype.footer=2;   
                       
    var plglenn=new Annimal();   这个Person应该理解为一个人的DNA比较 好吧？
    var plglenn=new Person();  理解为工厂加工出来一个人同样，如果dna是spider var Annimal=function() {             
    }   
    Annimal.prototype.footer=8;   
                       
    var heiguanfu2010=new Annimal();   
    上帝给我们很多抽象的DNA
    比如同样是一个蛋，dna不懂，可能就是小鸡或者鳄鱼了。jsFunction   Person(){    }
    c#
    Class Person(){   }这些东西都是一个抽象的代码，不存在的，没有任何攻击力，但是他们决定了从一个工厂出来的是
    ：鳄鱼谔谔，人诸葛亮，熊猫欢欢等实体，这样理解，我心了然