类:定义是通过class关键字来定义

class Person{
  name:string; //属性 前面省略的public关键字
  constructor(n:string){
    // 构造函数 实例化的时候触发方法
    this.name = n;
  }
  run ():void{
    alert(this.name);
  }
}
var p = new Person('张三');//初始化类
p.run();

声明了一个Person的类,其中有3个成员:一个是name属性,一个构造函数,一个是run方法。可以通过this访问类的成员

继承:通过继承来扩展现有的类(extends\super关键字)

class Person2{
  name:string; //属性 前面省略的public关键字
  constructor(n:string){
    // 构造函数 实例化的时候触发方法
    this.name = n;
  }
  run ():string{
    return `${this.name}在运动`;
  }
}
var p2 = new Person2('张三');
p2.run();//张三在运动

class Web extends Person2{
  constructor(n:string){
    super(n);//初始化父类的构造函数
  }
  work():string {
    return `${name}也在运动`//可重写父级的方法
  }
}
var w = new Web('李四');
w.work();//李四也在运动

Web是Person2超类(基类)的子类(派生类),通过extends关键字实现。子类包含一个构造函数,必须调用super(),它会执行超类的构造函数。在构造函数内访问this前,必须先调用super()。

类中的属性修饰符:public共有、protected保护类型、private私有。默认是公有。

class Person9{
  public name:string;
  protected age:number = 9;
  private sex:string = '男';
  constructor(n:string,a:any = 9){
   this.name = n;
   this.age = a;
  }
  run():string{
    return `${this.name}在运动`
  }
  ageShow():number{
    return this.age;
  }
  sexShow():string{
    return this.sex;
  }
}
class Web9 extends Person9{
  constructor(n:string,a?:any){
    super(n,a);
  }
  run():string{
    return `${this.name}也在运动`
  }
  ageShow():number{
    return this.age+1;
  }
  sexShow():string{
    return this.sex+1;//Property 'sex' is private and only accessible within class 'Person9'.
  }
}
var p9 = new Person9('哈哈哈');//超类
console.log(p9.name);//类外部
console.log(p9.age);//类外部,Property 'age' is protected and only accessible within class 'Person9' and its subclasses
console.log(p9.sex);//类外部Property 'sex' is private and only accessible within class 'Person9'.
console.log(p9.run());//哈哈哈在运动
console.log(p9.ageShow());//9
console.log(p9.sexShow());//男
var W9 = new Web9('肉肉');//子类
console.log(W9.run());//哈哈哈在运动
console.log(W9.ageShow());//10

ts编译后的js是均可打印正确,但在ts文件中会出现报错提示。

public共有(超类/子类/类外部直接属性访问均可)、protected保护类型(超类/子类均可)、private私有(只能在超类里可访问)。默认是公有。

类中的静态方法:通过static关键字实现

// class类中静态方法:static
class Person6{
  public name:string;
  public sex:string='男'
  static age=20;
  constructor(name:string){
    this.name = name;
  }
  static print(){
    alert(this.age);//需用static
    // alert(this.sex);//无法调用类里面的属性
  }
}
Person6.print()//调用静态方法

在静态方法中只能访问通过static定义的属性。并且这个静态方法就属于类本身,调用静态方法通过:类名.静态方法名()。

多态:超类定义一个方法不去实现,让继承他的子类去实现,每个类有不同的表现。多态属于继承。重写和重载是属于多态。

class Animal{
  public name:string;
  constructor(name:string){
    this.name = name;
  }
  eat(){
    console.log('吃的方法')
  }
}

class Dog  extends Animal{
  constructor(name:string){
    super(name);
  }
  eat(){
    return this.name+'吃粮食'
  }
}

抽象类抽象方法

它提供了其他类继承的基类,不被直接被实例化。使用abstract关键字定义抽象类和抽象方法,抽象类中的抽象方法不包含具体实现并且必须在派生类中实现

abstract class Animals{
  public name:string;
  constructor(name:string){
    this.name = name;
  }
  abstract eat():any;
}

class Cat extends Animals{
  constructor(name:string){
    super(name)
  }
  eat(){
    alert(this.name+'吃鱼')
  }
}
var cat = new Cat('猫');
cat.eat();