js类与对象

gmx_white
124 阅读5分钟

1. 面向过程与面向对象

1.1 面向过程

面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候再一个一个的依次调用就可以了。

1.2 面向对象

面向对象是把事务分解成为一个个对象，然后由对象之间分工与合作。

1.3 面向过程与面向对象对比

面向过程面向对象
优点性能比面向对象高，适合跟硬件联系很紧密的东西，例如单片机就采用的面向过程编程。易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，可以设计出低耦合的系统，使系统 更加灵活、更加易于维护
缺点不易维护、不易复用、不易扩展性能比面向过程低

2. 对象与类

2.1 对象

对象是由属性和方法组成的：是一个无序键值对的集合,指的是一个具体的事物

  • 属性：事物的特征，在对象中用属性来表示（常用名词）
  • 方法：事物的行为，在对象中用方法来表示（常用动词）

2.1.1 创建对象

//字面量创建对象
var ldh = {
    name: '刘德华',
    age: 18
}
console.log(ldh);

//构造函数创建对象
  function Star(name, age) {
    this.name = name;
    this.age = age;
 }
var ldh = new Star('刘德华', 18)//实例化对象
console.log(ldh);

如上两行代码运行结果为:

2.1.2 对象的属性和方法的增删改查，测试，枚举，扩展，序列化

// 1. 查询和设置属性和方法  . or []
// .右边只能是命名属性的简单标识符
// []方括号中的值必须是表达式，其结果为包含目的属性名的字符串
ldh.name
ldh["main occupation"]  // "actor"
ldh["main " + "occupation"]  // "actor"

// 2. 删除属性和方法，仅删除自身属性，不包含继承属性
delete ldh.age

测试

// 3. 测试，检测对象是否有某个属性
"name" in ldh  // true
"toString" in ldh  // true 包含继承的属性
ldh.hasOwnProperty("toString")  // false，hasOwnProperty()不包含继承属性
ldh.aaa !== undefined  // !== 确保不是未定义
// 不能区分值为undefined的情况
ldh.x = undefined
ldh.x !== undefined  // false
ldh.y !== undefined  // false

枚举

可枚举属性：for/in，迭代器for/of，详情可见迭代器章节。

扩展

// 1. Object.assign()
let o = {x:1}
let copy = Object.assign({}, o)

更多扩展方法见深拷贝与浅拷贝

序列化

let o = {x:1, y:{z:[false, null, ""]}}
let s = JSON.stringify(o)
let p = JSON.parse(s)

属性的getter和setter

除数据属性之外，js还支持为对象定义访问器属性(accessor property)，这种属性不是一个值，而是访问器方法：getter和setter，也是可以继承的。

let p = {
  x: 1.0,
  y: 1.0,
  // r 是定义了set和get的可读写属性
  get r() { return Math.hypot(this.x, this.y)},
  set r(newVal) {
    let oldVal = Math.hypot(this.x, this.y)
    let radio = newVal / oldVal
    this.x *= radio
    this.y *= radio
  },
  // theta 是定义了get的只读属性
  get theta() { return Math.atan2(this.y, this.x) }
}
console.log(p.r)  // 1.4...
console.log(p.theta)  // 0.78...
console.log(p.x)   // 1
console.log(p.y)  //  1
p.r = 2
console.log(p.x)  // 1.4...
console.log(p.y)  // 1.4...

2.2 类

在 ES6 中新增加了类的概念，可以使用 class 关键字声明一个类，之后以这个类来实例化对象。类抽象了对象的公共部分，它泛指某一大类（class）对象特指某一个，通过类实例化一个具体的对象

2.2.1 创建类

//步骤1 使用class关键字
class name {
  // class body
}     
//步骤2使用定义的类创建实例  注意new关键字
var xx = new name();

注意:

  1. 通过class 关键字创建类, 类名我们还是习惯性定义首字母大写
  1. 类里面有个constructor 函数,可以接受传递过来的参数,同时返回实例对象
  1. constructor 函数 只要 new 生成实例时,就会自动调用这个函数, 如果我们不写这个函数,类也会自动生成这个函数
  1. 多个函数方法之间不需要添加逗号分隔
  1. 生成实例 new 不能省略
  1. 语法规范, 创建类 类名后面不要加小括号,生成实例 类名后面加小括号, 构造函数不需要加function

2.2.2 类的继承

关键字：extends

class Father {
      constructor(surname) {
        this.surname= surname;
      }
      say() {
        console.log('你的姓是' + this.surname);
      }
}

class Son extends Father{}
var damao= new Son('刘');
damao.say();      //你的姓是刘

注意:

  1. 继承中,如果实例化子类输出一个方法,先看子类有没有这个方法,如果有就先执行子类的
  2. 继承中,如果子类里面没有,就去查找父类有没有这个方法,如果有,就执行父类的这个方法(就近原则)
  3. 如果子类想要继承父类的方法,同时在自己内部扩展自己的方法,利用super 调用父类的构造函数,super 必须在子类this之前调用
 // 父类有加法方法
 class Father {
   constructor(x, y) {
   this.x = x;
   this.y = y;
   }
   sum() {
   console.log(this.x + this.y);
   }
 }
 // 子类继承父类加法方法 同时 扩展减法方法
 class Son extends Father {
   constructor(x, y) {
   // 利用super 调用父类的构造函数 super 必须在子类this之前调用,放到this之后会报错
   super(x, y);
   this.x = x;
   this.y = y;

  }
  subtract() {
  console.log(this.x - this.y);
  }
}
var son = new Son(5, 3);
son.subtract(); //2
son.sum();//8

  1. 时刻注意this的指向问题,类里面的共有的属性和方法一定要加this使用.

    a). constructor中的this指向的是new出来的实例对象

    b). 自定义的方法,一般也指向的new出来的实例对象

    c). 绑定事件之后this指向的就是触发事件的事件源

  1. 在 ES6 中类没有变量提升，所以必须先定义类，才能通过类实例化对象
avatar
文章
阅读
粉丝