面向对象

面向对象心得：

1. delete用法
语法：boolean delete 数据，指在当前作用域上删除数据
用法：
（1）删除数组中的一个元素
     
(2) 删除一个对象的属性或方法
     
（3）删除一个没有用var声明的变量

用法（1）
  Var arr = [1,2,3,4];
 
Console.log(arr);     //[1,2,3,4]
 
Console.log(arr.length);  //4
 
Var isTrue = delete arr[2];
 
Console.log(arr);//[1,2,3:4]
 
Console.log(arr.length);//4
 
用法（2）
  
Var o = {name:”jim”};
 
Var isTure = delete o.name;
 
Console.log(o.name);  //undefined
 
Console.log(o[name]);  //undefined
 
用法（3）
  
Var n = 1;
 m = 2;
  
Var isTure1 = delete n;
  
Var  isTure2 = delete m;
 
Console.log(isTure1);  //false
 
Console.log(isTure2);  //true
 
Console.log(n);   //1
 
Console.log(m);   //mdefined

2.  创建对象
Var
Person = function(name,age,sex){
    
This.name = name;
    
This.age = age;
    
This.sex = sex

}

Person.prototype.sayHello = function(){
    
Console.log(“1”);

}

Var p1 = new Person(‘tyy’,23,’女’);

Var p2 = new Person(‘thh’,24,’女’);

Console.log(p1);
Console.log(p2);

3.  原型对象于原型属性
__proto__与prototype有什么区别？

__proto__是站在对象的角度讨论其原型对象；

Prototype 是站在构造函数的角度讨论原型属性，或构造函数创建的对象的原型对象；

4. 关于继承

 面向对象的特征就是 封装性, 继承性 和 多态性
 封装: 就是将复杂包裹, 隐藏起来, 让简单的东西预留在外面
 继承: 拿来主义, 自己没有, 把别人的拿过来, 让其成为自己的
 在 js 中有两种继承模型
 1, 原型继承
 2, 组合继承

1, 原型继承
// 如果需要让一个对象有某一个行为( 属性, 方法 ), 那么可以考虑将这个行为
// 加到原型对象中, 那么这个对象就继承自原型对象, 获得了该行为

 2, 组合式继承
// 组合式继承将其他的对象中的成员加到自己身上

4.1  什么是原型式继承
对象继承自其原型对象，所谓的原型式继承就是在 对象的 原型对象中加东西即可
// 如何使用原型对象
     1, 利用对象的动态特性添加成员
       var o = {};
      o.name = 'jim';
      var Person = function () {};
      Person.prototype.sayHello = function () {
        alert (' 哈哈哈 ');
       };
此时 原型对象是对象, 可以利用动态特性随时添加成员
添加的成员都会被 构造函数创建的对象所继承
     2, 利用覆盖原型对象
      var Person = function () {};
      Person.prototype.sayHello = function () {
        alert (' 啦啦！ ');
      };
       Person.prototype.sayGoodbye= function () {};
       Person.prototype.sayLove = function () {};
 //如果需要添加的内容非常多
        var Person = function () {};
        function Person() {}
        Person.prototype = {
        constructor: Person,
        sayHello: function() {},
        sayGoodbye: function() {},
        sayLove: function () {}
       };
// 这里由 Person 创建出来的对象什么类型?
// Object
// 为什么? 合理吗?
var p = new Person();
console.log( p.constructor.name );
        // 覆盖原型对象实现继承的时候, 一定要给新对象添加一个 constructor 属性
        // 以便模拟对象的类型. 但是如果对对象的类型要求不严格可以忽略

   3, 利用组合式继承添加原型成员
// 对象.extend( 对象 ) 

在实际开发中, 如果希望获得一个继承自 对象 o 的对象

   可以使用 Object.create 方法，ES5 提供的方法

 // 新对象 Object.create( 作为原型对象的对象 )
         
         var o1 = { name: 'jim' };
         var o2 = Object.create( o1 );
         // 明确函数调用语法，功能是什么?

// 它会创建一个新对象, 让他继承自参数 对象
         // 创建新对象就有构造函数
         // 继承对象就有原型对象
         
         
   function create( obj ) {
          function F() {}
       // 要有继承
        F.prototype = obj;
         return new F();
     }
      var o3 = create( o1 );
     // 在实际开发中, 如果是为了兼容所有的浏览器, 有两种做法
         // 1, 在原生对象中提供方法
         if ( !Object.create ) {
            Object.create = function ( obj ) {
               function F() {}
               // 要有继承
               F.prototype = obj;
               return new F();
            }
         }
         
         var o4 = Object.create( o1 );
         
         var _ = 0;
         // 2, 统一用新的方法
         var create = function( obj ) {
            if ( Object.create ) {
               return Object.create( obj );
            } else {
               
               function F() {}
               F.prototype = obj;
               return new F();
            }
         }
         
         
         var o5 = create ( obj );
         //小总结：
         // 无论浏览器是否支持该方法, 都应该使用自己定义的方法来完成, 但是
         // 在方法内部, 判断浏览器是否具有该功能, 如果有该功能
         // 则使用浏览器提供 的功能
         // 如果浏览器不支持该功能, 则自己实现
6.

// 继承的语法有几种, 分别是什么?
    //1.原型式继承：   //2.组合式继承
          //1.利用对象的动态特性添加  2. 利用覆盖原型对象  3.利用组合式继承添加原型成员
    obj.prototype.method1 =function(){} 
    obj.prototype.method2 =function(){} 

    obj.prototype = {
       method1= function(){}
       method2 = function(){}
    }

    obj2.extend(obj1);