面向对象及原型链

面向对象

以对象为核心

面向对象思想

就是以对象为核心来解决问题的思想
1.根据问题找到对象
2.根据特征造对象
3.控制对象做事情

oop

object oriented programming（面向对象编程）

POP

Procedure Oriented Programming(面向过程编程)
一堆指令的集合
任何问题都通过 过程(一堆指令)来解决
一般通过函数来管理一堆指令
面向过程 也称为 面向函数

构造函数

function Fun(name,age){
	this.name = name,
	this.age = age
}
let fun = new Fun();

new的执行步骤：

• 先创建一个新对象，
• 然后给对象添加函数里的属性，
• 然后赋值给变量

问题1（利用原型挂在解决内存占用）：

• 在构造函数中给对象添加函数方法的话，在创建多个该函数的对象时会导致内存里生成很多个该方法
• 利用构造函数名.prototype.方法名 = function(){}来给构造函数添加函数方法

问题2

• 没有挂载在原型对象上的方法，不同对象调用他们是不相同的方法
• 挂载在原型对象上的方法，不同对象调用他们也是全等的

	function Bird(){
        this.fly = function() { }
    }
    Bird.prototype.run = function(){ }
    let bird1 = new Bird();
    let bird2 = new Bird();
    console.log(bird1.fly===bird2.fly);//返回false
    console.log(bird1.run===bird2.run);//返回true

问题3（this指向问题）

• 在普通函数中，this指向函数的调用者，没有调用者则指向window
• 在箭头函数中，this指向函数当前所处环境
• 在构造函数中，this指向对应的构造的对象

prototype原型对象

• prototype获取构造函数自己的原型对象
• __proto__获取缔造我的人的原型对象
• 通过构造函数获取原型对象 构造函数名.prototype
• 通过构造函数创建的对象获取构造函数原型对象 对象名.proto
• 通过constructor获取对应的构造函数 对象名.proto.constructor 或 构造函数名.prototype.constructor

原型链

• 构造函数和原型对象的关系是自动创建的，有构造函数就有对应的原型对象
• 任何对象的__proto__都指向它的缔造者的原型
• 任何缔造者（构造函数）的prototype.__proto__就是是Object的原型对象
• 所有的构造函数的的缔造者是Function构造函数，也就是缔造者（构造函数）的__proto__.constructor指向Function构造函数
• 

构造函数的继承

• 原型继承（继承来的方法只能通过原型去访问）
  先定义一个Animal构造函数，并初始化一个对象方法，在原型上添加一个方法

        function Animal(){
            this.eat = function(){
                console.log("吃东西");
            }
        }
        Animal.prototype.huxi = function(){
            console.log("呼吸");
        }

1.原型继承的写法一：创建一个Cat构造函数，把Cat原型的值设置成Animal原型的值，这样Cat创建的对象只能访问到Animal的原型里的方法（无法继承到构造函数内初始化对象的方法）

        function Cat(){}
        Cat.prototype = Animal.prototype;
        let cat1 = new Cat();
        cat1.huxi();
        console.log(cat1);

2.原型继承的写法二：创建一个Dog构造函数，把Dog的原型=Animal所创建的对象，这样Dog的原型就变成了Animal所创建的对象，既可以访问Animal初始化对象的方法，也可以访问Animal原型里的方法（但是调用方法时都是从原型上去找到的，没有自己的初始化对象方法）

        function Dog(){}
        let animal = new Animal();
        Dog.prototype = animal;
        let dog1 = new Dog();
        dog1.eat();
        dog1.huxi();
        console.log(dog1);

• 构造继承（继承到的构造函数的初始化对象的方法在自己的构造函数中）
  创建一个Bird构造函数，在Bird函数内调用Animal函数，然后在Bird创建的对象中只能访问Animal的初始化对象的方法，无法访问Animal原型的方法（无法继承到构造函数的原型的方法）

        function Bird(){
            Animal.call(this);
        }
        let bird1 = new Bird();
        bird1.eat();
        
        console.log(bird1);

• 联合继承
  通过原型继承的写法一和构造继承（构造函数的初始化对象方法和原型上的方法都能获取到，而且初始化对象的方法就在自己的构造函数内直接用，不用在原型上查找，原型的方法依旧是在原型上）

        function Tiger(){
            Animal.call(this);
        }
        Tiger.prototype = Animal.prototype;
        let tiger1 = new Tiger();
        tiger1.eat();
        console.log(Tiger.prototype);
        console.log(tiger1);