您的位置:时时app平台注册网站 > 编程知识 > es6学习笔记12--Class【时时app平台注册网站】

es6学习笔记12--Class【时时app平台注册网站】

2019-10-12 09:16

 

一连是面向对象的四个非常重大的特征,通过一个品类对另三个类型的持续,可以使代码重复使用,同时也巩固了代码的职能上的扩充,承继的语法使用Class,在Python中,一切皆对象,都足以直接或然直接的去承袭(object)对象

荒诞不经变量升高

Class不设有变量升高(hoist),那或多或少与ES5通通差别。

new Foo(); // ReferenceError
class Foo {}

上面代码中,Foo类使用在前,定义在后,那样会报错,因为ES6不会把变量申明升高到代码底部。这种规定的原因与下文要涉及的后续有关,必得确定保障子类在父类之后定义。

当子类与父类下方法一致时,子类会覆盖父类的章程内容;其实那便是一种重写,也是一种多态。

接轨的意义和操作

Class的静态方法

类也便是实例的原型,全体在类中定义的点子,都会被实例承袭。假诺在二个措施前,加上static重在字,就表示该办法不会被实例继承,而是直接通过类来调用,那就叫做“静态方法”。

class Foo {
  static classMethod() {
    return 'hello';
  }
}

Foo.classMethod() // 'hello'

var foo = new Foo();
foo.classMethod()
// TypeError: undefined is not a function

下面代码中,Foo类的classMethod主意前有static入眼字,注脚该形式是贰个静态方法,能够平素在Foo类上调用(Foo.classMethod()),实际不是在Foo类的实例上调用。即便在实例上调用静态方法,会抛出一个不当,表示不设有该格局。

父类的静态方法,能够被子类承接。

class Foo {
  static classMethod() {
    return 'hello';
  }
}

class Bar extends Foo {
}

Bar.classMethod(); // 'hello'

下边代码中,父类Foo有二个静态方法,子类Bar能够调用那么些主意。

静态方法也是能够从super对象上调用的。

示范代码1:

3.私部分属性,方法不会被子类承袭,也无法被访谈。

Class基本语法

 

自作者对三番五次的知情就是,父类中的方法和性能有繁多,不过子类只关切须求的艺术和总体性,父类中贮存的形似都以一对公共的剧情,进步代码的复用性,子类能够每一日继承父类中的公共艺术和剧情。

概述

JavaScript语言的思想意识方式是通过构造函数,定义并生成新对象。上边是二个例证。

function Point(x,y){
  this.x = x;
  this.y = y;
}

Point.prototype.toString = function () {
  return '('   this.x   ', '   this.y   ')';
};

上边这种写法跟古板的面向对象语言(举例C 和Java)差距非常的大,很轻松让新学习那门语言的技士以为纳闷。

ES6提供了更就像是古板语言的写法,引进了Class(类)那么些概念,作为目的的沙盘。通过class根本字,能够定义类。基本上,ES6的class能够看作只是七个语法糖,它的多头意义,ES5都可以成功,新的class写法只是让对象原型的写法尤其分明、更像面向对象编制程序的语法而已。下面的代码用ES6的“类”改写,就是上面那样。

//定义类
class Point {
  constructor(x, y) {
    this.x = x;
    this.y = y;
  }

  toString() {
    return '('   this.x   ', '   this.y   ')';
  }
}

下面代码定义了八个“类”,能够看看里边有贰个constructor艺术,那便是构造方法,而this重在字则代表实例对象。也等于说,ES5的构造函数Point,对应ES6的Point类的构造方法。

Point类除了构造方法,还定义了一个toString办法。注意,定义“类”的方法的时候,前边没有供给丰裕function本条主要字,直接把函数定义放进去了就能够了。其他,方法之间无需逗号分隔,加了会报错。

构造函数的prototype天性,在ES6的“类”下面继续存在。事实上,类的有着办法都定义在类的prototype质量上面

class Point {
  constructor(){
    // ...
  }

  toString(){
    // ...
  }

  toValue(){
    // ...
  }
}

// 等同于

Point.prototype = {
  toString(){},
  toValue(){}
};

在类的实例上边调用方法,其实正是调用原型上的措施。

class B {}
let b = new B();

b.constructor === B.prototype.constructor // true

类的中间装有定义的情势,都以不可胜道的(non-enumerable)。

子类,一旦接二连三父类,就有所了父类的习性与办法,依照需求能够张开增加和删除改。

子类是传承父类的,可是子类也能够再度定义父类的存在的格局,那叫做重写,重写显示了子类的独立性还应该有可变性,也称得上(多态),方法重写有八个尺码1:继承的涉嫌。2:父类存在的办法。3:子类重新定义

中央用法

Class之间能够通过extends关键字福寿齐天持续,这比ES5的经过退换原型链完成一而再,要清晰和方便人民群众广大。

class ColorPoint extends Point {}

地点代码定义了一个ColorPoint类,该类通过extends关键字,继承了Point类的具备属性和方法。不过由于尚未配置任何代码,所以那八个类完全同样,等于复制了一个Point类。下面,我们在ColorPoint里面加上代码。

class ColorPoint extends Point {
  constructor(x, y, color) {
    super(x, y); // 调用父类的constructor(x, y)
    this.color = color;
  }

  toString() {
    return this.color   ' '   super.toString(); // 调用父类的toString()
  }
}

下边代码中,constructor方法和toString主意之中,都出现了super注重字,它在这里处代表父类的构造函数,用来新建父类的this对象。

子类必需在constructor措施中调用super方法,再不新建实例时会报错。那是因为子类未有和谐的this指标,而是继续父类的this指标,然后对其举办加工。举例不调用super艺术,子类就得不到this对象。

class Point { /* ... */ }

class ColorPoint extends Point {
  constructor() {
  }
}

let cp = new ColorPoint(); // ReferenceError

地点代码中,ColorPoint接轨了父类Point,然而它的构造函数未有调用super方式,导致新建实例时报错

这种做法的要害受益之一正是代码重用。

父类,正是被三回九转的类,称为父类,基类,超类。子类是承继了父类的类,称为子类,恐怕派生类。子类从父类承接公共的性质和国有艺术,不可能继续私有化的数据,子类能够接二连三父类,父类还是能一连持续父类。多个子类能够同临时候继续四个父类,同理能够利用五个父类的公家性质和公共艺术,如若父类中冒出同等的性质和艺术的话,使用_mro_来查阅优先承接权,传承中父类尽量不要用重新的性质和措施。

constructor方法

constructor方法是类的私下认可方法,通过new一声令下生成对象实例时,自动调用该情势。一个类必需有constructor方法,假设没有显式定义,二个空的constructor措施会被私下认可增添。

constructor格局默许再次回到实例对象(即this),完全能够钦赐再次回到别的贰个指标。

class Foo {
  constructor() {
    return Object.create(null);
  }
}

new Foo() instanceof Foo
// false

下面代码中,constructor函数重临一个斩新的目的,结果导致实例对象不是Foo类的实例。

 

�������rz� ��

类的prototype属性和__proto__属性

大比比较多浏览器的ES5实现之中,每二个指标都有__proto__属性,指向对应的构造函数的prototype属性。Class作为构造函数的语法糖,同期有prototype属性和__proto__属性,因而同不时候存在两条承接链。

(1)子类的__proto__属性,表示构造函数的三番两次,总是指向父类。

(2)子类prototype属性的__proto__属性,表示方法的持续,总是指向父类的prototype属性。

class A {
}

class B extends A {
}

B.__proto__ === A // true
B.prototype.__proto__ === A.prototype // true

下面代码中,子类B__proto__天性指向父类A,子类Bprototype属性的__proto__质量指向父类Aprototype属性。

诸如此比的结果是因为,类的持续是安份守己下边包车型地铁格局完毕的。

class A {
}

class B {
}

// B的实例继承A的实例
Object.setPrototypeOf(B.prototype, A.prototype);

// B继承A的静态属性
Object.setPrototypeOf(B, A);
C:Python27python.exe D:/weixin/temp/temp.py
你的名字是:xzdylyh

Process finished with exit code 0

后续有几点注意:

name属性

鉴于精神上,ES6的Class只是ES5的构造函数的一层包装,所以函数的大多特征都被Class承袭,包罗name属性。

class Point {}
Point.name // "Point"

name脾气总是回到紧跟在class根本字背后的类名。

输出

2.私部分艺术,不可能透过对象直接访谈。

原生构造函数的承接

原生构造函数是指语言内置的构造函数,通常用来生成数据结构。ECMAScript的原生构造函数大概有上边那么些。

  • Boolean()
  • Number()
  • String()
  • Array()
  • Date()
  • Function()
  • RegExp()
  • Error()
  • Object()

以前,那一个原生构造函数是无法继续的,ES6允许传承原生构造函数定义子类,因为ES6是先新建父类的实例对象this,然后再用子类的构造函数修饰this,使得父类的有着行为举止都能够持续。上面是一个持续Array的例子。

class MyArray extends Array {
  constructor(...args) {
    super(...args);
  }
}

var arr = new MyArray();
arr[0] = 12;
arr.length // 1

arr.length = 0;
arr[0] // undefined

地点代码定义了二个MyArray类,继承了Array构造函数,因而就能够从MyArray生成数组的实例。那象征,ES6足以自定义原生数据结构(举例Array、String等)的子类,那是ES5不可能做到的。

地点那些事例也注明,extends第一字不只能用来承继类,还是能够用来一连原生的构造函数。因而得以在原生数据结构的基本功上,定义本人的数据结构。

被持续的类称为父类,承继的类称为子类,一个父类,能够有多少个子类;

es6学习笔记12--Class【时时app平台注册网站】。1.私部分属性,无法由此对象直接访问,然而能够通过措施来拜谒。

类的实例对象

生成类的实例对象的写法,与ES5截然一致,也是采纳new一声令下。要是忘记加上new,像函数那样调用Class,将会报错。

// 报错
var point = Point(2, 3);

// 正确
var point = new Point(2, 3);

与ES5一致,实例的习性除非显式定义在其本身(即定义在this对象上),不然都是概念在原型上(即定义在class上)。

与ES5一样,类的有着实例分享一个原型对象。

那也意味,能够通超过实际例的__proto__质量为Class加多艺术。

var p1 = new Point(2,3);
var p2 = new Point(3,2);

p1.__proto__.printName = function () { return 'Oops' };

p1.printName() // "Oops"
p2.printName() // "Oops"

var p3 = new Point(4,2);
p3.printName() // "Oops"

上边代码在p1的原型上增添了多个printName方法,由于p1的原型正是p2的原型,因此p2也得以调用这些办法。並且,此后新建的实例p3也得以调用这几个措施。那意味着,使用实例的__proto__质量改写原型,必得一对一严谨,不引入使用,因为那会改变Class的本来定义,影响到全数实例。

#*_*coding:utf-8*_*

class perent_class(object):
    def __init__(self,name):
        self.name = name

    def printName(self):
        print('你的名字是:' self.name)


class child_class(perent_class):
    def __init__(self,name,age):
        super(child_class,self).__init__(name) #初始化类super()函数返回类对象
        self.age = age


if __name__=="__main__":
    child_class('xzdylyh','25').printName()

4.貌似景况下,私有的属性,方法都以不对对外宣撒播的,往往用来做内部的政工,起到平安的左右和效应

Class表达式

与函数同样,Class也得以运用表明式的款式定义。

const MyClass = class Me {
  getClassName() {
    return Me.name;
  }
};

地点代码应用表达式定义了一个类。须要注意的是,这么些类的名字是MyClass而不是MeMe只在Class的内部代码可用,指代当前类。

let inst = new MyClass();
inst.getClassName() // Me
Me.name // ReferenceError: Me is not defined

下面代码表示,Me只在Class内部有定义。

若果Class内部没用到的话,能够回顾Me,约等于足以写成上面包车型大巴样式。

const MyClass = class { /* ... */ };

采用Class表明式,能够写出立时实行的Class。

let person = new class {
  constructor(name) {
    this.name = name;
  }

  sayName() {
    console.log(this.name);
  }
}('张三');

person.sayName(); // "张三"

地点代码中,person是三个立刻试行的Class的实例。

es6学习笔记12--Class【时时app平台注册网站】。Parent Class(父类) 与 Child Class(子类):

后日求学了面向对象的持续意义和一些操作,承接,分为父类和子类,父类的片段公共数据都能够让子类进行利用,而私有化的数目,子类将不能够利用。Class Person()与class Man(Person)那样就是Class Man(Person)是Class Person的子类,父类Class Person中的公共数据,都能够让子类举行应用,等于是将父类的多少赋值给子类,通过内部存款和储蓄器地址实行再三再四,承袭还恐怕有多三番两次,贰个父类能够被七个子类承袭,裁减了代码的重复使用,使代码更加的洗练。

Object.getPrototypeOf()

Object.getPrototypeOf方法能够用来从子类上取得父类。

Object.getPrototypeOf(ColorPoint) === Point
// true

因此,能够选取这几个点子推断,三个类是或不是延续了另一个类。

类继承:

new.target属性

new是从构造函数生成实例的吩咐。ES6为new命令引进了二个new.target质量,(在构造函数中)返回new指令功用于的可怜构造函数。若是构造函数不是透过new指令调用的,new.target会返回undefined,因而这本性格能够用来鲜明构造函数是怎么调用的。

 

后续的主见在于,充份利用已有类的功力,在其基础上来增加来定义新的类。

super关键字

super本条十分重要字,有三种用法,含义分化。

(1)作为函数调用时(即super(...args)),super意味着父类的构造函数。

(2)作为对象调用时(即super.propsuper.method()),super意味着父类。注意,此时super即能够援引父类实例的特性和格局,也足以援引父类的静态方法。

 

Class的继承

本文由时时app平台注册网站发布于编程知识,转载请注明出处:es6学习笔记12--Class【时时app平台注册网站】

关键词: