js面向对象笔记

    /* 
    面向对象
    概述:
        面向对象是一种编程思维(oop), 他的核心就是:找有对应方法的对象做对应的事情(万物皆对象()万物可以被当做对象)
        面向对象的核心 对象(将一切不是动作的内容抽取为属性 将一切是动作的行为抽取为方法)
     */
    /* 
    对象的创建
    第一种通过构造方法创建(new关键词)
    构造方法是一个方法(函数) 它是一个匿名函数 它的名字就是你对应class的名字(首字母大写)
    */
    //构造函数 里面可以传递参数
    // function Person() {
    //      console.log(this);
    // }
    //class 的写法 它的底层就是上面的构造函数
    class Person {
        //构造函数
        constructor() {
            console.log(this);
        }
    }
    //对象实例的创建
    var person = new Person()
    person.name = "hello 傻狗"

    //工厂方法模式 (设计模式 类似于一个复用工厂 出产对应的对象 object是属于对象超类 所有对象都默认继承object)
    function factor(name, age) {
        //准备一个对象
        var obj = new Object()
        //将所有要设置的属性 设置给这个对象
        obj.name = name
        obj.age = age
        //将这个对象返回
        return obj
    }
    var person2 = factor("嘟嘟嘟", 18)
    console.log(person2);

    //第三种创建 使用字面量
    var Person = {
        name: "傻狗",
        age: 18,
        eat() {
            console.log("吃饭");
        }
    }

    /*
    总结
    构造函数创建的过程:
        1.自动创建对象
        2.手动添加属性
        3.自动返回对象
    工厂模式创建的过程:
        1.手动创建对象
        2.手动添加属性
        3.手动返回对象
     */
    /* 
    构造函数特性:
        1.首字母必须大写
        2.和普通函数没有区别(可以自由传值以及可以指定默认参数)
        3.需要new关键词修饰(如果没有参数可以省略后面的括号)
    */
    function Person(name = "tom", age) {
        this.name = name
        this.age = age
        this.sayHi = function () {
            console.log("Hi 傻狗");
        }
    }
    var person = new Person("jack", 18)
    person.sayHi()



    /*
    原型 prototype
    概述:
        prototype是每一个函数都有的一个空间(对象),里面就可以存放一些内容
    */
    /*
    constructor:构造器
    这个会指向对应的对象的构造函数 相对构造函数本身
    prototype:拥有的方法
    hasOwnPrototype 返回一个boolean类型的值 判断当前的对象上是否存在对应的属性
    isProtoTypeOf 返回一个boolean类型的值 判断当前的对象上是否处在对应的原型链上
    1.因为对应的构造函数也是一个函数 所以它同样具备这个内存空间(prototype)
    2.prototype是属于我们的构造函数的
    因为对应的构造函数有这个内存空间(对象) 所以我们可以往这个对象里面设置属性和方法
    */
    //构造函数
    function Person() {

    }
    //构造函数的原型prototype
    Person.prototype.name = "jack"
    Person.prototype.sayHello = () => {
        console.log("hello");
    }
    //当前person实例会自动读取到原型中的内容
    var person = new Person()
    //打印的属性是原型中的
    console.log(person.name);
    //原型中的方法
    person.sayHello()
    //通过对应的对象实例.属性名 可以访问到构造函数里面的prototype里面的值
    console.log(person.sayHello == person1.sayHello);//true
    /*
    总结
        1.我们一般将对应的属性存储咋构造方法里面
        2.将对应的方法存储在原型上
        3.存储在原型上的内容可以直接通过对象实例,去获取
     */

    /* 
    __proto__
    概述:所有对象都具备一个属性__proto__这个也是一个对象空间
    */
    var obj = {

    }
    console.log(obj.__proto__);

    //__proto__空间指向那
    function Person() {

    }
    Person.prototype.name = "傻狗"
    var person = new Person()
    console.log(person.__proto__);
    //我们的实例对象的__proto__和构造函数的prototype的指向是一致 这个两个东西就是一个东西
    console.log(person.__proto__ == Person.prototype);

    //在构造函数里面的我们是先编译一个构造函数(函数在预编译阶段先加载)再自动生成一个对象(构造函数先诞生 对象后诞生)
    //实例对象的__proto__指向对应构造函数的prototype的
    function Person() {

    }
    Person.prototype.name = "嘟嘟嘟"
    var person = new Person()
    person.__proto__.age = '18'//往原型中存数据
    var person1 = new Person()
    console.log(person1.age);

    /*
    原型链
        构造函数的prototype是一个对象 里面可以存放的对应的数据(不会二次的开辟空间)
        实例对象的__proto__它指向对应的构造函数的prototype
        构造函数是不是也是一个对象 它的__proto__指向哪:这个就诞生了原型链
    概述:
        对象在原型(__proto__) 上找属性的过程被称为原型链
    */
    //Object的构造函数设置一个属性
    Object.name = "hello"
    //Object的原型上设置一个属性
    Object.prototype.username = "Hi"
    function Person() {

    }
    Person.prototype = new Son()
    Person.prototype.age = 18
    function Son() {

    }
    var son = new Son()
    var person = new Person()
    console.log(son.name);//undefined
    console.log(person.name);//undefined
    console.log(son.age);//undefined
    console.log(person.age);//18
    console.log(son.username);//hi
    console.log(person.username);//hi

    /*
    总结
    原型链找的过程:
        1.先找自己的__proto__是否存在(构造函数的prototype)
        2.再找父类的__proto__是否存在(构造函数的prototype)
        3.再找对应的父类,直到直到Object的__proto__为止 如果还找不到
        4.找到null 并且返回
    原型链是会忽略对象的赋值的
        1.没有就创建这个属性
        2.有就更改这个属性
        3.它跟__proto__没有关系
    我们在创建构造函数的时候会将对应的属性写在构造函数上 将方法写在原型上
     */