基本使用

class Person{
    name:string;
}
let p = new Person()
console.log(p)   //Person{}

p的类型就是person

通过new 一个类那么p就是一个对象

构造器

  class Person{
    name:string;
    constructor(name){
        this.name = name
    }
}
let p = new Person('wangcai')
console.log(p.name)   //wangcai
let p1 = new Person('xiaoqiang')
console.log(p1.name)   //xiaoqiang

当new一个类时，会自动调用constructor,把wangcai传入到constructor中的name,this代表当前new这个类的对象,它是不固定的

当new这个类时，那么每一个对象上面都有一个name属性

三个权限

public

代表是公有的，在所有类的类内类外都可以访问到，不写权限的时候，默认都是public

class Animal{
   public name:string;
    constructor(name){
        this.name = name
    }
}
let p = new Animal('pig')
console.log(p.name)

private

私有的，只能在自己类的内部访问到，所以这时候需要使用访问器(公共的方法)，这时候会在所有的类内类外访问

class Animal{
    private _name:string;
     //构造器
     constructor(name){
         this._name = name //只能在自己内部使用
     }
     //访问器
     public get name():string{
         return this._name
     }
     //修改器
     public set name(newName){
         this._name = newName
     }
 }
//  let p = new Animal('pig')
//  console.log(p.name) //会报错 这是在类外 访问不到
let p = new Animal('Pig')
console.log(p.name)
p.name = 'Dog'
console.log(p.name)

访问器通过对象.访问器名字访问到修改器通过对象.修改器名字=新名字进行修改

protected

保护只能在自己和子类的内部访问到

class Animal{
    //构造器
    protected _name:string;
     constructor(name){
         this._name = name  //在自己内部访问到
     }
 }
class Pig extends Animal{
    public get name(){
        return this._name //在子类内部访问到
    }
}
let p = new Pig('wangcai')
console.log(p.name) //通过访问器访问到
let p = new Pig('wangcai')
console.log(p._name) 
//会报错 说_name是保护属性 只能在Animal类及子类中访问到
let a = new Animal('a')
console.log(a._name) 
//会报错 说_name是保护属性 只能在Animal类及子类中访问到

继承

通过extends关键字进行继承父类

class Animal{
    name:string
    // constructor(name){
    //     this.name = name
    // }
}
class Pig extends Animal{
    age:number
    constructor(age){
        super()
        this.age = age
        
    }
}
let p = new Pig(100)
console.log(p.name) //undefined
console.log(p.age) //100

当父类中没有constructor时，在子类中的constructor必须写上super(),

class Animal{
    name:string
    constructor(name){
        this.name = name
    }
}
class Pig extends Animal{
    age:number
    constructor(name,age){
        super(name)
        this.age = age
        
    }
}
let p = new Pig('wangcai',100)
console.log(p.name) //wangcai
console.log(p.age) //100

当父类中有constructor时，在子类的constructor中必须写super(),()里面的个数和父类中constructor中的个数顺序保持一致

在new Pig时会把name传到里面的name,super里面的name会传入到父类的constructor中，当p.name时，它内部没有，会去父类中找

抽象类

在类前面使用abstract关键字，抽象类不能被new,只能被继承，constructor中的值可以被继承到子类中

abstract class Person{
    name:string
    constructor(name){
        this.name = name
    }
}
let p = new Person('xiaoqiang ') //抽象类不能被new

class A extends Person{
    constructor(name){
        super(name)
    }
}
let a = new A('xiaoqiang')
console.log(a.name) //A中没有name 从父类中找

静态属性

使用static关键字它会使用类名.xxx访问

不带static是实例属性会使用对象.xxx访问

class Person{
    name:string;
    static age:number=200
    // constructor(name,age){
    constructor(name){
        this.name = name;
        // this.age = age //不可以使用this.xxx访问
    }
}
let p = new Person('xiaoqiag')
console.log(p.name)
console.log(p.age) //会出错
console.log(Person.age)

静态方法

使用方法和静态属性一致

class Person{
   static eat(){
        console.log('eat...')
    }
}
Person.eat()

ts之类部分