接轨的意思和操作,es6就学笔记12

类继承:

三番五次的含义和操作

Class基本语法

继续的主见在于,充份利用已有类的效果,在其底工上来增添来定义新的类。

后日学习了面向对象的接轨意义和有个别操作,世襲,分为父类和子类,父类的有的公共数据都足以让子类举行利用,而私有化的数据,子类将无法选择。Class
Person()与class Man(Person)这样正是Class Man(Person)是Class
Person的子类,父类Class
Person中的公共数据,都足以让子类举行应用,等于是将父类的数码赋值给子类,通过内部存款和储蓄器地址举办再而三,世襲还大概有多连续,一个父类能够被多个子类世袭,降低了代码的重复使用,使代码越来越简洁明了。

概述

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卡塔 尔(阿拉伯语:قطر‎。

 

接轨是面向对象的叁个要命关键的性状,通过二个种类对另二个连串的世袭,能够使代码重复利用,同不时间也抓好了代码的功用上的增加,世袭的语法使用Class,在Python中,一切皆对象,都足以直接也许直接的去继续(object卡塔 尔(阿拉伯语:قطر‎对象

constructor方法

constructor方法是类的暗中同意方法,通过new命令生成对象实例时,自动调用该方法。二个类必得有constructor方法,假如未有显式定义,贰个空的constructor艺术会被暗中同意增多。

constructor方法私下认可重回实例对象(即this卡塔 尔(阿拉伯语:قطر‎,完全能够内定再次来到此外二个对象。

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

new Foo() instanceof Foo
// false

下面代码中,constructor函数再次来到三个簇新的对象,结果形成实例对象不是Foo类的实例。

Parent Class(父类)
与 Child Class(子类):

父类,就是被三番一遍的类,称为父类,基类,超类。子类是继续了父类的类,称为子类,或许派生类。子类从父类继承公共的属性和国有措施,不能够世袭私有化的数据,子类能够持续父类,父类还足以继续接二连三父类。多少个子类能够同偶尔间继续八个父类,同理能够运用四个父类的公共性质和集体艺术,假如父类中冒出相近的品质和章程的话,使用_mro_来查看优先世襲权,世袭中父类尽量不要用重新的性质和章程。

类的实例对象

生成类的实例对象的写法,与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的庐山真面目目定义,影响到独具实例。

被一连的类称为父类,世袭的类称为子类,一个父类,能够有四个子类;

子类是世襲父类的,可是子类也得以再一次定义父类的存在的秘诀,那称为重写,重写体现了子类的独立性还会有可变性,也称得上(多态卡塔尔国,方法重写有五个规格1:世襲的涉及。2:父类存在的不二秘诀。3:子类重新定义

name属性

鉴于精气神儿上,ES6的Class只是ES5的构造函数的意气风发层包装,所以函数的多多特色都被Class世袭,包涵name属性。

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

name天性总是回到紧跟在class非常重要字背后的类名。

子类,意气风发旦接二连三父类,就具有了父类的个性与措施,依照须要能够张开增加和删除改。

自家对继续的知情正是,父类中的方法和质量有多数,然而子类只关切须求的方法和性质,父类中寄放的相近都以局地集体的剧情,升高代码的复用性,子类能够每一天世袭父类中的公共艺术和剧情。

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的实例。

这种做法的主要性收益之生龙活虎正是代码重用。

持续有几点注意:

不设有变量提高

Class子虚乌有变量进步(hoist卡塔 尔(阿拉伯语:قطر‎,那或多或少与ES5截然两样。

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

地点代码中,Foo类应用在前,定义在后,那样会报错,因为ES6不会把变量证明提高到代码尾部。这种规定的来由与下文要涉及的接续有关,必得保险子类在父类之后定义。

 

1.私部分属性,无法经过对象间接访问,可是足以透过措施来拜候。

Class的继承

演示代码1:

2.私某个艺术,不可能由此对象直接待上访谈。

基本用法

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艺术,招致新建实例时报错

#*_*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()

3.私局地属性,方法不会被子类世袭,也无法被访谈。

类的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);

输出

4.貌似景色下,私有的性质,方法都以不对外宣布的,往往用来做内部的业务,起到平安的左右和职能

Object.getPrototypeOf()

Object.getPrototypeOf主意能够用来从子类上赢得父类。

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

因此,可以使用那个方法判别,一个类是还是不是一而再了另二个类。

C:Python27python.exe D:/weixin/temp/temp.py
你的名字是:xzdylyh

Process finished with exit code 0

�������rz�+��

super关键字

super这一个至关心爱护要字,有三种用法,含义不一样。

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

(2)作为对象调用时(即super.propsuper.method()),super表示父类。注意,这时super即能够引用父类实例的习性和方法,也得以引用父类的静态方法。

 

 

原生构造函数的继续

原生构造函数是指语言内置的构造函数,经常用来生成数据结构。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关键字不仅可以够用来世袭类,还足以用来持续原生的构造函数。因而能够在原生数据结构的根基上,定义本人的数据结构。

当子类与父类下方法意气风发致时,子类会覆盖父类的措施内容;其实那就是生龙活虎种重写,也是少年老成种多态。

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指标上调用的。

new.target属性

new是从构造函数生成实例的吩咐。ES6为new指令引进了多个new.target天性,(在构造函数中卡塔 尔(英语:State of Qatar)重临new命令作用于的不得了构造函数。假使构造函数不是经过new命令调用的,new.target会返回undefined,由此那特个性能够用来规定构造函数是怎么调用的。

 

发表评论