javascript 对象

java中的

     类：

           1、继承：在类建立时已经确定，所以建立对象后，子类对象可以拥有父类public方法和属性。

           2、属性和方法：在类建立时就确定，new 对象时只能调用，但是里面的值可以改变。 

           3、object 是所有类的父类。

   对象：

           1、建立对象时，通过构造函数调用，初始化对象的值，所以构造函数非常重要。

           2、建立一个对象，有一个唯一标识hashcode()，哪么当一个对象占有cpu后，对应的类对象this=hashcode，即用this来表示当前正在运行的对象。

         3、object是所有的父类，当应用一开始运行，系统建立object类对象，属于类实例，这个知识点自己猜的，一直未实验？

              目的：就是提供一些公共方法供所有子对象使用，最著名的也就是toString()方法。

                         还有就是定义现实世界，万物都是对象。

javascript：不知道有没有像java一样的类对象和对象的区分。

                类：Object,自己定义的类，

                       而且可以在一个函数里定义类？也是javascript的一大特点

                                   

javascript 建立对象的几种方法：

一、单个建立对象

1、 new Object建立对象，

       和java差不多，哪么Object 这个类哪里来的，是自带的吧！对

        对象的名字用person 来表示，其实person 就是指针，指向new Object建立的对象，在java中，person是可以和对象相连的引用符。       

var person = new Object();
     person.name = “Nicholas”;
     person.age = 29;
     person.job = “Software Engineer”;
     person.sayName = function(){
      alert(this.name);
    };

  哪么这个person可以建立新的属性和方法（和java不一样），也可以调用Object 的对象和方法（和java一样）。
  1》建立对象的属性name ,age,job

  2》建立对象的方法sayName（）方法

 构造函数: Object(),Object(value)；

 既然是系统自带的：哪么Object自带许多方法：toString()等， 还有Static Methods Object.create()；

 按照java说法Static 是类级别方法，从类中建立的无数对象都可以使用的此方法，所以每建立一个对象，这个方法不用指定this.

大多少书上javascript没有类的概念，其实类就是Object，

 如何确定所有的对象是来自同一个类？如何确定这个方法，新建的所有对象可以使用？答案在后面.

  在js中，所有的对象都是来自Object 类，create() 这个方法，按理说，只要以object建立的对象，全部可以使用这个方法？

2、上面改成用固定值建立对象，

      和JAVA 中 String s="hello"; 差不多 ,多个属性之间用逗号 分割。

var person = {
         name: “Nicholas”,
         age: 29,
         job: “Software Engineer”,
        sayName: function(){
                        alert(this.name);
          }
   }  

   1》方法也直接可以定义，自由扩充。 js一大亮点，太灵活了

   2》属性个数不固定，可以自动添加属性，stooge.nickname = 'Curly';   js一大亮点，太灵活了。

   java中只要容器对象如ArrayList 等可以自动添加数据，容器是可变长的。

  两种访问方法

   stooge['middle-name'] = 'Lester'; //数组式
   stooge.nickname = 'Curly';  //java一样.式。

三、函数里面用new Object建立对象

  1、在一个公共函数里建对象，也叫工厂模式，直接调用函数createPerson

   多个对象之间，属性名，方法名，一样，不一样就是属性数据，和执行同样的方法，结果不同。    

 例如：createPerson：调用一次，建立一个新的对象。
function createPerson(name, age, job){
    var o = new Object();
         o.name = name;
        o.age = age;
        o.job = job;
        o.sayName = function(){
                           alert(this.name);
                        };
  return o; 
 }

    确定是否同一个类下的对象：

      类：Object，哪么只要用这名字建立的对象，全部属于Object类下的对象。

      哪么Object类对象，应该有一个属性this:表示指定当前正在执行的对象。

        下面可以建立无数个对象，每建立一个对象时，就会在当前context建立一个this，表示当前执行对象。

     var person1 = createPerson(“Nicholas”, 29, “Software Engineer”);//返回对象的位置的指针。
     var person2 = createPerson(“Greg”, 27, “Doctor”);

2、工厂模式另一种，调用函数时用 new 。

   var friend = new Person(“Nicholas”, 29, “Software

function Person(name, age, job){
var o = new Object();
o.name = name;
o.age = age;
o.job = job;
o.sayName = function(){
alert(this.name);
};
return o;
}
var friend = new Person(“Nicholas”, 29, “Software Engineer”);
friend.sayName(); //”Nicholas”

四、Parasitic Constructor Pattern
     function SpecialArray(){
//create the array
var values = new Array();

 //用构造函数传过来的值，给数组赋初始值。
  values.push.apply(values, arguments);

 //assign the method
  values.toPipedString = function(){
      return this.join(“|”);
};
    //return it
return values;
}
var colors = new SpecialArray(“red”, “blue”, “green”);
alert(colors.toPipedString()); //”red|blue|green”   

这种模式缺点：返回values 数组对象和SpecialArray的构造函数和SpecialArray的 prototype 无关系，

所以用instanceof 检查SpecialArray对象的类型，就没有用了，好像values对象时构造函数外面的对象。

 所以这种模式在其它几种方法没有用时才起作用。

五、Durable Constructor Pattern，

     和  Parasitic Constructor Pattern差不多，有两点不一样：1、sayName 方法里没有this,2、调用构造函数时不用new   

   主要设置属性为私有，外面的不能调用它的属性，只有调用它的方法

function Person(name, age, job){
  //create the object to return
  var o = new Object();

  //optional: define private variables/functions here
  //attach methods
     o.sayName = function(){
         alert(name);
  };
//return the object
return o;
}
var friend = Person(“Nicholas”, 29, “Software Engineer”);
friend.sayName(); //”Nicholas”

六、The Constructor Pattern构造器模式建立对象        

      下面的类：this,由于js 是单线程，一次只有一个对象执行，哪么this表示正在执行的对象。

     类：Person ,构造器Person(name, age, job)

function Person(name, age, job){//
      this.name = name;
      this.age = age;
      this.job = job;
      this.sayName = function(){
                   alert(this.name);
          };
      }
var person1 = new Person(“Nicholas”, 29, “Software Engineer”);
var person2 = new Person(“Greg”, 27, “Doctor”);

  和上面相比：

     1 、没有对象明确建立。
     2、属性和方法直接赋值给 this.
     3、无返回值。

     建立一个Person的新instance, 使用新的操作员. 名叫构造函数，有以下4个步骤：
      1、建立new object();
      2.  this值 指向刚建立的对象(so this points to the new object).

      3.   增加对象的属性和方法。 (adds properties to the new object).

      4. 返回新对象object.。

建立Person对象：

        javascript                                                                java        

建立一个Person类，用函数建立一个Person类，class 系统建里一个Object类实例?系统建立一个Object类实例var person1=new Person();
建立无数个Person类对象 Person person1=new Person();

Object类可以建立新对象，并扩充新属性和方法？？有意思Object 是具体类，也可以建立新对象，但是不能扩充新属性和方法，所以建立也没有什么用。

 alert(person1 instanceof Object); //true
alert(person1 instanceof Person); //true
alert(person2 instanceof Object); //true
alert(person2 instanceof Person); //true

构造函数和其它函数比较:

  在调用时不一样

//当构造函数用 new
var person = new Person(“Nicholas”, 29, “Software Engineer”);
person.sayName(); //”Nicholas”

//当一个函数用， 直接用，方法和属性增加到window全局对象里面
Person(“Greg”, 27, “Doctor”); //adds to window
window.sayName(); //”Greg”

Person() 函数：使用call()(或apply())，函数里面给定一个特定对象，然后被调用
//其实就是把方法的地址传给o对象，然后o对象调用。
var o = new Object();
Person.call(o, “Kristen”, 25, “Nurse”);
o.sayName(); //”Kristen”

七、利用Object.create(o)创建对象，并指定新建对象F的原型Prototype是 对象o;

   if(typeof object.beget!='function')?????应该判断create，为什么判断beget？？？

   {

     object.create=function(o)

 {

    var F=function(){};

      F.prototype=0;

     return new F();

 };

}

var another_stooge=Object.create(stooge); ？？？Object.create应该可以换成随便的名字吗cat,dog,的等等，为什么要用Object.create建立？？？？？

参考书：JavaScript高级程序设计(第3版) 英文.pdf