面向对象，对事物的概括，具体的事物抽象成虚拟的形式，即抽象为对象。

一、class类

对象包括属性和方法。对象的特点叫做属性，对象可以实现的事情叫做方法。

属性

class中的属性是实例属性，只有创建了实例才能使用属性。
class使用static关键字的属性是类属性，又叫静态属性。

class Person{
//实例属性
name:string="张三"
//类属性
static age:number=20
}

const per=new Person()

console.log(per)//通过实例访问

console.log(Person.age)//通过类访问

class属性可读可写，使用readonly关键字改为只读

class Person{
name:string="张三"
readonly age:number=20
static readonly height:number=180
}

const per=new Person()
per.name="李四"

对象

对象类型与属性类型一致，当使用static关键字时，方法是类对象；当不使用static关键字时，方法时实例对象。

class Person{
    //方法
    sayHello(){
        console.log('hello world')
    }
}

const per=new Person()
console.log(per.sayHello)

二、类的构造器创建实例

class Dog{
    name:string;
    age:number;
    constructor(name:string,age:number){
        this.name=name;
        this.age=age;
    }
    bark(){
        console.log(this.name+'在叫')
    }
}

const dog1=new Dog('招财',8)
const dog2=new Dog('进宝',8)

创建实例会自动执行构造器函数constructor，通过传入不同的形参，创建不同的实例
类中的this指向自身的实例函数。dog1指向招财实例，dog2指向进宝实例

三、类的继承

class Animal{
    name:string;
    age:number;
    constructor(name:string,age:number){
        this.name=name;
        this.age=age;
    }
    sayHello(){
        console.log('动物在叫')
    }
}

class Dog extends Animal{
    run(){
        console.log(`${this.name}在跑`)
    }
    sayHello(){
        console.log('狗在叫')
    }
}

const dog1=new Dog("旺财",5)
dog1.run()
dog1.sayHello()

Animal类是共有属性和方法，Dog类或其他具体的类可以继承Animal类的属性和方法。 extends继承类

可以在Dog类中定义具体的私有属性和方法。当Dog类中需要使用符合自身类的Animal方法，Dog中sayHello方法会覆盖Animal的sayHello方法，重写实现需求的实现

四、super 父类引用

class Animal{
    name:string;
    constructor(name:string){
        this.name=name
    }
    sayHello(){
        console.log('动物在叫')
    }
}

class Dog extends Animal{
    age:number;
    constructor(name:string,age:number){
        super(name)
        this.age=age
    }
    sayHello(){
        super.sayHello()
    }
}

当子类继承父类，需要添加属性或使用constructor时，需要使用super传参调用父类属性

super相当于父类，通过super.sayHello()可以调用父类方法

五、abstract 抽象

abstract class Animal{
    name:string;
    constructor(name:string){
        this.name=name;
    }
    abstract sayHello():void;
}

class Dog extends Animal{
    sayHello(){
        console.log("汪汪")
    }
}

类使用abstract，定义为抽象类，抽象类只能被继承，不能创建实例。
方法使用abstract，父类中声明方法，子类必须创建。

六、interface 接口

interface myClass{
    name:string;
    sayHello():void;
}
class classOne implements myClass{
    name:string;
    constructor(name:string){
        this.name=name
    }
    sayHello(){
        console.log("大家好")
    }
}

interface可以作为类结构，也可以作为类型声明
interface与type类似，interface可以多次声明，使用多次声明的共同内容。type只能声明一次
inerface只能声明属性类型和方法类型。进行实例化限制，保证通过inerface定义的class实例的一致性和规范性

七、类的属性修饰符

public

属性的默认公共修饰符，可以在类和类的实例任意位置访问

private 属性的私有修饰符，只能在类中访问，实例使用 get 类型方法获取属性，使用set 类型方法设置属性

class Person{
    private name:string;
    private age:number;
    constructor(name:string,age:number){
        this.name=name
        this.age=age
    }
    get age(){
        return this.age
    }
    set age(val:number){
        if(val>=0){
            this.age=val
        }
    }
}
const per=new Person(name:"五柳",age:99)

//设置age
per.age=10

//获取age
per.age

protected

属性的受保护修饰符，当前类和子类可以直接访问属性，实例通过get set 方法访问

class A{
    protected age:number;
    constructor(age:number){
        this.age=age
    }
}
class B extends A{
    test(){
        console.log(this.age)
    }
    get age(){
        return this.age
    }
    set age(val:number){
        if(val>=0){
            this.age=val
        }
    }
}
const show=new B(age:99)

//设置age
show.age=10

//获取age
show.age

八、类属性简便写法

constructor形参使用修饰符，可以不用声明属性

class Person{
    constructor(public name:string,public age:number){
        this.name=name
        this.age=age
    }
}
const per=Person(name:'张',age:111)

typeScript-面向对象的类