创建类：class关键字

//age为number类型
//sex为string类型
class person{
age：number
sex: "男"  
}
//person的实例对象p的类型是person
const p = new person()

构造函数：constructor关键字

一个类只可以有一个constructor方法，且不写会调用默认的构造函数

//构造函数不需要返回值类型
class person{
  age: number
  sex: string
  constructor(age: number,sex: string){
  this.age=age
  this.sex=sex
}            
}
//调用函数
const p = new person(18,"男")

类的实例方法

//定义一个取平方的方法
class point {
  x=10
  y=20
  scale(n:number):void{
    this.x*=n
    this.y*=n
  }
}
//调动函数
const p = new point()
p.scale(10)

类的继承

在JS中只有extends，而TS新增了implements

extends方法

//定义动物类
class Animal{
move(){console.log('moving')}
}
//定义狗类并继承动物类
class Dog extends Animal{
bark(){consple.log('汪')}
}
//狗类具有move()和bark()方法
const dog = new Dog()
dog.move()//moving
dog.dark()//汪

implements方法(实现)

实现接口，可以大致理解为继承接口，使用此方法后类中必须指定所有的方法和属性

//定义接口
interface singale{
string():void
name:string
}
//类中实现接口
class person implements singale{
name='jack'
  sing(){
  console.log('我是个沉默不语的，靠着墙壁晒太阳的过客')
  }
}
//调用
const p = new person()
console.log(p.name+"在唱"+p.sing())

可见性修饰符

public

在任何地方都可以被访问到(默认为public)

//动物类
class Animal{
 public move(){
 console.log('走两步')
 } 
}
const a = new Animal()
a.move()//输出 走两步
//狗继承
class Dog extends Animal{
bark(){
  this.move()
  console.log('汪')
}
}
const d = new dog
d.bark()//输出  走两步 汪
d.move()//输出 走两步

protected

在声明类中或子类可以访问，子类可以通过this来访问父类受保护的成员，但是实例不可以访问

//动物类
class Animal{
 protected move(){
 console.log('走两步')
 } 
  run(){
  this.move()
    console.log('跑起来')
  }
}
const a = new Animal()
a.move()//报错，不可在实例对象中访问受保护的成员
a.run()//输出走两步 跑起来
//狗继承
//调用bark()函数输出  走两步 跑起来 汪
class Dog extends Animal{
bark(){
  this.move()
  console.log('汪')
}
}
const d = new dog
d.bark()//输出  走两步 跑起来 汪
d.run()//输出走两步 跑起来
d.move()//报错

private

只在当前类可见，其他都不可访问

//动物类
class Animal{
 private move(){
 console.log('走两步')
 } 
}
const a = new Animal()
a.move()//报错，不可在实例对象中访问私有的成员
//狗继承
class Dog extends Animal{
bark(){
  //this.move()//报错 不可在子类访问父类私有成员
  console.log('汪')
}
}
const d = new dog
d.move()//报错