面向对象

面向对象和面向过程

面向过程：面向过程就是分析出解决问题需要的步骤，然后用函数把这些步骤一个个实现，使用的时候依次调用。面向过程的核心是过程。
面向对象：面向对象就是把需要解决的问题分解成一个个对象，建立对象不是为了实现一个步骤，而是为了描述每个对象在解决问题中的行为，面向对象的核心是对象。

面向对象的优势

面向对象的优势：

模块化更深，封装性强。
更容易实现复杂的业务逻辑。
更易维护、易复用、易扩展。

面向对象的特征

面向对象的特征：

封装性；
多态性；
继承性；

类

类和对象

类：事物分为具体的事物和抽象的事物，当我们脑中出现“书”这个词的时候，可以大致想象到书的基本样貌特征，这个过程就是抽象，抽象出来的结果，就是类。
对象：而当我们拿起手里的一本真实存在的书的时候，这本书有自己的
书名、作者、页数等信息，像这种具体的事物，就是对象。

类的基本语法

class关键字：用来定义一个类
在ES6中使用constructor()来定义构造函数，作用是初始化对象的属性(成员变量)
构造函数不是必须的(不是必须定义的)
若用户没有定义构造函数，系统会生成一个默认的、无参的构造函数

// 定义类
class Person {
  constructor(name) {
    this.name = name;  }
}

// 利用类创建对象
var p1 = new Person('张三');	// 创建p1对象
var p2 = new Person('李四');	// 创建p2对象
console.log(p1.name);// 访问p1对象的name属性
console.log(p2.name); // 访问p2对象的name属性

class Person{
//    name = 'AAA'
//    age = 25
//    sex = '女'
  constructor(){
      this.name = 'AAA'
      this.age = 25
      this.sex = '女'
  }

   tt = function() { //普通的成员函数
    console.log("姓名："+this.name)
    console.log("性别："+this.sex)
    console.log("年龄："+this.age)
   }
}

类中的方法

普通的成员函数：

函数名([参数]){
	函数体语句
}

变量名 = function([参数]){
	函数体语句
}

如：

class Person {
  constructor(name) {this.name = name;}
  say() {	// 在类中定义一个say()方法
    console.log('你好，我叫' + this.name);
  }
}
var p1 = new Person('张三');
p1.say();	// 输出结果：你好，我叫张三

示例

模拟简单的计算器。定义名为Number的类，其中有两个数据成员n1和n2。编写构造方法，赋予n1和n2初始值，再为该类定义加（addition）、减（subtration）、乘（multiplication）、除（division）4个成员函数，分别对两个成员变量执行加、减、乘、除的运算。

class Number{
    constructor(n1,n2){
        this.n1 = n1
        this.n2 = n2
    }

    add(){
        return this.n1+this.n2
    }

    sub(){
        return this.n1-this.n2
    }
    mut(){
       return this.n1*this.n2
    }
    div(){
        if(this.n2 != 0){
            return this.n1/this.n2
        }else{
            return "除数不能为零!"
        }
    }
}

继承

在JavaScript中，继承用来表示两个类之间的关系，子类可以继承父类的一些属性和方法，在继承以后还可以增加自己独有的属性和方法。
定义父类和子类

父类必须已经定义，父类又称为基类或超类
子类又称为派生类，可以继承父类的属性和函数
子类不能继承父类的构造函数

// 先准备一个父类
class Father {
  constructor() {}
  money() {console.log(100);}
}
// 子类继承父类
class Son extends Father {}

调用父类的方法

// 创建子类对象
var son = new Son();
son.money();	// 输出结果：100

super关键字

super关键字用于访问和调用对象在父类上的方法，可以调用父类的构造方法，也可以调用父类的普通方法。

调用父类的构造函数：在子类的构造函数中使用super调用父类的构造函数，则调用语句必须作为子类构造函数的第一条语句（子类只可以调用）
调用普通函数：super.函数名([参数])
方法覆盖：若子类中定义的函数与父类中的函数同名时，子类的函数就覆盖了父类中函数
如：

class Father{  //父类(基类或超类)
    constructor(type,color){
        this.type = type
        this.color = color
    }
    money(){
        console.log(100)
    }
    show(){
        console.log("类型："+this.type)
        console.log("颜色："+this.color)
    }
}

class Son extends Father{ //Son是子类(又称为派生类)
    constructor(type,color,weight){
       super(type,color) //调用父类的构造函数
       this.weight = weight
    }
    show(){
        super.show()
        console.log("重量："+this.weight)
    }

    other(){
        return "子类的其他方法"
    }
}

静态成员和实例成员

实例成员：通过实例对象访问的成员称为实例成员
静态成员：是通过类名或构造函数访问的成员

function Student(name,age,sex){
    Student.school = '西安邮电大学' //school是静态的属性(ES5中的写法)
    this.name = name
    this.age = age
    this.sex = sex

    show = function(){
        console.log("姓名："+this.name)
        console.log("年龄："+this.age)
        console.log("性别："+this.sex)
    }
}

区别

实例成员属于具体的对象，而静态成员为所有对象共享
静态成员是通过类名访问，实例成员是通过对象名访问

ES6中静态属性的定义：

先创建类
在类的外部定义静态属性：类名.静态属性名

ES7中静态属性的定义

在类定义时，使用static关键字定义静态属性

静态的方法(函数)

只能通过类名访问，不能通过对象名访问

static  函数名([参数]){
	函数体语句
}

class Foo{
    static prop = 45
    constructor(){
        this.color = '红色'
    }

    static sayHello(){ //静态函数，只能通过类名访问
        console.log('Hello World')
    }
}
//Foo.prop = 45 //prop是静态的属性