要想面向对象，操作对象，首先便要拥有对象，那么下一个问题就是如何创建对象。要创建对象，必须要先定义类，所谓的类可以理解为对象的模型，程序中可以根据类创建指定类型的对象，举例来说：可以通过Person类来创建人的对象，通过Dog类创建狗的对象，通过Car类来创建汽车的对象，不同的类可以用来创建不同的对象。

  • 定义类： ```typescript class Person{ name: string; age: number;

    //定义构造函数初始化 constructor(name: string, age: number){

    1.  this.name = name;
    2.  this.age = age;

    }

    sayHello(){

     console.log(`大家好，我是${this.name}`);

    } }

const p = new Person(‘孙悟空’, 18); p.sayHello();

<a name="rXYQK"></a>
### 继承
类从基类中继承了属性和方法。 这里，Dog 是一个 派生类，它派生自 Animal 基类，通过 extends 关键字。 派生类通常被称作_子类_，基类通常被称作_超类_。

1. 重写：如果子类中的方法会替换掉父类中的同名方法，这就称为方法的重写
1. super：子类中可以使用super来完成对父类的引用 
```typescript
class Animal {
  run(distance: number) {
    console.log(`Animal run ${distance}m`)
  }
}

class Dog extends Animal {
  cry() {
    console.log('wang! wang!')
    //调用父方法
    // super.run(1)
  }
  //重写父方法
  // run(distance: number) {
  //   console.log(`Animal run ${distance}cm`)
  // }
}

const dog = new Dog()
dog.cry()
dog.run(100) // 可以调用从父中继承得到的方法

公共，私有与受保护的修饰符

TS中属性具有三种修饰符：

  • public（默认值）— 公共的 ：可以在类、子类和对象中修改
  • protected — 受保护的的 ：可以在类、子类中修改

  • private — 私有的 ：可以在类中修改 ```typescript class Person { public name: string; // 写或什么都不写都是public protected age: number; private sex: string;

    constructor(name: string, age: number, sex: string) { //所有的都可以在类中修改 this.name = name; this.age = age; this.sex = sex; }

    sayHello() { console.log(大家好，我是${this.name}); } }

class Employee extends Person { constructor(name: string, age: number, sex: string) { super(name, age,sex); this.name = name; //public的 子类中可以修改 this.age = age; //protected的 子类中可以修改 this.sex = sex; //private的 子类中不可以修改 } }

const p = new Person(‘孙悟空’, 18); p.name = ‘猪八戒’;// public的 可以通过对象修改 p.age = 22;// protected的 不能修改 p.sex = ‘女’;// private的 不能修改

<a name="Gkhtb"></a>
### readonly 修饰符
**类添加readonly的属性成员**<br />只有构造函数(constructor)中可以修改，外部只能访问
```typescript
class Person {
  readonly name: string = 'abc'
  constructor(name: string) {
    this.name = name
  }
}

let john = new Person('John')
// john.name = 'peter' // error 只读属性不可以修改

构造函数中参数使用readonly
这种情况会相当于在给该类添加一个属性成员name, 不仅readonly 其他修饰符也是。一样是外部可以访问但不能修改

class Person2 {
  constructor(readonly name: string) {
  }
}

const p = new Person2('jack')
console.log(p.name) //传入参数却能用实例对象访问name

存取器 getters/setters

TypeScript 支持通过 getters/setters 来截取对对象成员的访问。 它能帮助你有效的控制对对象成员的访问。

class Person {
  firstName: string = 'A'
  lastName: string = 'B'

  get fullName () {
    return this.firstName + '-' + this.lastName
  }

  set fullName (value) {
    const names = value.split('-')
    this.firstName = names[0]
    this.lastName = names[1]
  }
}

const p = new Person()
console.log(p.fullName) //A-B

p.firstName = 'C'
p.lastName =  'D'
console.log(p.fullName) //C-D

p.fullName = 'E-F'
console.log(p.firstName, p.lastName)//E F

静态属性

static 静态属性（方法），也称为类属性。使用静态属性无需创建实例，通过类即可直接使用 

class Person {
  //静态属性
  static myName: string = 'Dan'

  constructor() {
    //this是实例对象,不能访问或修改静态属性
    //this.myName = 'Dan' //error
  }
  //静态方法
  static sayHi() {
    console.log('Hi');
  }
}

const person: Person = new Person();
//console.log(person.myName); //实例对象不能访问静态属性
//person.sayHi() //实例对象不能访问静态方法

console.log(Person.myName); // Dan
console.log(Person.sayHi());// Hi

抽象类

抽象类是专门用来被其他类所继承的类，它只能被其他类所继承不能用来创建实例。
使用abstract开头的方法叫做抽象方法，抽象方法没有方法体只能定义在抽象类中，继承抽象类时抽象方法必须要实现 

abstract class Animal {
    //抽象方法不能有方法体
  abstract cry ()

  run () {
    console.log('run()')
  }
}

//继承抽象类
class Dog extends Animal {
  //实现抽象方法
  cry () {
    console.log('Dog cry()')
  }
}

const dog = new Dog()
dog.cry() //Dog cry()
dog.run() //run()