面向对象（OOP）

目录

1.概念

2.面向对象

3.怎么写对象

4.系统对象

5.三大特性

6.深拷贝知识

7.具体案例：数组去重和反转字符串（敲重点）

---

1.概念

（1）什么是“对象”：不了解内部结构，知道表面的操作

（2）什么是“面向对象”：不了解原理的情况下，会使用功能

（3）面向对象是一种思想，生活中处处都可以应用，万事万物都是对象

2.面向对象

（1）特点

   <1>封装

      1）不考虑内部实现，只考虑功能使用

      2）人的因素

         1>用对象的人

         2>写对象的人：用封装把一堆属性和方法集合在一起

   <2>继承

      1）目的：最大限度重用代码

      2）多重继承（注意：该方法慎用）

      3）遗传

   <3>多态：表现的形式太弱

   <4>抽象

      1）抓住核心的问题

      2）抽：抓

（2）组成

   <1>属性（变量：就是同一个东西，场景不同，称呼不同）

   <2>方法（函数：就是同一个东西，场景不同，称呼不同）

（3）恶心点

   <1>this   该方法指向(属于)谁

   <2>this   占了95%

（4）js中常见对象

   <1>Array：数组，用来存储数据

   <2>Date：日期

   <3>RegExp：正则表达式，用以字符串验证

   <4>Object

         1）可以理解为空对象，什么都没有，意味着啥都可以往上添加

         2）没有功能

3.怎么写对象

（1）使用Object

   <1>var obj=new Object()

   <2>new 出来的是一个具体的对象

代码：

   // 语法
    // 1. new  Object()     new开辟堆内存空间
    var  obj = new Object();
    obj.name = "yyqx";
    obj.ns = 2;
    obj.sun = function(a,b,d){
        // this指向函数的拥有者
        return  a + b + c + this.ns;
    }
    console.log(obj);

运行结果：

（2）字面量创建/json

   <1>写法简易，语法简单，但是重用性低

   <2>适用于整个程序里只有一个的对象

   <3>var obj={}

代码：

    // 2. JSON(基于对象)
    var  shz = {
        description: "105个男人与3个女人的故事",
        sale: function(price){
            console.log(price);
        },
        author: "施耐庵"
    }
    console.log(shz);

运行结果：

（3）工厂方式

function   createPerson(name,qq){
       var   obj=new   Object();
}

代码：

    // 3. 工厂模式
    function  createBook(author,price,type){
        return  {
            author: author,
            price: price,
            type: type
        }
    }
    var  b = createBook("我替你记得",25,"叙事");
    console.log(b);

运行结果：

（4）构造函数创建对象（推荐）

   <1>具体案例：

var   a=new   My()
var   b=new   My()

      1）这是一种构造函数

      2）构造函数就是用来创建对象的

      3）为了与其它的函数进行区分，我们将函数名的首字母大写

   <2>问什么   a.move == b.move   弹出的是false?

代码：

    // 4. 构造函数；用来创建对象
    // 构造函数：开辟内存空间
    // 析构函数：释放内存
    function  Book(author,price,type){
        this.author = author;
        this.price = price;
        this.type = type;
        // 不要把函数或公共资源写在构造函数里
        // 容易造成内存的浪费
        this.sale = function(){
            console.log(this.price);
        }
    }

（5）原型   prototyoe

   <1>什么是原型

      1）公共汽车

      2）js中表示该组对象公用的

   <2>类与对象

      1）什么是类

         1>模型

            1)月饼模子

            2)Array

            3)Date

         2>成品

      2）什么是对象：产品，实例

         1>月饼

         2>arr=[1,2,3]

         3>date

   <3>原型是往类（模型/构造函数）上添加的

Array.prototype.sun=function(){}

   <4>开发常用模式：

      1）构造函数加属性，原型加方法

      2）也就是4（构造函数加属性，原型加方法） + 原型

代码：

    function  Book(author,price,type){
        this.author = author;
        this.price = price;
        this.type = type;
        // 不要把函数或公共资源写在构造函数里
        // 容易造成内存的浪费
        this.sale = function(){
            console.log(this.price);
        }
    }

    // 公共资源写在原型(prototype)中
    // 原型需要使用构造函数的名字来调用
    // 原型是一块独立的内存空间，本质是个对象(原型是用来节省内存空间的)
    Book.prototype.sale = function(){
        console.log(this.price);
    }

4.系统对象

（1）本地（非静态）

      1>Object（对象）

      2>Array（数组）

      3>Date（日期）

      4>Number（数字）

      5>Boolean（布尔值）

      6>String（字符串）

      7>Function（函数）

      8>RegExp（正则表达式）

      9>Error（错误）

（2）内置（静态）：Math

      例：new  Math();

（3）宿主

      1>DOM/BOM

      2>浏览器提供的

5.三大特性

（1）封装

      1>目的：将信息隐藏

      2>共有、私有：其实真的没有私有共有的区别，只是在命名的时候进行一下区分，自己知道这种命名是私有的即可

function   Gir(name,age){
       //共有属性
       this.name=name;
       this.age=age;

       //私有属性
       var _sex="girl"

       //共有方法
       this.eat=function(){
            alert("123")
       }
        
       var _xiuxiu=function(){
            alert("456")
       }
}

   注意： 上述代码中使用_来表示私有变量及私有方法

（2）继承

      1>目的：找到共性，精简代码，提高重用性

      2> 1）属性继承：call(),apply()

              1>改变父级构造函数内部的this

              2>例：

function  People(name){
      this.name=name;
      this.say=function(){
            alert("hello");
       }
}
function Student(name){
       People.call(this,name);
}

           2）原型继承：B.prototype=A.prototype

              1>这里有引用的问题

              2>修改A就会修改B，修改B就会修改A

           3）原型继承（推荐）：

for(var  x=in   A.prototype){
      B.prototype[x]=A.prototype[x];
}

      3> 1）子级对象原型指向父级对象实例

           2）B.prototype=new   A();

           3）B.prototype.constructor=B;

      4>具体案例：微信朋友圈

（3）多态（在JS中存在感很弱）

         目的：使语言具有动态性，具有更好的通用性

6.深拷贝知识

（1）for  in：只能对第一层深拷贝，如果里面的数据就是引用数据类型，就是浅拷贝了

（2）深拷贝使用JSON：JSON.parse(JSON.stringify())

7.具体案例：数组去重和反转字符串（敲重点）

（1）数组去重

代码：

   // 数组去重(面向对象方法)
    Array.prototype.SingleArr = function(){
        var  newArr = [];
        this.forEach(function(item){
            newArr.indexOf(item) === -1 ? newArr.push(item) : null;
        })
        return  newArr;
    }

（2）反转字符串

代码：

 // 反转字符串(面向对象方法)
    // String.prototype.reverseStr = function(){
    //     return  this.split('').reverse().join('');
    // }