TypeScript的相关知识点

一、类

声明

class 类名{
    
    属性名:type;
​
    constructor(参数:type){
        this.属性名=参数;
        
    }
    
    函数():type{
        
    }
    
}

继承

class 子类 extends 父类{
    属性名:type;
    constructor(参数父:type,参数子:type){
        super((参数父:type)
        this.属性名=参数子;
    }
}

类的修饰符

• public 公有 类本身，子类，类的外层都可以使用 （默认）

• protected 受保护的 再类本身贺子类中可以使用，类外不能使用

• private 私有的 在类本身可以使用，子类和类的外部不能使用

// 声明类
// public 公开的，， 在类内部  子类中  类的外部都能访问
// protected 受保护  在类内部  子类中  可以访问
// private  私有的 在类内部 才能访问
​
​
class Perons1 {
​
    public name:string="请输入内容"
​
    // protected name:string="请输入内容"
​
    // private name:string="请输入内容"
​
    constructor(name:string){
        this.name=name
    }
​
    say(){
​
        // 1、在类的内部去调用
        console.log(`我是${this.name}`);
        
    }
​
}
​
​
class Stu1 extends Perons1{
    constructor(name:string){
        super(name)
    }
    say(){
​
        // /2、子类中访问父类的属性
        console.log(`我的父亲是${this.name}`);//属性“name”为私有属性，只能在类“Perons1”中访问
        
    }
}
​
let p1=new Perons1("张三")
​
//3、外部获取name属性
console.log(p1.name);
// 属性“name”受保护，只能在类“Perons1”及其子类中访问
// 属性“name”为私有属性，只能在类“Perons1”中访问
​
p1.say()
​
​
let  s1=new Stu1("李四")
s1.say()
​

抽象类abstract

抽象类做为其它派生类的基类使用。 它们一般不会直接被实例化。abstract 关键字是用于定义抽象类和在抽象类内部定义抽象方法。抽象类中的抽象方法不包含具体实现并且必须在派生类中实现

​
// 抽象类，一般不会实例化，只是给派生类（子类）当做基类使用
// 抽象方法
abstract class Person2{
​
    // 抽象方法,规定了子类必须声明的方法，以及方法的返回值类型
    // 抽象方法 必须在子类中具体实现
    abstract fun():string
}
​
class Stu2 extends Person2{
​
    // 子类中必须有fun   并且返回值是string
    fun(): string {
      
        return "fun"
    }
}
​
// new  Person2() //无法创建抽象类的实例 
​
console.log(new  Stu2().fun());//fun

二、接口

TypeScript的核心原则之一是对值所具有的结构进行类型检查。TypeScript里，接口的作用就是为这些类型命名和为你的代码或第三方代码定义契约

属性接口

interface 接口名称{
    必传属性:属性类型
}

// 接口：规定函数应该使用那些参数，什么样的参数
// 接口通常会抽离出来，单独声明
// 接接口声明：interface 接口名{  }
​
​
console.log("-----------属性接口 --------------"