面向对象OOP(Ts)

操作对象
例如

• 操作浏览器要使用window对象
• 操作网页要使用document对象
• 操作控制台要使用console对象
  (function(){})()
  操作对象要先有类

1. 类(class)
   语法

    class 类名 {
            属性名: 类型;
        constructor(参数: 类型){
            this.属性名 = 参数
        }
        方法名(){
              ......
       }
   }

  class Person{
        /*
        直接定义的属性是实例属性,需要通过对象的实例去访问
      const p = new Person();
      p.name
    使用static开头的属性是静态属性(类属性),可以直接通过类去访问
    Person.age
      */
// readonly 只读属性不能更改
      readonly name: string = 'zs';
    //  在属性前使用static关键字可以定义类属性(静态属性)
       static age: number = 15;
      // 定义方法
      static sayHello() {
         console.log('hello');
       }
     }
    const p = new Peron();
    // 实例属性
    console.log(p.age)
   // 类属性(static开头)
    console.log(Person.age)
   // 实例方法
    p.sayHello()
  // 类方法(static开头)
    Person.sayHello()

2. 构造函数(constructor)在对象创建时调用

 class Hell{
     name: string;
     age: number
  constructor(name: string,age: number){
    /* 在实例方法中,this表示当前的实例
    console.log(this)
 */
      this.name = name;
      this.age = age
  }
 }
const h = new Hell(name:'ls', age:12);
const s = new Hell(name:'zs', age:16)

3. 继承(extends)

class Amid{
    name:string;
    age: number
  constructor(name: string,age: number){
   this.name = name;
   this.age = age
 }
 saHe(){
  console.log('动物们');
  }
}
/* Dog extends Amid
  - 此时,Amid被称为父类,Dog被称为子类
  - 使用继承后,子类将会拥有父类所有的属性和方法 
 - 如果在子类中添加了和父类相同的方法,则子类方法会覆盖掉父类的方法
这种方式称为方法重写
*/
// 使用Dog 继承 Amid 类
class Dog extends Amid {
 run () {
  console.log(`${this.name}在跑~~`);
  }
}
// 使用Cat 继承 Amid 类
class Cat extends Amid {
  saHe(){
    console.log('喵喵');
    }  
}

4. super(在类的方法中super表示当前类的父类)

  class A{
    name: string;
    constructor(name: string){
        this.name = name;
      }
   sayHello() {
     console.log('动物在叫~')
    }
  }
  // 添加新的属性
  class Dog extends A {
    age: number;
  // 对属性进行初始化必须调用构造函数
  constructor(name:string, age:number){
  // 如果在子类中写了构造函数,在子类构造函数中必须对父类的构造函数进行调用
    super(name); // 调用父类的构造函数
    this.age = age;
  }
     sayHello() {  
       console.log('汪汪')
      }
    }
  const dog = new Dog(name:'旺财',age:6)

5. 抽象类
   以abstract开头的类是抽象类;不能创建对象;抽象类就是专门用来被继承的类

abstract class A{
    name: string;
    constructor(name: string){
        this.name = name;
      }
 /* 定义抽象方法;使用abstract开头,没有方法体;只能定义在抽象类中;子类必须对抽象方法进行重写  
*/
 abstract  sayHello(): void;
  }

  class Dog extends A {
     sayHello() {  
         console.log('汪汪')
      }
    }