Typescript（八）类的概念和使用

类是一个功能的集合。

一：类的定义及基本使用

1：定义一个类

class lady{
    content = "你好啊，我是camellia";
    say(){
        console.log(this.content);
    }
}
 

2：调用类

// 类的使用
let camellia = new lady();
camellia.say();
// 输出：你好啊，我是camellia
 

二：类的继承

1：定义一个girl类继承lady类

class girl extends lady{
    saylove(){
        console.log("我是girl~");
    }
}

2：子类调用父类方法

// 类的继承
let girls = new girl();
// 子类对父类同名方法重写
girls.say();
girls.saylove();
// 输出：你好啊，我是camellia
//       我是girl~

3：子类重写父类同名方法

class girl extends lady{
 
    say(){
        console.log('我是子类中的say方法！');
    }
    saylove(){
        console.log("我是girl~");
    }
}

调用：

// 类的继承
let girls = new girl();
// 子类对父类同名方法重写
girls.say();
girls.saylove();
// 输出：我是子类中的say方法！
//       我是girl~

4：子类调用父类中的同名方法，使用super关键字

class girl extends lady{
 
    say(){
        // console.log('我是子类中的say方法！');
        return super.say();
    }
    saylove(){
        console.log("我是girl~");
    }
}
// 类的继承
let girls = new girl();
// 子类对父类同名方法重写
girls.say();
girls.saylove();
// 输出：你好啊，我是camellia
//       我是girl~
 

三：类的访问类型

基本上就是面向对象的三大类型：public protected private

Public 定义的方法和属性，类内外都可调用

Private定义的方法和属性，只有类内可使用

Protected定义的方法和属性，只有类内和其子类可调用

class person{
    public name:string;
    protected age:number;
    private weight:number;
}

这个是面向对象的基础知识，这里不做过多的解释。

四：类的构造函数

构造函数关键字：constructor

1：定义一个类，带有构造函数

class person{
    public name:string;
    protected age:number;
    private weight:number;
    constructor(name:string,age:number,weight:number){
        this.name = name;
        this.age = age;
        this.weight = weight;
        console.log(name);
        console.log(age);
        console.log(weight);
    }
}
 
const han = new person('camellia',30,180);
// 输出：
// camellia
// 30
// 180

2：构造函数继承

class teacher extends person{
    public sex:string;
    constructor(sex:string){
        // 子类构造函数需要使用super关键字来调用父类的构造函数，否则报错
        super(han.name,han.age,han.weight);
        this.sex = sex;
        console.log(this.name);
        console.log(this.age);
        console.log(this.weight);
        console.log(this.sex);
    }
}
const zc = new teacher('男');
// 输出：
// camellia
// 30
// 180
// 男

五：类的getter，setter，static

1：getter和setter

Typescript是微软写的，C#也是微软写的，所以C#和typescript中都有get，set这两个玩意。

get和set是属性，而不是一个方法。

Get其实就是对我们的属性进行包装保护在进行输出。

Set是对外部访问类的属性做一个类似中间件的处理，确保我们的属性合法。

class ren
{
    public _age:number;
    constructor(age:number)
    {
        this._age = age;
    }
    set age(age:number){
      this._age = age;
    }
    get age(){
      return this._age - 10;
    }
}
 
const aa = new ren(35);
aa.age=35
console.log(aa.age)
 

2：static静态方法

类需要实例化一个对象存放在内存中，我们需要调用类中方法的时候，直接调用就好。

类中的静态方法是在程序加载的时候就加载到内存中，程序关闭后销毁，因此，静态方法在想调用的时候直接使用类名调用就好。

class car{
    static pao(){
        console.log(
            "挂挡，加油，走你！"
        )
    }
}
// 调用
car.pao();
// 输出：
// 挂挡，加油，走你！

六：类的只读属性

class baoma{
   // 声明已读属性
    public readonly siqu:string = "x-driver"
    static pao(){
        console.log(
            "挂挡，加油，走你！"
        )
    }
}
 
const sanxi = new baoma();
console.log(sanxi.siqu);  
// 输出 x-driver

当我们修改sanxi.siqu属性时，如下图所示：

七：抽象类

抽象类关键字abstract。

抽象类的基础知识大概参照《C#中的抽象类（abstract）》

Typescript中的抽象类例子如下：

abstract class GT{
    abstract siqu()  //因为没有具体的方法，所以我们这里不写括号
}
 
class bmw extends GT
{
    siqu(){
        console.log("x-driver");
    }
}
 
class benz extends GT
{
    siqu(){
        console.log("4matic");
    }
}
 
class aodi extends GT
{
    siqu(){
        console.log("quattro");
    }
}

有好的建议，请在下方输入你的评论。

欢迎访问个人博客
https://guanchao.site