TypeScript类与继承和修饰符就是这样简单

本文已参与好文召集令活动，点击查看：后端、大前端双赛道投稿，2万元奖池等你挑战！

1.我理解的类

类能够理解成为一个模板，经过这个模板能够实例化某一个具体对象
好比说：咱们定义一个动物类，
经过这个动物模板能够实例化成为猫或者其余具体的动物
复制代码

2.类的基本使用

咱们须要建立一个动物类；
这个动物有姓名、【默认值小可爱，字符串类型】
年龄、【默认值 20，数字类型】
性别、【字符串类型】
体重、【数字类型】
爱好【爱好无关紧要，若是有必须是一个数组类型的】
这个动物类还有一个say的实例方法
下面咱们就开始实现
复制代码

class Animails {
    name: string
    age: number
    gender: string
    weight: string
    likes?: Array<any>
    //爱好这个属性无关紧要，若是有必须是数组类型
    // 定义构造函数：为了未来实例化对象的时候，

    // 构造器直接对属性进行初始化
    // 须要给名称默认值小可爱、年龄默认值age=20
    constructor(
        name: string = '小可爱',
        age: number = 20,
        gender: string,
        weight: string,
        likes?: Array<any>
    ) {
        // 初始化属性中的数据
        this.name = name
        this.age = age
        this.gender = gender
        this.weight=weight
    }
    // 定义实例方法
    say() {
        console.log(
            `你们好我是${this.name},
            今年${this.age}岁了,
            性别:${this.gender},
            体重:${this.weight},
        `);
    }
}
// 实例化对象
let pig = new Animails('猪猪侠', 10, '男', '30kg');
pig.say();//调用实例方法
复制代码

3.实例化类的注意点

当类中的属性都有默认值时，
实例化对象的时候，
能够不用进行进行初始化。
类中的属性若是没有默认值，不是可选属性。必须一一赋值(初始化)
就是说:
咱们必须对构造器中的属性进行一一赋值
除非构造器中有默认值
复制代码

class Animails {
    name: string
    age: number
    constructor(
        name: string = '小可爱',
        age: number = 20,
    ) {
        // 初始化属性中的数据
        this.name = name
        this.age = age
    }
    // 定义实例方法
    say() {
        console.log( `你们好我是${this.name}, 今年${this.age}岁了, `);
    }
}
// 实例化对象
let pig = new Animails();
pig.say();//调用实例方法
复制代码

4.类与类之间的继承

A类继承了B类，那么A类叫作子类；B类叫作基类
子类--->又叫派生类
基类--->又叫父类或者超类
复制代码

下面这个例子咱们将子类MySon将会去继承Father父类。
子类有属于本身的方法sonsay；
子类能够去调用父类的方法super.say('子类');
同时咱们在子类中将会去重写父类的方法
复制代码

// 咱们定义了一个超类【父类】
class Father {
    // 定义属性
    name: string
    age: number
    // 定义构造函数
    constructor(name: string, age: number) {
        // 初始化属性中的数据
        this.name = name
        this.age = age
    }
    // 定义实例方法
    say(str:string) {
        console.log( `你们好我是${this.name}, 今年${this.age}岁了，${str}呼喊的我 `);
    }
}

// 子类去继承了父类
class MySon extends Father {
    // constructor中的参数必需要知足父类。
    // 除非父类有默认参数或者父类中的属性不是必须属性。
    constructor(name: string, age: number) {
        // super调用父类中的构造函数
        super(name,age)
    }
    // 子类中本身的实例方法
    sonsay() {
        console.log('我是子类哈哈');
        //调用父类中的实例方法
        super.say('子类');
    }

    // 重写父类的方法
    say(name:string) {
        console.log(`我重写了父类的方法我是${name}`)
    }
}
// 进行实例化
let xiaoming = new MySon('小明', 19);
// 进行方法调用 
xiaoming.sonsay();
xiaoming.say('小明');
复制代码

5.修饰符的理解

修饰符:主要用于描述类中的成员(属性、方法、构造函数，)的可访问行
当一个类的成员变量没有修饰的时候,
默认的就是 public 进行修饰。
外界是能够进行访问的。任何位置均可以访问类中的成员

private 属性【只可以】在父类的内部直接进行访问;
class Person{
    age:10
    // private 属性只可以 在类的内部 进行访问;
    private name = "张三" 
    say() {
        console.log("个人名字是"+this.name)
    }
}
复制代码

6.private的理解

若是父类定义的私有属性或者方法的时候,
那么继承的子类是不能够访问父类中的私有属性和私有方法
在实例化的时候也是不能够访问私有属性和私有方法

子类继承父类后 
访问父类属性经过this.属性名
调用父类的方法 this.方法名

下面咱们看一下：
子类是否能够访问父类中的私有属性？
实例化后是否能够访问父类中的私有属性？
复制代码

class Person {
    age: 10;
    // private 属性只可以在类的内部进行访问;
    private name = "张三";
    say() {
      //内部访问是ok的哈
      console.log("个人名字是" + this.name);
    }
}
class Children extends Person {
    sayage() {
        console.log('访问父类属性年龄',this.age)
    }
    // 下面这种访问是非法的会报错 
    sayname() {
        console.log('访问父类属性姓名',this.name)
    }
}
var xm = new Children();
xm.say();//个人名字是张三
// 报错，由于name是父类私有的，
// 实例化的时候不可以进行访问 
console.log( xm.name )
复制代码

7.protected 的理解

protected修饰的属性和方法是受保护的,
只可以在父类和其子类中访问。
实例化后是不可以访问protected所修饰的属性和方法
复制代码

class Person {
    protected age:string
    constructor(age:string) {
      this.age=age
    }
    say() {
        console.log("个人年龄是" + this.age);
    }
}

// 继承父类
class Children extends Person {
    callPar() {
      super.say(); //super 能够调用父类中的属性方法
    }
    hello() {
      console.log("我今年" + this.age);
    }
}

var xm = new Children('10');
xm.hello(); //我今年10
<!-- 提示 属性“age”受保护，只能在类“Person”及其子类中访问 -->
console.log(xm.age)
复制代码