第22课——面向对象简单探究与类1

面向对象简单探究

面向对象是一种变成的思维或者说思想，谈及面向对象，首先我们要了解面向过程。
    在面向过程中，我们会注重事物发展的逻辑顺序，按照顺序一步一步的执行。
但是
    在面向对象中，会注重事物发展的对象，研究对象的特征和行为，最后组织对象间的
    逻辑关系。
    1.研究和需求相关的对象
    2.研究对象的特征和行为
例:
    面向对象：
                    1.研究和需求相关的对象
                        小明 
                        餐馆
                    2.研究对象的特征和行为（和需求相关）;
                        特征：名词
                        行为：动词；

                        小明：{
                            name:"小明",
                            walk(){
                                console.log("走")
                            },
                            eat(){
                                consoe.log("吃");
                            },
                            giveMoney(){
                                console.log("给钱");
                            },
                            order(){
                                console.log("点菜")
                            }
                        }

                        餐馆：{
                            name:"餐馆",
                            out(){
                                console.log("出菜");
                            }
                        }

        // 小明.walk()--->小明.order()---->餐馆.out()---->
        // 小明.eat()-->小明.giveMoney()--->小明.walk();


        // 对象的特征（属性） 对象的行为（方法function）
上述方式中，只有小明去吃饭会就产生一个小明的对象，如果涉及很多不同的人，这些人去吃饭就会有
类似的方法和属性，这时我们会
    把类似的对象抽象成类  ，然后通过类来生产对象 。类的好处是可以生产多个类似的对象；
        1.类：是一类对象的抽象  （提高复用性）;
        2.类可以生产很多个相似的对象

js中的类和对象；

一、js中的对象

    创建对象的三种方法：
        1.字面量创建
            let obj = {name:"张三"};
        2.内置构造函数创建
            let obj = new Object();
            obj.name = "李四";
        3.在对象原型上创建属性和方法
            var obj =  Object.create({name:"王五"});

二、js中的类
    1.工厂模式：早期和类相似

         //注意---表示类的函数  约定俗成    首字母大写
         function GetDog (name,gender){          //创建一个函数，函数作用是传入狗名字和性别
             let obj = {} ;                      //创建一个狗的对象
             obj.name = name ;                   //狗的名字等于传入进来的名字
             obj.gender = gender ;               //狗的性别为传入进来的性别
             obj.bark = function(){              //给这个对象一个叫的方法
                 console.log("叫") ;
             }
             return obj  ;                       //返回这个对象
         }
         let daHuang = GetDog("大黄","公");      //申明一个大黄狗接收这个对象
         let xiaoHei = GetDog("小黑","公");      //申明一个小黑狗接收这个对象
         console.log(xiaoHei);                   
         console.log(daHuang);
         daHuang.bark();                         //调用大黄叫的方法
         setInterval(()=>{xiaoHei.bark();},1000) //让小黑每秒叫一次

        但是这种方法创建对象比较占用内存，性能不好
    2.构造函数  constructor

      function Person(name,age,gender){
          this.name = name ; 
          this.age = age ; 
          this.gender = gender ; 
      }
      Person.prototype.fn = function (){
          console.log("姓名是："+this.name+"年龄是："+this.age);
      }
      let zhangsan = new Person("张三",25,"男");
      zhangsan.fn();          //姓名是：张三年龄是：25

    a.构造函数提供一个公共的空间来存放    对象的行为或方法，  这个公共空间就是原型
    我们一般
        用工厂模式创建对象的属性或者说特征  =>  简单数据类型在栈中存放
        用原型创建对象的方法或者说行为   =>复杂数据类型存放在对象的原型上
    b.构造函数的调用
        new + 类名。例 ： let zhangSan = new Person("张三",20,"男");
        这里new调用函数分为隐藏的三部分：1、创建一个空的对象。
                                      2、把创建的空对象和函数内的this绑定
                                      3、返还这个对象
        用new调用函数也叫对象实例化。
    另外，上述我们在类的原型上定义的方法，看看是否同一个类实例化的对象方法都在同一片公共区域
    我们可以再次new一个新的对象
    例：    let lisi = new Person("李四",24,"男");
            console.log(lisi.fn === zhangSan.fn);  //打印的结果为true

constructor 构造器

prototype是对象（对象的实例化）的原型，同时也是一个对象，在这个对象上，有一个系统已经定义好的
属性叫做constructor，它的属性值指向实例化这个对象的类。
如上面例中：    我们实例化对象zhangSan后，zhangSan对象的原型prototype上，constructor全等于我们的类
--注--
1.在原型上添加内容的时候只能追加属性，如果是覆盖式，那么要把固有属性constructor补回来
2.constructor可以判断对象的出处
例：    let arr = [1,2,3,4]
        if ( arr.prototype.constructor === Array ){
            console.log("是一个数组");
        }
        在这里，我们用typeof检测不出的复杂数据类型可以查看它的原型
    同理，对象以及正则等等，都可以查看原型来看数据类型

原型

1.原型是一个对象
2.两种原型
    a、显示原型 
        在对象实例化之前，类的原型叫做显示原型
    例：    Person.prototype.fn = function (){ console.log("fn"); };
    b、隐式原型
        在对象实例化之后，对象的原型叫做隐式原型
        在控制台，我们一般看到的隐式原型是这样子
            [[prototype]]     <====>    __proto__ 
        这两种是一样的

        ---注---
            隐式原型的获取与设置
                获取。例：  let res = Object.getPrototypeOf(zhangSan);  //获取zhangSan这个对象的隐式原型
                设置。例：  Object.setPrototypeOf(zhangSan,{height:"175cm"});
                        //在zhangSan这个对象的隐式原型对象赋值为一个对象    覆盖式赋值
3.对象组成及查找
    a、对象是由自身属性和方法 + 原型的属性和方法共同构成
    b、对象查找规则，会先在自身查找；
        如果自身查找不到，就会在原型上查找，如果都没找到就会返还undefined