继承的意义和操作澳门太阳娱乐官方网站,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卡塔 尔(英语:State of Qatar)。

 

三回九转是面向对象的四个老大关键的特色,通过三个门类对另三个门类的存在延续,能够使代码重复利用,同时也抓牢了代码的意义上的恢宏,继承的语法使用Class,在Python中,一切皆对象,都足以平昔或许直接的去继续(object卡塔尔对象

constructor方法

constructor艺术是类的私下认可方法,通过new指令生成对象实例时,自动调用该方法。叁个类必需有constructor方法,假诺未有显式定义,一个空的constructor主意会被默许增多。

constructor艺术暗中同意再次回到实例对象(即this卡塔 尔(英语:State of Qatar),完全能够钦命重临此外几个对象。

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()卡塔 尔(英语:State of Qatar),而不是在Foo类的实例上调用。要是在实例上调用静态方法,会抛出叁个八花九裂,表示不设有该方式。

父类的静态方法,能够被子类世襲。

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

class Bar extends Foo {
}

Bar.classMethod(); // 'hello'

上面代码中,父类Foo有三个静态方法,子类Bar能够调用那些方法。

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

new.target属性

new是从构造函数生成实例的命令。ES6为new一声令下引进了贰个new.target属性,(在构造函数中卡塔尔国重返new指令成效于的老大构造函数。假如构造函数不是因而new指令调用的,new.target会返回undefined,由此那天性情能够用来规定构造函数是怎么调用的。