TypeScript02
1.class类
面向对象：具有属性和行为的事物的统称
类：抽象，具有相同属性的行为和属性的一类对象抽象为类
对象：具体的东西，对类的具体实现
面向对象的三大特征：
封装：保护内部的属性，对外提供读写的方法
隐藏类内部的细节，只对外提供功能
继承：子类可以继承父类的属性和方法，提高代码复用性
一个类只能由一个父类，一个父类可以有多个子类
多态： 龙生九子，各有不同（一个类的不同形态）
1.1 ES6之前是通过原型来实现的继承，class也是基于原型的语法糖
super/this：this代表当前对象；super代表父类
方法重写：子类可以重写父类的方法
用super.调用父类的方法
1.2 实现接口：implements
类与类之间是继承关系
类与接口之间是实现的关系
接口提供一套标准
通过类可以实现标准
1.3 修饰符
限定修饰符：可以限制类的读写权限
private：私有的，private修饰的属性和方法只能在当前类里访问
protected：保护的，protected当前类中可以使用，它的子类中可以使用
public：公开的，都可以使用
readonly：只读，只能在构造函数中对其进行一次赋值，其他地方不能赋值，只读
static：static修饰的变量或方法，归属于类；非static归属于实例化对象
static是挂到类中的方法，拿不到this(this指当前对象)
class Person {
name: string //成员变量
age: number //成员变量
constructor(name: string, age: number) {
//this这个关键字，指代的是当前对象
this.name = name //局部变量
this.age = age //局部变量
}
getName(): void {
console.log("人类：" + this.name)
}
}
const per1: Person = new Person('张三', 20)
per1.getName()
class Student extends Person {
stuNo: number
constructor(stuNo: number, name: string, age: number) {
super(name, age);
this.stuNo = stuNo
}
study(course: string): void {
this.getName()
super.getName()
console.log(this.name + '学习了' + course)
}
getName(): void {
console.log("学生：" + this.name)
}
}
const stu1: Student = new Student(1, '李四', 22)
stu1.getName()
stu1.study("数学")
interface MemorySticks {
type: MemorySticksType
size: number
//存储，存储k,v数据
store: Map
write(address: string, text: string): void
read(address: string): string
}
enum MemorySticksType {
SDRAM,
DDR,
RDRAM
}
class SamsungMemorySticks implements MemorySticks {
size: number
type: MemorySticksType
store: Map = new Map()
factory: string
read(address: string): string {
console.log("读取了" + address + "的内容")
return this.store.get(address)
}
write(address: string, text: string): void {
console.log("写入" + address + "的内容:" + text)
this.store.set(address, text)
}
}
const neicuntiao: MemorySticks = new SamsungMemorySticks()
neicuntiao.write('add1', '怎么写？不太理解')
console.log(neicuntiao.read("add1"));
class Animal {
private name: string //private仅在当前类可用
color: string
protected height: number //protected仅在当前类和子类可用
constructor(name: string, color: string, height: number) {
this.name = name
this.color = color
this.height = height
}
getName(): string {
console.log(this.name)
console.log(this.height)
return this.name
}
private sayName(): void {
console.log(this.name)
}
}
const ani: Animal = new Animal("小猫", "白色", 15)
console.log(this.getName());
class Dog extends Animal {
readonly weight: number //readonly只读，只能在构造函数中赋值，其他均不可修改
constructor(name: string, color: string, height: number, weight: number) {
super(name, color, height)
this.weight = weight
}
say(): void {
console.log(this.height)
console.log("小狗说：汪汪汪")
}
}
const dog = new Dog("小黄", "黄色", 12, 30)
dog.say()
// dog.weight=10 //readonly修饰的属性和方法不能赋值
console.log(dog.weight) //可读
// new Dog("小黄","黄色",12).height
class Cat {
name: string //非static是挂在实例上的，有this
static color: string //static是挂在类上的，没有this
constructor(name: string) {
this.name = name
Cat.sayHello2() //static方法只能通过类调用
}
say(): void {
console.log(this.name)
console.log("小猫说：喵喵喵")
}
static sayHello2(): void {
console.log("123")
}
}
const cat: Cat = new Cat("小白")
cat.say()
let pro = new Promise((resolve, reject): void => {
resolve(1)
})
pro.then() //then方法相当于非static，是挂到实例上的，归属于实例化对象
Promise.all([pro]) //all和race相当于被static修饰的方法，归属于类
Promise.race([pro]) 1.4 抽象类
里面允许有实现的方法，有没有实现的方法
不能创建实例
//抽象类
abstract class Animal2{
//里面有允许实现的方法，有没有实现的方法
//不能创建实例
weight:number
sleep():void{
console.log('睡觉')
}
abstract say(content:string):void
}
class Cat2 extends Animal2{
say(content):void{
console.log("喵喵喵"+content)
}
}2.交叉类型
同时满足
//& 并，交
interface A {
name: (string | number)
}
interface B {
color: string
name: (string | number)
}
/*同时满足A和B*/
const C: A & B = {
name: "a+b",
color: "hotpink"
}3.泛型
在定义函数、接⼝或类的时候，不预先指定具体类型，⽽在使⽤的时候在指定具体类型的⼀种特性 。
接⼝ interface 也可以配合泛型使⽤，可以增加灵活性、增强复⽤
class AjaxResult{
code:number
msg:string
data:T
getData:T
isSuccess():boolean{
return this.code===200
}
}
interface Iacticle{
acticleId:number
title:string
}
interface Icategory{
categoryId:number
name:string
}
const res1:AjaxResult=new AjaxResult()
if(res1.isSuccess()){
res1.data.forEach(item=>item.title)
}
new Promise>((resolve,reject):void=>{
}).then(res =>{
res.isSuccess()
res.data.forEach(item=>item.categoryId)
}) 3.1 泛型工具
let article:Iacticle={
acticleId:1,
title:''
}
//把article所有属性改变为可选
type Iacticle2=Partial
let article2:Iacticle2={
acticleId:2
}
//把article所有属性改变为只读
let article3:Readonly={
acticleId:3,
title:'文章3'
}
// Pick 从Type 中选择属性来构建新的类型
// 注意：第⼆个参数⼀定要在第⼀个参数中有
let article4:Pick={
acticleId:4
}
// Record 构造⼀个对象类型，属性键为Keys, 属性类型为 Type
type type2=Record<'a'|'b'|'c',string>
let a:type2={
a:'',
b:'',
c:''
}