es六学习笔记1贰,继承的意思和操作

类继承:

持续的意思和操作

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)差别相当的大,很不难让新学习那门语言的程序员感到疑忌。

ES陆提供了更类似古板语言的写法,引入了Class(类)那几个概念,作为目的的沙盘。通过class珍视字,能够定义类。基本上,ES陆的class能够作为只是叁个语法糖,它的多边效益,ES5都足以达成,新的class写法只是让对象原型的写法特别显然、更像面向对象编制程序的语法而已。上边包车型客车代码用ES陆的“类”改写,正是下边这样。

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

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

上面代码定义了三个“类”,能够见见当中有2个constructor方法,那就是构造方法,而this要害字则代表实例对象。也等于说,ES五的构造函数Point,对应ES6的Point类的构造方法。

Point类除了构造方法,还定义了1个toString艺术。注意,定义“类”的主意的时候,前面不须要添加function以此主要字,直接把函数定义放进去了就足以了。此外,方法之间不须求逗号分隔,加了会报错。

构造函数的prototype性情,在ES陆的“类”上边继续存在。事实上,类的保有办法都定义在类的prototype本性上边

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

  toString(){
    // ...
  }

  toValue(){
    // ...
  }
}

// 等同于

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

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

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

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

类的中间装有定义的诀窍,都以举不胜举的(non-enumerable)。

 

继承是面向对象的2个极度首要的特征,通过3个项目对另2个项指标存在延续,能够使代码重复使用,同时也增加了代码的功力上的扩大,继承的语法使用Class,在Python中,壹切皆对象,都能够一贯大概直接的去继续(object)对象

constructor方法

constructor主意是类的默许方法,通过new一声令下生成对象实例时,自动调用该措施。3个类必须有constructor方法,一旦未有显式定义,3个空的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的原有定义,影响到具备实例。

被一连的类称为父类,继承的类称为子类,三个父类,能够有八个子类;

子类是继续父类的,可是子类也得以另行定义父类的留存的办法,那叫做重写,重写展现了子类的独立性还有可变性,也称为(多态),方法重写有多少个条件壹:继承的涉嫌。2:父类存在的秘籍。三:子类重新定义

name属性

是因为精神上,ES六的Class只是ES5的构造函数的壹层包装,所以函数的广大表征都被Class继承,包罗name属性。

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

name质量总是回到紧跟在class主要字背后的类名。

子类,一旦一而再父类,就有着了父类的习性与办法,依据须求可以拓展增加和删除改。

本身对一连的接头正是,父类中的方法和质量有众多,可是子类只关心要求的章程和总体性,父类中存放的貌似都以一些公共的始末,进步代码的复用性,子类能够随时继承父类中的公共艺术和情节。

Class表达式

与函数壹样,Class也足以行使表明式的格局定义。

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

上面代码应用表明式定义了3个类。须要留意的是,那些类的名字是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的实例。

那种做法的最主要利益之1便是代码重用。

三番五次有几点注意:

不存在变量升高

Class不设有变量提高(hoist),那点与ES5全然分裂。

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

上边代码中,Foo类使用在前,定义在后,那样会报错,因为ES陆不会把变量申明升高到代码尾部。那种规定的原故与下文要提到的接轨有关,必须保险子类在父类之后定义。

 

1.私部分属性,不能因而对象直接待上访问,但是足以通过措施来拜会。

Class的继承

以身作则代码一:

二.私有的艺术,不能够经过对象直接待上访问。

中央用法

Class之间能够经过extends关键字福寿双全三番五次,那比ES伍的通过改动原型链完毕持续,要明晰和有益广大。

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()

三.私有的属性,方法不会被子类继承,也不可能被访问。

类的prototype属性和__proto__属性

超过1二分之伍浏览器的ES五兑现之中,每多少个指标都有__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

因此,能够运用那么些措施判断,1个类是或不是一而再了另叁个类。

C:\Python27\python.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()

以前,这个原生构造函数是不可能持续的,ES陆允许继续原生构造函数定义子类,因为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

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

上边这些事例也认证,extends根本字不仅能够用来继承类,还足以用来延续原生的构造函数。因而得以在原生数据结构的功底上,定义本身的数据结构。

当子类与父类下方法同样时,子类会覆盖父类的格局内容;其实那就是壹种重写,也是1种多态。

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驷不如舌字,注解该措施是3个静态方法,能够直接在Foo类上调用(Foo.classMethod()),而不是在Foo澳门网上正规赌场网址,类的实例上调用。如若在实例上调用静态方法,会抛出二个荒唐,表示不存在该措施。

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

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

class Bar extends Foo {
}

Bar.classMethod(); // 'hello'

地方代码中,父类Foo有多个静态方法,子类Bar可以调用那个点子。

静态方法也是足以从super对象上调用的。

new.target属性

new是从构造函数生成实例的吩咐。ES六为new命令引入了1个new.target品质,(在构造函数中)再次来到new一声令下效用于的不行构造函数。假如构造函数不是通过new指令调用的,new.target会返回undefined,由此那几个天性能够用来规定构造函数是怎么调用的。

 

Post Author: admin

发表评论

电子邮件地址不会被公开。 必填项已用*标注