Typescript类

最新推荐文章于 2024-02-29 22:33:24 发布

云中的星星

最新推荐文章于 2024-02-29 22:33:24 发布

阅读量594

点赞数

文章标签： javascript 前端开发语言

本文链接：https://blog.csdn.net/m0_61902288/article/details/126771010

版权

1 类的基本使用

定义：TypeScript 是面向对象的JavaScript。
类描述了所创建的对象共同的属性和方法。
TypeScript支持面向对象的所有特性，比如类、接口等。

class class_name{

//类作用域

}

定义类的关键为cass,后而紧疑关名,类可以包含以下几个模块(类的数师成员) :
●字段：字段是类里面声明的变量。字段表示对象的有关数据。
●构造函数类实例化时调用。可以为类的对象分配内存。
●方法方法为对象要执行的操作。

export default {}

//类的基本使用
class Person{
    //字段(属性)
    name:string
    age:number
    // 构造函数
    constructor(name:string,age:number){
        this.name=name
        this.age =age
    }
    //函数（方法）
    sayHello():void{
        console.log(`我的男神是${this.name},他${this.age}了`);
        
    }
}

// 实例化类
let p = new Person("国超",30)
p.sayHello()

2 类的继承

TypeScript支持继承类，即我们可以在创建类的时候继承一个已存在的

765类，这个已存在的类称为父类，继承它的类称为子类。
                类继承使用关键字extends,子类除了不能继承父类的私有成员(方法和属性)和构造函数，其他的都可以继承。
                TypeScript一次只能继承一个类，不支持继承多个类，但TypeScript支持多重继承(A继承B, B继承C)。
                语法格式如下: class child_ class_ name extends parent_ class_ name

export default{}

class Person{
    //字段(属性)
    name:string
    age:number
    // 构造函数
    constructor(name:string,age:number){
        this.name=name
        this.age =age
    }
    //函数（方法）
    sayHello():void{
        console.log(`我的男神是${this.name},他${this.age}了`);
        
    }
}

/* 
// 实例化类
let p = new Person("国超",30)
p.sayHello()
 */


// 子承父类
class Student extends Person{
    stap:string
    constructor(name:string,age:number,stap:string){
        super(name,age)
        this.stap=stap;
    }
    sayHello():void{
        //调用父类中的办法
        super.sayHello();
        console.log(`我是${this.name},我${this.age}了,我的成绩是${this.stap}`);
        
    }
}
let s = new Student("国超",30,"A")
s.sayHello()

3 static与instanceof

static关键字用于定义类的数据成员(属性和方法)为静态的,静态成员可以直接通过类名调用。

instanceof 运算符用于判断对象是否是指定的类型，如果是返回true, 否则返回false。

export default {}

//static 关键字用于定义类的数据成员（属性和方法）为静态，静态成员可以直接通过类名调用
class StaticTest{
    static salary:number
    static say():void{
        console.log(`我想要${StaticTest.salary}k`);
    }
}
StaticTest.salary=100;
StaticTest.say()

// instanceof运算符
// instanceof运算符用于判断对象是否是指定的类型。如果是返回true，否则返回falsa
class Person{}
let p = new Person()
let isPerson = p instanceof Person;
console.log("p是Person实例化处理的吗？",isPerson);//true

// 继承父类的结果，所以返回的是true
class Student extends Person{}
 let s = new Student()
 let isStudent = s instanceof Person;
 console.log("s是实例化出来的吗",isPerson);//true

4 类中的修饰符

●public(默认): 公有，可以在任何地方被访问
●protected: 受保护，可以被其自身以及其子类访问
●private: 私有，只能被其定义所在的类访问。
●readonly: 可以使用readonly 关键字将属性设置为只读的。只读属性必须在声明时或构造函数里被初始化。

export default{}
class Person{
    public name:string;
    protected age:number;
    private sex:string;
    constructor(name:string,age:number,sex:string){
        this.name = name;
        this.age = age;
        this.sex = sex
    }
    say():void{
        console.log(`我是${this.name},性别为${this.sex},今年${this.age}岁`);
    }
}
class Student extends Person{
    score:string
    constructor(name:string,age:number,sex:string,score:string){
        super(name,age,sex)
        this.score=score
    }
    say():void{
        console.log(this.name);
        console.log(this.age);
        // console.log(this.sex);
        console.log(this.score);
    }
}
let s = new Student("往",18,"女","A")
s.say()

class Print{
    readonly str1:string="我是声明时3赋值的"
    readonly str2:string
    readonly str3:string
    readonly str4:string
    readonly str5:string
    constructor(str2:string,str3:string,str4:string,str5:string,){
        this.str2=str2
        this.str3=str3
        this.str4=str4
        this.str5=str5
    }
}
let pc=new Print("我的","我想要去的地方","ftgyh","jk")

5 getter与setter

存取器
通过getters/setters来截取对对象成员的访问
注意点:
如果存在get,但没有set,则该属性自动是只读的
如果没有指定setter参数的类型，它将从getter的返回类型中推断出来
访问器和设置器必须有相同的成员可见性

export default{}
class GetNameClass{
    private _fullName:string="嘉伦"
    //获取值
    get fullName():string{
        console.log("get方法");
        return this._fullName        
    }
    //添加
    set fullName(newName:string){
        console.log("set方法");
        this._fullName=newName
    }
}

let starname = new GetNameClass();
console.log(starname);
starname.fullName = "国超"
// console.log(starname);
console.log(starname.fullName );

6 抽象类

●定义
抽象类做为其它派生类的基类使用。它们一般不会直接被实例化
抽象类是专门用于定义哪些不希望被外界直接创建的类的
抽象类和接口-样用于约束子类
●抽象类和接口区别
抽象方法必须包含abstract 关键字并且可以包含访问修饰符
接口中只能定义约束，不能定义具体实现。而抽象类中既可以定义约束又可以定义具体实现

export default {}
abstract class Person {
    abstract name: string
    // abstract age:number
    abstract show(): string
    sayHo(): void {
        console.log("Hooll");
    }
}
class Serden extends Person {
    name: string = "张"
    age: number = 18
    show() {
        return "yi"
    }
}
let p0 = new Serden()
let res = p0.show()
console.log(res);

7 类的初始化顺序

●基类的字段被初始化
●基类构造函数运行
●子类的字段被初始化
●子类构造函数运行

export default{}

class Person{
    //字段(属性)
    name:string
    age:number
    // 构造函数
    constructor(name:string,age:number){
        this.name=name
        this.age =age
    }
    //函数（方法）
    sayHello():void{
        console.log(`我的男神是${this.name},他${this.age}了`);
        
    }
}

/* 
// 实例化类
let p = new Person("国超",30)
p.sayHello()
 */


// 子承父类
class Student extends Person{
    stap:string
    constructor(name:string,age:number,stap:string){
        super(name,age)
        this.stap=stap;
    }
    sayHello():void{
        //调用父类中的办法
        super.sayHello();
        console.log(`我是${this.name},我${this.age}了,我的成绩是${this.stap}`);
        
    }
}
let s = new Student("国超",30,"A")
s.sayHello()