ts 中 class 类介绍

使用class 关键字定义一个类

对象中主要包含两个部分 ：1.属性  2.方法

class Person {
    //定义实例属性
    name: string = '小明';

    //使用static 开头的属性是静态（类属性），可以直接通过类去调用
    static age: number = 18;

    //readonly 开头的属性表示一个只读的属性无法修改
    readonly sex: string = '男';

    //定义方法
    //如果方法以 static 开头就是类方法，可以通过类直接调用
    getData() {
        console.log('hello');
    }

}

const per = new Person();

console.log(per.name);
console.log(Person.age);
console.log(per.sex);
//调用方法
per.getData()

constructor 构造函数

 

class anmimo {
    name: string;
    age: number;

    constructor(name: string, age: number) {
        //在实例方法中，this就表示当前的实例
        //在构造函数中当前对象就是当前新建的那个对象
        //可以通过this向新建的对象中添加属性
        this.name = name;
        this.age = age;
    }

    bark() {
        // 在方法中可以通过this来表示当前调用方法的对象
        console.log(this.name);
    }
}

继承 extends

// 继承 extends
// extends anmimo
// 使用继承后，子类将会拥有父类所有方法和属性
// 通过继承可以将多个类中共有的代码写在一个父类中
// 这样只需要写一次即可让所有的子类都同时拥有父类中的属性和方法
// 如果希望在子类中添加一些父类中没有的属性或者方法直接加就行
// 如果在子类中添加了和父类相同的方法，则子类方法会覆盖掉父类的方法
class Dog extends anmimo {
    run() {
        console.log(this.name);
        //在类方法中 super就表示当前类的父类
        super.bark()
    };
    constructor(name: string, age: number) {
        //如果在子类中写了构造函数，在子类够赞函数中必须对父类的构造函数进行调用
        super(name, age);  //调用父类的构造函数
    }
}

const dog = new Dog('旺财', 1)
dog.run()

 

// 以abstract开头的类是抽象类

// 抽象类就是专门用来被继承的类

// 抽象类中可以添加抽象方法

 

// 以abstract开头的类是抽象类
// 抽象类就是专门用来被继承的类
// 抽象类中可以添加抽象方法
abstract class jihe {
    name: string;
    constructor(name: string) {
        this.name = name
    }

    //定义一个抽象方法
    //抽象方法使用abstract开头，没有方法体
    //抽象方法只能定义在抽象类中，子类必须对抽象方法进行重写
    abstract say(): void;
}


//接口可以在定义类的时候去限制类的结构
//接口中所有的属性都不能有实际的值
//接口只定义对象的结构，而不考虑实际值
//在接口中所有的方法都是抽象方法
interface myInter {
    name: string;
    say(): void;
}

// public 修饰的属性可以在任意位置访问（修改）默认值

// private 私有属性，只能在类内部进行访问（修改）

 

// public 修饰的属性可以在任意位置访问（修改）默认值
// private 私有属性，只能在类内部进行访问（修改）

class sons {
    public _name: string;
    public _age: number;

    //私有属性
    private name1: string;
    private age1: number;
    constructor(name: string, _age: number) {

        this._name = name
        this._age = _age
        this.name1 = name
        this.age1 = _age
    }

    //get方法获取值
    get name() {
        return this._name
    };

    //set方法修改值
    set name(value: string) {
        this._name = value
    }

}

//泛型

 

//泛型
function fn<T>(a: T): T {
    return a;
}

//可以直接调用具有泛型的函数
let res = fn(10);//不指定泛型，TS可以自动对类型进行推断
let res1 = fn<string>('hello')//指定泛型

//泛型可以同时指定多个
function fn2<T,K>(a: T,b:K){
    return a
}
fn2<number,string>(123,"aaa")


interface Inter{
    length:number
}
//T extends Inter 表示泛型T必须是Inter实现类（子类）
function fn3<T extends Inter>(a:T):number{
    return a.length
}