原型与原型链

一、创建对象

1. 通过构造函数Object创建对象

   let obj=new Object();
       obj.uname="aaaaa";
       obj.age="20";
       obj.bol=true;
       obj.fn=function(){
           
       }

2. 字面量创建对象

   let obj={
           username:"wer",
           age:18,
           sex:"男",
           phone:"23456432333333333"
       }
   

3. 通过工厂函数创建对象

   function demo(uname,age,phone){
           let obj=new Object();
           obj.uname=uname;
           obj.age=age;
           obj.phone=phone;
           return obj;
       }
   let student0=demo("aaaa",18,"1234565432");
   let student1=demo("bbbb",20,"4567890282");
   let student2=demo("cccc",37,"2134588888");
   let student3=demo("dddd",29,"3456765432");
   console.log(student0,student1,student2,student3);

    4、通过构造函数实例化对象（函数名的首字符一定要大写）

function Person(uname,age,phone){
        this.uname=uname;
        this.age=age;
        this.phone=phone;
    }

    let p=new Person("姜邢",18,"123456323");
    let p1=new Person("苏涵",29,"defkmf");
    console.log(p,p1);

二、原型

 1.所有函数都有原型函数

（1）所有引用类型都有一个__proto__(隐式原型)属性，属性值是一个普通对象

function Person(uname,age,phone){ //构造函数
        this.uname=uname;
        this.age=age;
        this.phone=phone;
   }
   let p=new Person("姜邢",18,"123456323");
   let p1=new Person("苏涵",29,"9876543");
   console.log(p,p1);
   console.log(p.__proto__);

 

 

（2）所有函数都有一个prototype(原型)属性（用于存放公共方法），属性值是一个普通的对象

Person.prototype.fn=function(){
        console.log("这是原型对象上的方法");
    }
    console.log(p.fn);
    console.log(p.fn==p1.fn);

 

（3）所有引用类型的__proto__属性指向它构造函数的prototype

console.log(p.__proto__==Person.prototype);

（4）constructor   构造方法（原型对象创建的构造函数）

console.log(Person.prototype.constructor===Person);

 二、原型链

 当要访问一个对象的某个属性：

1.一般先在这个对象本身属性上查找（即 构造函数的实例化对象p,p1），

2.如果没有找到，则会去它的__proto__原型对象上查找(即p.__proto__)，即这个构造函数的prototype（即Person.prototype)

3.如果还没有找到就会在原型对象的原型对象(p.__proto__.__proto__)中查找

4.如果还没有找到,就会在(p.__proto__.__proto__.__proto__)中查找，但这是null,就会返回undenfined

这样一层一层向上查找就会形成一个链式结构，这就是原型链

三、原型与原型链的应用——继承【面向对象】

 （1）属性继承

// 父  构造函数
    function Father(uname,age,sex){
               // 指向创建它的实例对象
               this.uname=uname;
               this.age=age;
               this.sex=sex
    }
 // 子  构造对象
    function Son(uname,age,sex,email){
        // 指向创建它的实例对象 s
        // 使用 call() 立即调用父类方法，并传递参数
        Father.call(this,uname,age,sex);//继承 Father() 要向其中传递参数 但是          Father(uname,age,sex)的this不指向s，指向window,所以需要用到call来改变this指向
        this.email=email;// 子类  自身独有的属性
    }
let f=new Father("苏涵",50,"男");
let s=new Son("姜邢",19,"女","345@qq.com");
console.log(f,s);

（2） 方法继承

父/子构造对象如上一样
// Father构造函数的原型对象上的公共方法
    Father.prototype.money=function(){
        // 原型对象上的this  指向 调用它的  实例对象
               console.log(this.uname+"----在挣钱");
    }

    Son.prototype=new Father();  // 通过new将父构造函数 的 实例对象   赋值给 son 的原型对象
    Son.prototype.constructor=Son;  // 利用 constructor 手动改变Son的原型对象的指向的构造函数
    // 在son  的  原型对象上添加son独有的 game 方法
    Son.prototype.game=function(){
        console.log(this.uname+"-----在玩游戏");
    }

f.money();
s.money();
s.game();

 如图所示：