TypeScript基础(2)

一.函数

1.函数的基本使用

export default{}
//匿名函数
const makeMoney = function(salary:number,reward: number): number {
    return salary +reward
}
let res =makeMoney(1000,500);
console.log(res);

//有名函数│命名函数|普通函数
function writecode(hour: number, sleep: number): number {
    return hour
}
let res2=writecode(8, 1)
console.log(`我每天要看${res2}个小时代码 `);

    //箭头函数
const seeMeiMei = (time: number) :void => {
    console.log(`我每天要看${time}个小时MeiMei `);
}
seeMeiMei(8)

    //接口函数
type myFunc =(x: number,y: number) =>number 
const myfunc :myFunc = (a: number, b: number) =>a + b

let res3= myfunc(75,65)
console.log(res3);

2.可选参数

export default{}
//可选参数
type aa=(x: number, y: number)=>number
const func1:aa= (a:number, b?:number)=>{
return a+b
}
// const func1:(x: number, y: number)=>number = (a:number, b?:number)=> {
// return a+b;
// }
console.log(func1(1,2));

const func2 = function(c: number,d? : number): number {
    return c;
}
func2(10);
func2(10,20);
func2(10,undefined);
//函数的默认值
const func3 = function(e: number = 1,f:number =2,g:number=3){
     return e + f + g;
}
func3();
func3(10);
func3(10,20);
func3(10,20,30);

//函数的剩余参数
const func4 = function(...args: any[]) {
    console.log(args);
}
func4(10, 20, 30, "邱淑贞");
const func5 = function(a: number, b: number,...args: any[]) {
    console.log(a);
    console.log(b);
    console.log(args);
}
func5(10, 20, 30,"邱淑贞 ","邢菲");

注：可选参数不要参加运算，虽然不会报错

3.构造函数

export default{}

//构造函数
//class人
// {
    //姓名: string
    //年龄:age
// }
    //var person =new 人()  此时无值
    // person.姓名=”刘亦菲“
    // person.年龄=18
    //var person=new 人("刘亦菲，18)  此时有值，创建对象的时候有值就是构造函数
    
    var myFunction = new Function("a","b","return a * b");
    var x = myFunction(4,3);
    console.log(x);

4.函数重载

export default{}

//使用函数重载

function addFunc(a:number,b:number):number
function addFunc(a:string,b:string):string
function addFunc(a:number,b:string):string
function addFunc(a:string,b:number):string

function addFunc(a: any,b: any) : any {
    return a + b;
}
addFunc(10,20);
addFunc("谭松韵","金晨");
addFunc (27,"白鹿");
addFunc("赵今麦",19);


//定义参数类型与参数数量不同
function star(s1:string) : void;
function star(n1 : number,s1:string) : void;
function star(x: any , y? :any) : void {
console.log(x);
console.log(y);
}
star("王心凌");
star(1,"爱你");

二.类

1.类的基本使用

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 p0 = new Person("李荣浩",39)
p0.sayHello()

2.类的继承

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}岁了`);
        
    }
}

class Student extends Person{
    score:number
    constructor(name:string,age:number,score:number){
        //调用父类中的构造函数
        super(name,age)
        this.score=score
    }
    sayHello():void{
        //调用父类中的方法
        super.sayHello()
        //重写父类中的方法
        console.log(`我是重写的方法,我最喜欢的歌手是${this.name},他今年${this.age}岁了,他考了${this.score}分`); 
    }
}
let stu = new Student("李荣浩",39,98)
stu.sayHello()

3.static与instanceof运算符

export default {}

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

    class StaticTest{
    static salary : number
    static say():void{
    console.log(`我们想要的工资是${StaticTest.salary}k` )
    }
    }
    StaticTest.salary=18;
    StaticTest.say();
    
// instanceof运算符
// instanceof运算符用于判断对象是否是指定的类型，如果是返回true，否则返回false。
    class Person{}
    let p = new Person()
    let isPerson = p instanceof Person;
    console.log("p是Person实例化出来的么?"+isPerson);

    class Student extends Person{}
    let s = new Student()
    let isPerson2 = p instanceof Person;
    console.log("s是Person实例化出来的么?"+isPerson2);
    
    

4.类的修饰符

export default{}
 
//类的基本使用
class Person{
    //字段(属性)

// public(默认):公有，可以在任何地方被访问
// protected:受保护，可以被其自身以及其子类访问
// private:私有，只能被其定义所在的类访问。

    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
    }
    //函数方法
    sayHello():void{
        console.log(`我最喜欢的歌手是${this.name},性别是${this.sex}他今年${this.age}岁了`);
        
    }
}

class Student extends Person{
    score:number
    constructor(name:string,age:number,sex:string,score:number){
        //调用父类中的构造函数
        super(name,age,sex)
        this.score=score
    }
    sayHello():void{
        //调用父类中的方法
        super.sayHello()
        //重写父类中的方法
        console.log(`我是重写的方法,我最喜欢的歌手是${this.name},他今年${this.age}岁了,他考了${this.score}分`); 
    }
}
//sex 用不了，以为设置了私有
let stu = new Student("李荣浩",39,"男",98)
stu.sayHello()

5.getter和setter

export default{}


// 如果存在get，但没有set ,则改属性自动是只读的
// 如果没有指定setter参数的类型，它将从getter的返回类型中推断出来

// 访问器和设置器必须有相同的成员可见性

class MyName{
    private _fullName:string="王祖贤"
    //读取数据
    get fullName(){
        console.log("get被调用");
        
        return this._fullName
    }
    //为字段赋值
    set fullName(newName:string){
        console.log("set被调用");
        
        this._fullName=newName
    }
}

let n = new MyName()
n.fullName="邱淑贞"
console.log(n);
console.log(n.fullName);

6.抽象类

export default{}


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

abstract class Person{
    abstract name:string
    abstract age:number
    abstract show():string

    showName():void{
        console.log("Hello world");
        
    }
}

class Student extends Person{
    name:string="关之琳"
    age:number=18
    show(){
        return "十三姨"
    }
}

//let p =new Person() //抽象类不能实例化
let s = new Student();
let result= s.show()
console.log(result);

//抽象类不能实例化，作为父类，继承他的子类，可以实例化