可以定义属性，构造函数和实例方法。

  //ts中类的定义及使用
  class Person {
    //定义属性
    name: string
    age: number
    gender: string
    //定义构造函数:实例化对象的时候可以直接对属性的值进行初始化
    constructor(name: string = '小甜甜', age: number = 16, gender: string = '男') {
      //更新对象中的属性数据
      this.name = name
      this.age = age
      this.gender = gender
    }
    //定义实例方法
    sayHi(str: string) {
      console.log(`大家好，我是${this.name},今年${this.age}岁了。是个${this.gender}孩子.`, str)
    }
  }
  //ts中使用类实例化对象，可以直接进行初始化操作
  const person = new Person('dxy', 18, '女')
  person.sayHi('你叫什么名字啊')

• 类之间的继承关系用extends实现。
• 子类中可以调用父类中的构造函数，使用的是super关键字，（包括父类中的实例方法）
• 子类可以重写父类的方法

//定义一个类
  class Person {
    //定义属性
    name: string
    age: number
    gender: string

    //定义构造函数
    constructor(name: string='小明', age: number=18, gender: string='男') {
      //更新属性数据
      this.name = name
      this.age = age
      this.gender = gender
    }
    //定义实例方法
    sayHi(str: string) {
      console.log(`我是:${this.name}`,str)
    }

  }
//定义一个类，继承自person
  class Student extends Person {

    constructor(name: string, age: number, gender: string) {
      //调用父类的构造函数
      super(name,age,gender)
    }
    //可以调用父类的方法
    sayHi() {
      console.log('我是学生类中的sayHi方法：')
      super.sayHi('哈哈')
    }
  }
  //实例化person
  const person = new Person('大明', 89, '男')
  person.sayHi('嘎嘎')
  //实例化student
  const student = new Student('小甜甜',16,'女')
  student.sayHi()

• 父类型的引用指向了子类型的对象，不同类型的对象针对相同的方法，产生了不同的行为。

  //定义一个父类
  class Animal {
    name: string
    constructor(name: string) {
      //更新属性值
      this.name = name
    }
    run(distance: number = 0) {
      console.log(`跑了${distance}米`,this.name)
    }
  }
  //定义一个子类
  class Dog extends Animal {

    constructor(name: string) {
      super(name)
    }
    //实例方法，重写父类中的实例方法
    run(distance: number = 5) {
      console.log(`跑了${distance}米`,this.name)
    }
  }
  //定义一个子类
  class Pig extends Animal {

    constructor(name: string) {
      super(name)
    }
    //实例方法，重写父类中的实例方法
    run(distance: number = 10) {
      console.log(`跑了${distance}米`,this.name)
    }
  }
  //实例化父类对象
  const ani: Animal = new Animal('动物')
  ani.run()
  const dog: Dog = new Dog('大黄')
  dog.run()
  const pig: Pig = new Pig('佩奇')
  pig.run()
  console.log('===========')
  //父类和子类的关系：父子关系，此时，此时，父类类型创建子类对象
  const dog1: Animal = new Dog('小黄')
  dog1.run()
  const pig1: Animal = new Pig('小猪')
  pig1.run()
  console.log('===========')
  //该函数需要的参数是Animal类型的
  function showRun(ani:Animal) {
    ani.run()
  }
  showRun(dog1)
  showRun(pig1)

• 类中的成员的修饰符，描述类中成员（属性，构造函数，方法）的可访问性
• 类中的成员都有自己的默认的访问修饰符public
• public修饰符：公共的，任何位置都可以访问类中的成员
• private修饰符：私有的。类中的成员如果用private来修饰，那么外部是无法访问这个成员属性的
• protected修饰符：受保护的。类中的成员如果使用protected修饰,外部是无法访问这个成员数据的，当然，子类是可以访问的
• 构造函数中的name参数使用关键字进行修饰后Person类中就有了一个相应访问权的属性成员了。

  //类
  class Person {
    //属性 piblic修饰的属性成员
    // public name: string
    //属性 private修饰的属性成员
    //private name:string
    //属性 protected修饰的属性成员
    protected name: string
    //构造函数
    public constructor(name: string) {
      this.name = name
    }
    public eat() {
      console.log('这个骨头真好吃', this.name)
    }
  }
  //定义一个子类
  class Student extends Person {
    constructor(name: string) {
      super(name)
    }
    play() {

      console.log('我就喜欢玩娃娃', this.name)
    }
  }
  //实例化
  const per = new Person('ant')
  //类的外部可以访问类中的属性成员

  per.eat()
  const stu = new Student('红豆')
  stu.play()
  //protected属性只能在person及其子类中调用
  //stu.name()

• 是一个关键字，可以对类中的属性成员进行修饰
• 该属性成员除了在实例化时，不能在外部被随意修改了
• 构造函数中，可以对只读的属性进行修改
• 构造函数中的name参数，一旦使用readonly进行修饰之后，那么该参数可以叫参数属性
• 如果构造函数中没有任何参数，类中的属性成员已经使用readonly修饰了，那么外部也不能对这个属性值进行修改了
• 构造函数中的name参数，一旦使用readonly进行修饰，外部也是无法修改类的name成员值的
• 类中的普通方法，也是不能修改readonly修饰的成员属性的

  class Person {
    constructor(readonly name: string = '大甜甜') {
    }
   //   sayHi() {
  //     console.log('你好', this.name)
  //     //类中的普通方法，也是不能修改readonly修饰的成员属性的
  //     // this.name='大甜甜'
  //   }
  }
  const person: Person = new Person('小甜甜')
  console.log(person)
  //此时无法修改，因为name属性是只读的

• 存取器让我们可以有效地控制对 对象中的成员访问
• 通过getters和setters进行操作。只有get，只读；只有set，可写；两者兼有，可读可写。

class Person {
//外部可以传入姓名，同时使用set和get控制姓名的数据，外部也可以操作
  firstName: string
  lastName: string
  constructor(firstName: string, lastName: string) {
    this.firstName = firstName
    this.lastName=lastName
   }
  //读取器：读取数据
  get fullName() {
    console.log('获取中..')
    return this.firstName+'_'+this.lastName
  }
  //设置器：设置数据
  set fullName(val) {
    //重新赋值
    console.log('set中..')
    let names = val.split('_')
    this.firstName = names[0]
    this.lastName=names[1]
  }
 

  }
  const person: Person = new Person('东方', '不败')
  console.log(person)
  //获取该属性成员属性
  console.log(person.fullName)
  //设置该属性的数据
  person.fullName = '诸葛_孔明'
   console.log(person.fullName)

• 在类中通过static中修饰的属性或方法，也称之为静态成员
• 使用的时候通过 类名.方法 调用
• 通过类名.属性名 修改成员数据

  class Person {
    //静态属性
    static name1: string = '小甜甜'
    //构造函数是不能用static修饰的
    constructor() {
      //不能通过实例对象直接调用静态属性来使用
      //Person.name1 = name
    }
    //静态方法
    static sayHi(){
      console.log('你好')
    }
  }
//实例化对象
  //const person: Person = new Person()
  //通过实例调用属性
 // console.log(person.name)
//通过实例调用方法
  //person.sayHi()
  console.log(Person.name1)
  //通过类名.属性名 修改成员数据
  Person.name1 = 'dxy'
  console.log(Person.name1)
  Person.sayHi()

• 包含抽象方法，也可以包含实例方法。抽象类是不能被实例化的，只是为了让子类实现实例化
• 不能实例化抽象类的对象
• 类和类成员用abstract修饰

  //定义一个类
 
  abstract class Animal {
    //抽象属性
    abstract name:string
    abstract eat ():void
    sayHi() {
      console.log('你好哇')
    }
    
  }
  //定义一个子类
  class Dog extends Animal {
    name:string='小黄'
    eat() {
      console.log('舔着吃')
    }
  }
  //不能实例化抽象类的对象
  const dog: Dog = new Dog()
  dog.eat()
  dog.sayHi()
  console.log(dog.name)