面向对象与原型 创建对象

一、创建对象

        1、原始方式   

var gf = {}

gf.name = “张三”;
gf.age = 18;
sex: "男";
gf.cry = function() {
    console.log(this.name + “向你问好”);
};

        缺点：不能重复使用

        2、工厂模式

        概念 工厂模式是很是常见的一种设计模式，它抽象了建立具体对象的过程。JS 中建立一个函数，把建立新对象、添加对象属性、返回对象的过程放到这个函数中，

function createObj(name,age){
     var obj = new Object();
     obj.name = name;
     obj.age = age；
     return obj;
}
var obj1 = createObj("张三" , 30);
var obj2 = createObj("李四" , 36)；

        优点：可以批量创建对象

        缺点：无法识别创建类型

        3、构造函数

        JS 中构造函数与其余函数的惟一区别，就在于调用它的方式不一样。任何函数，只要经过new 操做符来调用，那它就能够做为构造函数

function Person(name,age){
    this.name = name;
    this.age = age;
   this.speak = function(){
       console.log("hello")
   }；
   this.say = new Function(‘console.log("hello")’)；
}

var p = new Person("张三",30)；
var p2 = new Person("李四" , 36)；

        p instanceOf Person      true
     实例 从属Person类

        引用类型：数组,对象,函数

    每一个引用类型都有一个__proto__属性  隐式原型对象[[prototype]]

    每一个函数都有一个原型对象 显示prototype

        new 操作符干了什么

        1. 在内存里创建一个对象
        2.这个新对象内部的[[Prototype]]特性被赋值为构造函数的 prototype 属性
        3.构造函数内部的 this 被赋值为这个新对象（即 this 指向新对象）
        4.执行构造函数里的其他代码
        5.如果构造函数返回非空对象，则返回该对象；否则，返回刚创建的新对象（返回this）

        p.__proto__   === Person.prototype 
        Person.prototype.constructor === Person
        p.__proto__.__proto__  === Person.prototype.__proto__ === Object.prototype
        p.__proto__.__proto__.__proto__     null

        缺点：消耗内存

function Person(name,age){
    this.name = name;
    this.age = age;
   this.speak = fun;
}

function fun(){
   console.log("hello")
}；

        缺点: 破坏了封装性

        4、原型方法

       原型方法： 把实例共享的属性和方法放到原型对象中去，而不是放在构造函数中，这样每一次经过构造函数new一个实例，原型对象中定义的方法都不会从新建立一次。

function Person(){}
Person.prototype.name = "jack";
Person.prototype.speak = function(){
   console.log("原型上的方法");
}
var p = new Person();
p.name;
p.speak();

原型重写：
function Person(){}
Person.prototype = {
     constructor：Person,
     "name" : “jack",
      age : 40，
      speak : function(){}
}
var p = new Person();
p.name;
p.speak();

console.log(Person.prototype.isPrototypeOf(p)); //true p实例对象在原型连上
console.log(Object.prototype.isPrototypeOf(p)); //true p实例对象在原型连上
console.log(p.hasOwnProperty("name")); //false 不在实例里
console.log(p.hasOwnProperty("sex")); //true 在实例里

console.log("name" in p); //true
console.log("abc" in p); //false

        1.判断一个对象是否在另一个对象的原型链上
        原型对象.isPrototypeOf(对象)
        如果该对象在另一个对象的原型链上，返回true,否则返回false

        2.判断一个属性是否存在实例上
        obj.hasOwnProperty(属性)
        如果属性在实例对象obj里能找到，返回true,否则返回false

        3.in操作符
        属性  in  obj
        用来判断obj对象里是否存在属性 (不管在实例或原型上)
        不管在实例或原型上存在这个属性，均会返回true，否则返回false

   原型方法

        优点:共享

        缺点：也是共享

        5、终极方法  构造函数+原型对象

        构造函数用于定义实例属性，而共享属性和方法定义在原型对象中。这样每一个实例都有本身独有的属性，同时又有对共享方法的引用，节省内存。

function Person(name, age){
    this.name = name;
    this.age = age;
    this.family = ["大哥",“二哥”];
}
Person.prototype.speak = function(){}
var p = new Person("张三", 20);

function Person(name, age){
    this.name = name;
    this.age = age;
    this.family = ["大哥",“二哥”];
}
Person.prototype = {
   constructor : Person,
   sing:function(){},
   speak(){}
}
var p = new Person("张三", 20)

        6、ES6定义类

class 类名{
  constructor(name,age){
      this.name = name;
      this.age = age;
  }

   方法名(){}
   static 方法名(){}
}
var p = new 类名("张三",20)
p.方法名()

        静态方法调用    类名.方法名()