先写一个简单的类
class Girlclass {
public name: string
}
const girlcA = new Girlclass()
girlcA.name = '小红'
console.log(girlcA.name) // 小红
如果类中的属性模式是public属性,可以被外部访问,也可以在内部使用
class Person1 {
public name: string;
constructor(name: string) {
this.name = name
console.log(this.name)
}
}
const person1 = new Person1('小红')
如果类中的属性是private,则该属性只能在内部被访问,不能外部调用
class Person3 {
private name: string;
private work: true;
constructor(name: string) {
this.name = name
}
public sayHello() {
console.log(this.name + ' say Hello') // 小红 say Hello
};
}
const person3 = new Person3('小红')
person3.sayHello()
//person3.work // 报错:属性“work”为私有属性,只能在类“Person3”中访问
如果类中的属性是protected,则该属性在该类的内部可以调用,在外部调用出错,它的子类可以继承protected属性,可以使用
class Person4 {
protected name: string
constructor(name: string) {
this.name = name
}
public sayHello() {
console.log(this.name + ' say Hello')
}
}
class Person5 extends Person4 {
sayName() {
console.log(this.name)
}
}
const person5 = new Person5('小红') // 此处注意,类的继承同样会继承类的构造函数
person5.sayName()
person5.sayHello()
类中的构造函数
// 之前的构造函数是这样写的
class Person6 {
public name: string;
constructor(name: string) {
this.name = name
}
}
const person6 = new Person6('小红')
构造函数的简写(写法就相当于你定义了一个name,然后在构造函数里进行了赋值,这是一种简化的语法,在工作中我们使用这种语法的时候会更多一些。)
class Person7 {
constructor(public name: string) { }
}
如果子类中使用构造函数,必须在constructor内部写super()函数来调用父类的构造函数,如果父类的构造函数有参数,还必须传上
class Person8 {
constructor(public name: string) { }
}
const person8 = new Person8('小红')
class Person9 extends Person8 {
constructor(public age: number) {
super('小美')
}
}
关于private私有属性的设置和查看 Getter、Setter,可以调用.get .set属性来操作,注意get和set并不是方法,归根到底还是属性
class Xiaojiejie {
constructor(private _age: number) { }
get age() {
return this._age - 10 // 我们可以在获取私有属性的时候修改属性的值
}
}
const dajiao = new Xiaojiejie(25)
console.log(dajiao.age) // 15
// 调用set Xiaojiejie1.age = 30 调用get Xiaojiejie1.age
class Xiaojiejie1 {
constructor(private _age: number) { }
get age() {
return this._age + 5
}
set age(age: number) {
this._age = age
}
}
const dajiao1 = new Xiaojiejie1(25)
dajiao1.age = 30
console.log(dajiao1.age)
类中的staic(静态修饰符)
学习类,都知道要使用这个类的实例,就要先New 出来(),但是有时候人们就是喜欢走捷径。但是现在不想new 出对象,而直接调用类中的方法,那Ts提供了快捷的方法,用static声明的属性和方法,不需要声明对象,就可以直接使用
class Staticobj {
static sayLove() {
return 'I Love You'
}
}
console.log(Staticobj.sayLove()) // I Love You
类中的只读属性readonly(第一次设定后不允许往后再次修改)
class Person10 {
constructor(public readonly _age) { }
}
const person10 = new Person10(20)
// person10._age = 20 报错:无法分配到 "_age" ,因为它是只读属性。
类中的抽象类 abstract
使用场景:如果我们要求三个类都具备相同的属性方法,但是方法内部不相同,比如我开了一个红浪漫洗浴中心,里边有服务员,有初级技师,高级技师,每一个岗位我都写成一个类,我作为老板,我要求无论是什么职位,都要有独特的技能,比如服务员就是给顾客倒水,初级技师要求会泰式按摩,高级技师要求会 SPA 全身按摩。这是一个硬性要求,但是每个职位的技能有不同,这时候就可以用抽象类来解决问题。
// class Water { } // 初级
// class BaseTeacher { } // 中级
// class SeniorTeacher { } // 高级
abstract class Girl666 {
abstract skill() // 因为没有具体的方法,所以我们这里不写括号
}
// 有了这个抽象类,三个类就可以继承这个类,然后会要求必须实现skill()方法,代码如下:
class Water extends Girl666 {// 初级
skill() {
console.log('大爷,请喝水!')
}
}
class BaseTeacher extends Girl666 {
skill() {
console.log('大爷,来个泰式按摩吧!')
}
}
class SeniorTeacher extends Girl666 {
skill() {
console.log('大爷,来个SPA全身按摩吧!')
}
}
ts的联合类型展示
所谓的联合类型,就是可以认为一个变量可能又两种或两种以上的类型,关键符号是 ’ | ’
interface IA {
anjiao: boolean
say: () => {}
}
interface IB {
anjiao: boolean
skill: () => {}
}
function judgeWho1(animal: IA | IB) {
// animal.say() 报错:judgeWho不能准确的判断联合类型具体的实例是什么。
}
这时候就需要再引出一个概念叫做类型保护,类型保护有很多种方法,讲几个最常使用的。
类型保护-类型断言 (类型断言就是通过断言的方式确定传递过来的准确值,)
function judgeWho2(animal: IA | IB) {
if (animal.anjiao) {
(animal as IB).skill()
} else {
(animal as IA).say()
}
}
我们还经常使用in语法来作类型保护,比如用if来判断animal里有没有skill()方法。这里的else部分能够自动判断,得益于TypeScript的自动判断。
function judgeWho3(animal: IA | IB) {
if ('skill' in animal) {
(animal as IB).skill()
} else {
(animal as IA).say()
}
}
下一篇: typescript(八)ts中的Enum枚举