javascript-面向对象和原型(1).

1.工厂模式解决了集中实例化的问题，解决了实例化大量重复的问题

function createObject(name ,age)
  {
      var obj =new Object();                                //创建对象
      obj.name =name;                                        //添加属性
      obj.age=age;        
      obj.run =function()                                    //添加方法
      {                            
          return this.name +this.age+'运行中...';
      }
        return obj;                                            //返回对象引用
  }
  
        var box1 = createObject('Lee',100);                    //创建第一个对象
        var box2 = createObject('Jack',200);                //创建第二个对象

        alert(box1.run());                                    //打印第一个实例run()方法    
        alert(box2.run());                                    //打印第二个实例run()方法

        //问题：无法识别问题，因为根本无法搞清楚他们到底是哪个对象的实例
        alert(typeof box1);                                    //object    
        alert(typeof box1);                                    //object
        //★instanceof判断一个变量是否是某个对象的实例 （条件是已知构造函数的名称）
        alert(box1 instanceof Object);                        //true
        alert(box2 instanceof Object);                        //true

2.构造方法&构造函数 [解决工厂模式不知道引用了哪个对象的实例]

  //构造函数名 首字母大写 
  function Box(name ,age)
  {
      //构造函数没有new Object,但它后台会自动 var obj =new Object;
      //this 是指的实例化的 对象
      this.name = name;
      this.age = age;
      this.run =function()
      {
          return this.name +this.age+'运行中...';
      }
      //构造函数不需要返回对象引用，它是后台自动返回的，没有return;
  }
    var box1 = new Box('Lee',100);        //实例化
    var box2 = new Box('jack',200);        //实例化
    
    alert(box1.run == box2.run);          //false 因为他们的引用地址 不一样，我们用prototype解决 这个问题
    
    alert(box1 instanceof Object);  
    alert(box1 instanceof Box); 
    
    var o =new Object();
    //对象冒充
    Box.call(o,'CSN',500);
    alert(o.run());

3.prototype原型[解决方法引用地址不一致]

 function Box(){};
 3      Box.prototype.name='Lee';
     Box.prototype.age=100;
     Box.prototype.run =function()
     {
         return this.name + this.age + '运行中...';
     }
10     var box1 =new Box();
    var box2 =new Box();

    alert(box1.run == box2.run);                        //true 方法写在原型上 引用地址共享
    
    alert(box1._proto_);                                //IE不支持 这个属性是一个指针指向prototype原型对象
    //★constructor
    alert(box1.constructor);                            //构造属性,可以获取构造函数本身
                                                        //作用是被原型指针定位,然后得到构造函数本身
                                                        //其实就是对象实例 对应的 原型对象的作用
                                    
    //★判断一个对象实例 是否指向了该构造函数 的原型对象，可以使用isPrototypeOf()方法来测试
    alert(Box.prototype.isPrototypeOf(box1));             //只要实例化对象,自动指向
    alert(Object.prototype.isPrototypeOf(box1));  

注：构造函数在创建实例的时候，实例会自动生成一个_proto_指针，指向原型对象[prototype]里的constructor [原型属性]

 

★原型模式的执行流程

function Box(){};                             //构造函数体内什么都没有，这里如果有，叫做实例属性，实例方法                            
        Box.prototype.name='lee';
        Box.prototype.age=100;
        Box.prototype.run=function()
        {
                return this.name + this.age+'运行中...';
        };
        
        var box1 = new Box();
        box1.name='Jack';                        //实例属性并没有重写原型属性
        alert(box1.name);                        //=> Jack 就近原则，优先 寻找实例里面的属性，如果没有就查找原型里面的属性
        
        //★判断 实例 中是否存在指定属性 可以使用hasOwnProperty()
        alert(box1.hasOwnProperty('name'));      
        
        //★in 操作符 不管实例属性 或者 原型属性 只要有就返货true两边都没有返回false
        alert('name' in box1);
        
        //如果我想访问了实例的属性，然后有访问原型的属性
        
        delete box1.name;                        //删除实例中的属性
        alert(box1.name);                 //=> lee
        delete Box.prototype.name;                //删除原型中的属性
        alert(box1.name);                //=> undefined

//判断只有原型中有属性
function isProperty(object , property)
{
    return !object.hasOwnProperty(property)&&(property in object);
}