TypeScript面向对象

面向对象是程序中一个非常重要的思想，它被很多同学理解成了一个比较难，比较深奥的问题，其实不然。面向对象很简单，简而言之就是程序之中所有的操作都需要通过对象来完成。

·举例来说:

操作浏览器要使用window对象

操作网页要使用document对象

操作控制台要使用console对象

在程序中所有的对象都被分成了两个部分数据和功能，以人为例，人的姓名、性别、年龄、身高、体重等属于数据，人可以说话、走路、吃饭、睡觉这些属于人的功能。数据在对象中被成为属性，而功能就被称为方法。所以简而言之，在程序中一切皆是对象。

在程序中所有的对象都被分成了两个部分数据和功能，以人为例，人的姓名、性别、年龄、身高、体重等属于数据，人可以说话、走路、吃饭、睡觉这些属于人的功能。数据在对象中被成为属性，而功能就被称为方法。所以简而言之，在程序中一切皆是对象。

类（class）

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

语法

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

实例

class Person {
    //定义实例属性
    name:string="张三"
    //定义静态属性  readonly:设置文只读属性
     static readonly age: number=16

    //定义一个方法
    sayHi(){
        console.log("我是一个方法")
    }
}

const person=new Person();
//修改person的name
person.name="李四"
console.log(person)

console.log("姓名："+person.name+"年龄："+Person.age)

person.sayHi()

构造函数和this

class  Dog {
    name:string;
    age:number

    //constructor 构造函数
    constructor(name:string,age:number) {
        this.name=name;
        this.age=age
    }

    bark(){
        alert("dog的名称为"+this.name)
    }
}
const dog=new Dog("小黑",17)
const dog2=new Dog("小白",17)

console.log(dog);
console.log(dog2);

dog2.bark()

继承

//立即执行函数
(function () {
   //定义一个动物的类
    class Animal{
        name: string;
        age:number;
        constructor(name:string,age:number) {
            this.name=name
            this.age=age
        }

        sayHai(){
            console.log("动物在叫")
        }
    }

    /**
     * extends Animal
     * -此时，Animal被称为父类，Dog被称为子类
     * -使用继承后，子类将会拥有父类所有的方法和属性
     * 通过继承可以将多个类中共有的代码写在一个父类中，
     * 这样只需要写一次即可让所有的子类都同时拥有父类中的属性和方法
     * 如果希望在子类中添加一些父类中没有的属性或方法直接加就行
     * 如果在子类中添加了和父类相同的!法，则子类方法会覆盖掉父类的方法
     * 这种子类覆盖掉父类方法的形式，我们称为方法重写
     */
    //定义一个狗狗类
     class Dog extends Animal{
      run(){
          console.log(this.name+"再跑")
      }
      sayHai() {
          console.log("汪汪汪")
      }
    }

    //定义一个猫类
    class Cat extends Animal{

    }
    const dog=new Dog("旺财",4)
    const cat=new Cat("猫",1)
    console.log(dog)
    console.log(cat)
    dog.sayHai()
    dog.run()
})();

super关键字

(function () {

    class Animal{
        name: string

        constructor(name:string) {
            this.name=name;
        }

        sayHai(){
            console.log("动物再叫")
        }
    }

    class Dog extends Animal{
        age:number

        constructor(name:string,age:number) {
            super(name);//调用父类的构造函数
            this.age=age
        }

      //在类的方法中super就表示当前类的父类
        sayHai() {
            super.sayHai();
        }
    }
  const dog=new Dog("旺财",2)

    console.log(dog)
})();

抽象类

(function () {
    //abstract:定于一抽象类
    abstract class Animal{
        name: string

        constructor(name:string) {
            this.name=name;
        }
        //定义一个抽象方法
        //抽象方法使用abstract开头，没有方法题
        //抽象方法只能定义在抽象类中，子类必须对抽象方法进行重写
       abstract sayHai():void
    }

    class Dog extends Animal{
        //在类的方法中super就表示当前类的父类
        sayHai():void {
           console.log("汪汪汪...")
        }
    }

    class Cat extends Animal{
        sayHai(): void {
            console.log("喵喵喵...")
        }

    }

    const dog=new Dog("旺财")
    const cat=new Cat("猫")
    console.log(dog)
    console.log(cat)
    dog.sayHai();
    cat.sayHai();
})();