1、类的使用

1.1 类的基本使用

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

定义类的方式：

class Person{// Person自己定义的名字//类作用域
}

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

export default{}
//类的基本使用
class Person{//字段(属性)name:srtingage:number//构造函数constructor(name:srting,age:number){this.name=namethis.age=age}//函数（方法）sayHool():void{console.log(`我是${this.name},她${this.age}岁,但永远18`);}
}
//调用函数
let p = new Person("留"，12)
p.sayHool()

1.2 类的继承

TypeScript支持继承类，即我们可以在创建类的时候继承一个已存在的类，这个已存在的类称为父类，继承它的类称为子类。
                类继承使用关键字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=namethis.age=age}//函数(方法)sayHool():void{console.log(`我是${this.name},她${this.age}岁,但永远18`);}
}
//调用函数
// let p = new Person("留",12)
// p.sayHool()//类的继承 先子级 extends 后父级
class Stuson extends Person{scron:stringconstrustor(name:string,age:number,scron:string){super(name,age) //调用父级中的构造函数this.scron=scron}//函数sayHoole():void{super.sayHool()  //调用父级的函数//重写子集的函数（方法）console.log(`重写的方法，我是${this.name},今年${this.age},成绩是${this.scron}`);}
}
let p0 = new Stuson("kiu",18,"A")
p0.sayHoole()

1.3 static与instanceof

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

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

export default{}
//static关键字用于定义类的数据成员(属性和方法)为静态的,静态成员可以直接通过类名调用。
class Staticy{static salary:numberstatic say():void{console.log(`我们想要的工资是${Staticy.salary}k`);}
}
Staticy.salary=18
Staticy.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 isStudent = s instanceof Person;
console.log("s是Person实例化出来的吗",isStudent);

1.4类中的修饰符

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

export default{}
class Percon{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:stringconstructor(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()//readonly: 可以使用readonly 关键字将属性设置为只读的。只读属性必须在声明时或构造函数里被初始化。
class Print{readonly str1:string="我是声明时3赋值的"readonly str2:stringreadonly str3:stringreadonly str4:stringreadonly str5:stringconstructor(str2:string,str3:string,str4:string,str5:string,){this.str2=str2this.str3=str3this.str4=str4this.str5=str5}
}
let pc=new Print("我的","ghb","ftgyh","jk")
console.log(pc.str2,pc.str3,pc.str4,pc.str5);

1.5 getter与setter

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

export default{}
class MyName{private full:string="杨";//读取字段的值get fullName(){console.log("get被调用")return this.full;}//为字段赋值set fullName(newName:string){console.log("set被调用")this.full=newName}
}
let ns = new MyName()
ns.fullName="liu"  //赋值
console.log(ns)
console.log(ns.fullName)  //取值

1.6 抽象类

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

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

1.7 类的初始化顺序

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

export default{}
class Old{name:string="李"constructor(){console.log(`我是${this.name},古剑奇谭`);}
}
class Young extends Old{name:string="liu"constructor(){super()console.log(`我是${this.name},天龙八部`);}
}
let y = new Young()
//console.log(y)

2. 函数

2.1 函数的基本使用

函数是JavaScript应用程序的基础。它帮助你实现抽象层，模拟类，信息隐藏和模块。在TypeScript里，虽然已经支持类，命名空间和模块，但函数仍然是主要的定义行为的地方。TypeScript为JavaScript函数添加了额外的功能，让我们可以更容易地使用

export default{}
//匿名函数
const makeMoney = function(salary:number,reward:number):number{return salary+reward
}
let res = makeMoney(100,100)
console.log(res)//有名函数|命名函数|普通函数
function writeCode(hour:number,sleep:number){return hour
}
let res1 = writeCode(8,1)
console.log(`我今天写代码${res1}代码`);//箭头函数
const seeMei=(time:number):void=>{console.log(`我每天看${time}小时`);
}
//调用
seeMei(1)
//或
const seeMei1=(time:number):void=>console.log(`我每天看${time}小时`);
//调用
seeMei1(2)//接口函数
type myfun = (x:number,y:number)=>number
const relfun:myfun=(a:number,b:number)=>a+b+100
const rel=relfun(1,2)
console.log(rel);

2.2 函数参数的处理

（1）可选参数:
在TypeScript函数里，如果我们定义了参数,则我们必须传入这些参数，除非将这些参数设置为可选。可选参数使用问号标识？

（2）参数的默认值

语法格式

function 自定义名(param1[:type],paaram2[:type]=default_value){}

（3）剩余参数

当不知道要向函数传入多少个参数，这时候我们就可以使用剩余参数来定义。
剩余参数语法允许我们將一个不确定数量的参数作为一个数组传入。...args :any[]

export default{}
//可选参数
const func1:(a:number,b:number)=>number=(x:number,y:number)=>{return x
}
const func2=function(a:number,b?:number):number{return a
}
func2(10)
func2(10,20)
func2(10,undefined)//参数的默认值
const func3=function(x:number,y:number,z:number=200){return x+y+z
}
let res = fun3(100,200)
console.log(res);
let res1 = fun3(100,200,400) //会覆盖默认值
console.log(res1)//函数的剩余参数
const func4 = function(...args:any[]){lconsole.log(args)
}
func4(1,2,3,4,"李")const func5=function(a:number,b:string,...args:any[]){console.log(a);console.log(b);console.log(args);
}
func5(100,"10","张",true)

2.3 构造函数

什么是构造函数：实例化对象的时候就赋值好了

TypeScript支持使用js内置的构造函数用new Function()来定义函数

语法：

var res = new Function([arg1[,arg2[,...argN]],] functionBody)

参数的说明

（1）arg1,arg2,...argN: 参数的列表

（2）functionBody:一个含有包含函数定义的Js语句的字符串

export default{}
var myStr = new Function("a","b","return a*b")
var str= MyStr(10,20)
console.log(str)

2.4 函数重载

重载是方法名字相同，而参数不同，返回类型可以相同也可以不同

每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表

参数类型不同

function disp(string):void
function disp(number):void

参数数量不同

function disp(n:number):void
function disp(x:number,y:number):void

参数类型顺序不同

function disp(n:number,s:string):void
function disp(s:string,n:number):void

参数类型不同，则参数类型应设置为any

参数数量不同你可以将不同的参数设置为可选

export default{}
//函数重载
function addFunc(a:number,b:number):number
function addFunc(a:string,b:string):string
function addFunc(a:number,b:string):number
function addFunc(a:string,b:number):number
//使用函数重载
function addFunc(a:any,b:any):any{return a+b
}
console.log(addFunc(10,20));
console.log(addFunc("刘亦菲","鞠婧祎"));
console.log(addFunc("养",18));
console.log(addFunc(18,"迪"));//定义参数类型与参数数量不同
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,"哎")

TypeScript函数与类的使用基础知识点相关推荐

typescript函数和类的基础
目录函数函数的基本使用函数参数的使用构造函数函数重载类类的基本使用类的继承 static与instanceof 修饰符 getter与setter 抽象类初始化函数函数的基本使用 ...
Typescript函数和类的使用
一.函数的基本使用函数是Javascript应用程序的基础.可以实现抽象层.模拟类.信息隐藏和模块.在Typescript里,虽然已经支持类.命名空间和模块,但函数仍然是主要的定义行为的地方.Typ ...
TypeScript函数和类
函数介绍函数是JavaScript应用程序的基础.它帮助你实现抽象层,模拟类,信息隐藏和模块.在TypeScript里,虽然已经支持类,命名空间和模块,但函数仍然是主要的定义行为的地方.TypeSc ...
C语言指针基础知识点(六)--通过指针引用多维数组
指针系列目录 C语言指针基础知识点(一)–指针及指针变量 C语言指针基础知识点(二)–指针变量的引用 C语言指针基础知识点(三)–指针变量作为函数参数 C语言指针基础知识点(四)–通过 ...
C语言指针基础知识点(四)--通过指针引用数组
指针系列目录 C语言指针基础知识点(一)–指针及指针变量 C语言指针基础知识点(二)–指针变量的引用 C语言指针基础知识点(三)–指针变量作为函数参数 C语言指针基础知识点(四)–通过 ...
C语言指针基础知识点(七)--通过指针引用字符串
指针系列目录 C语言指针基础知识点(一)–指针及指针变量 C语言指针基础知识点(二)–指针变量的引用 C语言指针基础知识点(三)–指针变量作为函数参数 C语言指针基础知识点(四)–通过 ...
python describe函数_Python基础知识点梳理2，推荐收藏
接着昨天的基础知识点继续梳理,昨天的 Python基础知识梳理1 8.函数 1.定义函数: 使用关键字def来告诉python你要定义一个函数接着指出函数名:如下面函数名是-greet_user ( ...
TypeScript 函数与以及类的使用
一.函数 1.函数的基本使用介绍函数是JavaScript应用程序的基础.它帮助你实现抽象层,模拟类,信息隐藏和模块.在TypeScript里,虽然已经支持类,命名空间和模块,但函数仍然是主要的定 ...
【前端】你好，我叫Typescript 04──函数与类
函数与类前言本文章是Typescript系列学习文章,旨在利用碎片时间快速高效上手学习Typescript,也可以对Typescript进行复习知识点,温故知新.如果感兴趣的话~ 欢迎关注, 后续 ...

TypeScript函数与类的使用基础知识点