十六、ES6中的面向对象
类的定义
语法:class 类名 {}
//定义类,关键词class
class Furist{
}
//类的使用(类的实例化),关键词new
let f=new Furist();//f叫做类的引用
类中的结构
类中可以定义方法(函数),也可以定义属性。
类的方法
类中的方法包含3类,构造方法、成员方法、静态方法
构造方法
关键词constructor
语法:constructor(){}
class Fruit{
constructor(){//类的构造方法
}
}
成员方法
即一般普通的方法,
语法:方法名(参数){ }
class Fruit{
aa(params) {}
bb(){}
}
静态方法
语法:static 方法名(参数){}
class Fruit{
static aa(params) {}
static bb(){}
}
类方法的使用
class Friut{
constructor(str){
console.log("我是构造方法!"+str);
}
aa(){
console.log("我是成员方法!");
}
static bb(){
console.log("我是静态方法!");
}
}
//如果需要使用类,必须要先创建类的实例。
let f=new Friut();//创建了一个Friut类的实例
//构造方法,在创建类的实例的时候被调用。
let f1=new Friut("我是憨憨");
//上面new的变量名,专业术语叫 类的引用。
//成员方法只能使用引用来调用
f.aa();
//静态方法只能使用类名来调用
Friut.bb();
Friut.aa();
类的属性
类中的属性的分类 2类,成员属性,静态属性。
成员属性
语法:属性名即可,可以在成员方法/构造方法中使用 this.属性名
注:如果在成员方法中定义的成员属性,需要调用成员方法才可以赋值。如果是静态方法中定义的属性,也需要调用静态方法才可以赋值。
静态属性
语法:在静态方法中使用 this.属性名 ,也可以在类中使用关键词 static 属性名
class User{
interest="haha";
static username="rypy";
constructor(){
this.username="rypy1";
}
getPwd(){
this.pwd="123456";
}
static getSex(){
this.sex="男";
}
}
console.log(User.username);
User.getSex();
console.log(User.sex);
类的继承
类的继承 关键词 extends,语法:子类 extends 父类
**注:**ES6中类的继承,子类是完全继承父类的全部。
class Fruirt{
sf=true;
static wss="ABCDEFG";
constructor(sf){
//this.sf=sf;
}
eating(){
console.log("我可以吃!");
}
static getPi(){
console.log("我有皮");
}
}
class Apple extends Fruirt{
}
let ap=new Apple(false);
console.log(Apple.wss);
console.log(ap.sf);
ap.eating()
Apple.getPi()
类的多态
成员方法/静态方法
成员属性/静态属性可以直接实现子类的多态,但是,如果构造方法需要实现多态,必须在子类中调用父类的构造方法。
子类中调用父类的构造方法,采用 super()。
class Fruirt{
sf=true;
static wss="ABCDEFG";
constructor(sf){
this.sf=sf;
}
eating(){
console.log("我可以吃!");
}
static getPi(){
console.log("我有皮");
}
}
class Apple extends Fruirt{
sf=false;
constructor(){
super("我是子类的父类");
this.hh="我有核";
}
eating(){
console.log("我还很绿,不能吃!");
}
}
let f=new Fruirt();
let ap=new Apple();
console.log(ap.sf);
console.log(ap.hh);
ap.eating();
// let f=new Fruirt();
// console.log(f.sf);//undefined
console.log(f.sf);//undefined
使用new创建的实例,实例与实例之间互补干扰,各自有各自的作用域。
静态方法和静态属性
静态属性在用子类的类名重新赋值的时候,不会影响父类,但如果使用父类的类名给静态属性进行赋值,则会影响子类。
//情况一
// Apple.wss="我是重新赋值的内容";
// console.log(Fruirt.wss);
//情况二
Fruirt.wss="我是重新2";
console.log(Apple.wss);
super和this关键词
super关键词
用在子类中,
如果在子类中需要调用父类的成员方法,可以采用 super.方法名 来使用。注:只能使用在子类成员方法。
如果在子类中需要使用父类的静态方法,可以采用 super.方法名 来使用,但只能在子类的静态方法中使用。
如果在子类的成员方法中需要使用父类的静态方法,可以使用 类名.方法名来调用。
class Fruirt{
sf=true;
static wss="ABCDEFG";
constructor(sf){
this.sf=sf;
}
eating(){
console.log("我可以吃!");
}
static getPi(){
console.log("我有皮");
}
}
class Apple extends Fruirt{
sf=false;
constructor(){
super("我是子类的父类");
this.hh="我有核";
}
eating(){
super.eating();
Fruirt.getPi();
console.log("我还很绿,不能吃!");
}
static getPii(){
super.getPi();
console.log("我的皮是红色的");
}
}
let ap=new Apple();
ap.eating();
// Apple.getPii();
this关键词
指向当前类,
this关键词可以让子类之间的方法进行互相调用。
规则,成员方法只能成员方法之间互调。静态方法只能静态方法之间互调。
规则,this 也可以在成员方法中调用成员属性,在静态方法中调用静态属性。
class Fruirt{
sf=true;
static wss="ABCDEFG";
constructor(sf){
this.sf=sf;
}
eating(){
console.log("我可以吃!");
}
static getPi(){
console.log("我有皮");
}
}
class Apple extends Fruirt{
sf=false;
constructor(){
super("我是子类的父类");
this.hh="我有核";
}
eating(){
this.eating2();
console.log("我还很绿,不能吃!"+this.sf);
}
eating2(){
console.log("我还很红了,可以吃!");
}
}
let ap=new Apple();
ap.eating();