118.《TypeScript 基础知识总结(数据类型,接口,抽象类,继承,属性封装,修饰符) 》

typescript知识点总结

1.概念

• 类（class）: 定义了一类事物的特点，这类事物具有属性和方法
• 对象（Object）: 定义的类被 new 实例化 生成我们的对象
• 面向对象（OOP）：具有三大特征: 封装，继承，多态
• 封装：在我们类中，有很多敏感的数据，比如我们类中的金额，密码 等属性，这些东西 将被 隐藏起来，只暴露对外的接口，对外只能通过我提供的接口来访问我的数据，同时保证了外界无法肆意i需改我们的数据
• 继承（extends）： 子承父业，子类继承了父类的所有属性以及方法，在子类中 可以访问 父类定义的 属性 方法，并且还可以对 其 方法进行重写
• 修饰符：
  • public: 默认值，公共修饰符，其修饰的属性和方法可以被外界所访问，以及修改，对属性的安全性 较低
  • protected: 被 其修饰的 方法和属性，只能被 自己类 及其 子类进行访问，子类的实例化 以及 外界无法访问
  • private: 私有属性，被其修饰的属性和方法，只能自己 的 类中访问，数据安全性最高
• 抽象类：（Abstract Class）: 被 其 修饰的类，称为抽象类，抽象类 不能被实例化 ，抽象类中的抽象方法 必须在子类中被实现
• 接口（Interfaces）：不同类之间公有的属性或方法，可以抽象成一个接口。接口可以被类实现（implements）。一个类只能继承自另一个类，但是可以实现多个接口

2.typeScript 中的数据类型

数字

let num : number = 10 
num = 100
console.log( num );

字符串

let str:string ='str' 
str = '这是一个字符串'  
console.log( str );

布尔值

let istrue : Boolean = true
istrue = false
console.log( istrue ); 

undfind

// 这是一个 undfind 
let und:undefined 
und = null 
console.log( 'undefined类型输出',und );

null

let nu:null
nu = undefined
console.log( 'null进行输出',nu );

obj

方式一： 对象object

let obj: {}
obj = { a:1 , b:4 , c:6 }

方式二： 对象object

let obj1 : { name:string, age?:number }
obj1 = { name:"zhangsan" }

方式三：对象object ( 可传入多个对象 )

let obj2 : { name:"里斯",[ propName:string ]:any }
obj2 = { name:"里斯",age:"里斯",c:4 }

元组

元组：数组长度是固定的

let yz : [ string,string ]
yz = ["1","2"]  

枚举

列出所有可能的情况

enum gender{
    grils = 0,
    male = 1
}
let i : { name:string,sex:gender,a?:number,[ propName:string ] : any }
i = {
    name:"张三",
    age:44,
    sex:gender.male
}
console.log( i.sex === gender.male );  // true

函数类型

函数 的 类型

let d : ( a:number,b:number )=> number

d = function ( n1:number=1,n2:number=2 ){
    return n1 + n2
 }
console.log( d( 10,20 ) );

void

函数的返回为空

function fn() : void {
    return null
}

never

函数没有返回值

function noReturn():never {
    throw new Error("这是一个错误")
} 

3. 运算符

| 或

let notype: number | string
notype = 1
notype = 'str' 

& 并且

let objs : { name:string } & { age : number } 
objs = {
    name:"sas",
    age:45
}
console.log( objs );

类型的别名

let mytype = 11 || 22 || 33
let variable = mytype
console.log( variable );

类型的断言

let  a  = '字符串 a' 
let  b  = '字符串 b' 
a = b as string

4. 类的继承

class Anamin {
    name:string;
    age:number;
    constructor(name:string,age:number){
       this.name = name 
       this.age = age 
    }
    say(){
        console.log( "这是一个动物类" );
    }
    static staticMeth(){
        console.log( "这是一个静态方法" );
    }
}

class Dog extends Anamin {
    // say 对父类中的 方法进行了重写
    say(){
        console.log( "汪汪汪" );
    }
}
class Cat extends Anamin {
    // say 对父类中的 方法进行了重写
    say(){
        console.log( "猫猫猫" );
    }
}

let dog1 = new Dog("王婉",15)
console.log( dog1.say() );  // 汪汪汪
/*  被 static 修饰的方法为 静态方法，静态方法只能被 类 访问  */ 
console.log( Anamin.staticMeth() ); // 这是一个静态方法

let cat = new Cat("猫",55)
console.log( cat.say() );   // 猫猫猫

5.super 关键字

super 指向父类中的属性

 
abstract class Anamins {
    name:string; 
    constructor(name:string){
       this.name = name  
    }
    say(){
        console.log( "这是一个动物类" );
    } 
}

class Dogs extends Anamins {
    age:number;
    constructor( name:string,age ){
         super(name)
         this.age = age
    }
    say(){
        console.log( "汪汪汪" );
    }
} 

let dog0 = new Dogs("王婉",15) 
console.log( dog0.age );

6. 抽象类

被 abstract 修饰的类 为抽象类，被其修饰的方法 为 抽象方法 修饰的属性为抽象属性

抽象方法被继承时 必须 被重写

 
abstract class Pseson {
    name:string; 
    constructor(name:string){
       this.name = name  
    }
    abstract say():void; 
}

class Son extends Pseson {
    age:number;
    constructor( name:string,age ){
         super(name)
         this.age = age
    }
    say(){ 
        console.log( "这是继承抽象类的" );
    }
} 

let dog0 = new Son("王婉",15) 
console.log( dog0.age );

7. interface 接口

接口可以通过 implements 被类 进行一个实现

他的主要作用是对类的接口进行一个限制，也就是用来定义类的结构，告诉类应该包含哪些结构 同时接口 可以当作类型申明 去使用

当做 类型申明使用

interface myInterface {
   name: string,
   age: number 
} 
const obj : myInterface = {  // myInterface
    name:"占山",
    age:15
}
console.log( obj );

实现接口

interface myinter {
    name:string;
    sayHello():void
}

// 定义类时 可以去实现接口
// 实现接口 就是 类 满足 接口的要求
class  Myclasss implements myinter{
    name: string
    sayHello(): void {
        throw new Error("Method not implemented.")
    }
} 

8. 属性的封装

方式一：

借助我们的方法 实现间接的修改我们的属性

class Person(){
	private _name:string;
	private _age:number;
	constructor( name:string,age:number ){
		this._age = age
		this._name = name
	}
	getName(){
		return this._name 
	}
	setName(val:string){
		this._name = val
	} 
}
// 实例化
let per = new newClass("孙悟空",15)
console.log( per.getName() )
console.log( per.setName('猪八戒') )

方式二：

通过存储器访问属性

class newClass {
   private _name:string;
   private _age:number; 

    constructor(name:string,age:number) {
        this._name = name
        this._age = age
    }
    // get set  属性的 存取器
    get name(){
        return this._name
    }
    set name(val:string){
       this._name = val
    }
    get age(){
        return this._age
    }
    set age(val:number){
        if( val > 0 ){
            this._age = val
        } 
    }
}

let per = new newClass("孙悟空",15)  
  // 通过存储器访问属性
  console.log( per.name );
  console.log( per.name = '猪八戒' );
  console.log( per );