ts学习05-typeScript中的类

类的定义

class Person {
  name: string; //属性  前面省略了public关键词
  constructor(n: string) {
    //构造函数   实例化类的时候触发的方法
    this.name = n;
  }

  run(): void {
    console.log(this.name);
  }
}
var p = new Person("张三");

p.run();

class Person {
  name: string;

  //构造函数   实例化类的时候触发的方法
  constructor(name: string) {
    this.name = name;
  }

  getName(): string {
    return this.name;
  }

  setName(name: string): void {
    this.name = name;
  }
}
var p = new Person("张三");
console.log(p.getName());
p.setName("李四");
console.log(p.getName());

继承

class Person {
  name: string;

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

  run(): string {
    return `${this.name}在运动`;
  }
}
var p=new Person('王五');
console.log(p.run())

class Web extends Person {
  constructor(name: string) {
    super(name); /*初始化父类的构造函数*/
  }
}

var w = new Web("李四");
console.log(w.run());

ts中继承的探讨 父类的方法和子类的方法一致

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

  run(): string {
    return `${this.name}在运动`;
  }
}
// var p=new Person('王五');
// alert(p.run())

class Web extends Person {
  constructor(name: string) {
    super(name); /*初始化父类的构造函数*/
  }
  run(): string {
    return `${this.name}在运动-子类`;
  }
  work() {
    alert(`${this.name}在工作`);
  }
}

var w = new Web("李四");
// alert(w.run());
// w.work();
console.log(w.run());

类里面的修饰符

• public :公有 在当前类里面、 子类 、类外面都可以访问
• protected：保护类型 在当前类里面、子类里面可以访问 ，在类外部没法访问
• private ：私有 在当前类里面可以访问，子类、类外部都没法访问

> 属性如果不加修饰符 默认就是 公有 （public）

public

在类里面、 子类 、类外面都可以访问

class Person {
  public name: string; /*公有属性*/
  constructor(name: string) {
    this.name = name;
  }

  run(): string {
    //内部访问
    return `${this.name}在运动`;
  }
}
class Student extends Person{
  constructor(name:string){
    super(name)
  }
}
var p = new Person("哈哈哈");
// 内部访问
console.log(p.run());
// 类外部访问公有属性;
console.log(p.name);
var s = new Student('里斯')
// 子类内部访问
console.log(s.run());
// 子类外部访问公有属性;
console.log(s.name);

protected

在类里面、子类里面可以访问 ，在类外部没法访问

class Person {
  protected name: string; /*公有属性*/
  constructor(name: string) {
    this.name = name;
  }

  run(): string {
    //内部访问
    return `${this.name}在运动`;
  }
}
class Student extends Person {
  constructor(name: string) {
    super(name);
  }
  run(): string {
    //内部访问
    return `${this.name}在运动`;
  }
}
var p = new Person("哈哈哈");
// 内部访问
console.log(p.run());
// 类外部访问公有属性;
console.log(p.name);
var s = new Student("里斯");
// 子类内部访问
console.log(s.run());
// 子类外部访问公有属性;
console.log(s.name);

private

在类里面可以访问，子类、类外部都没法访问

class Person {
  private name: string; /*公有属性*/
  constructor(name: string) {
    this.name = name;
  }

  run(): string {
    //内部访问
    return `${this.name}在运动`;
  }
}
class Student extends Person {
  constructor(name: string) {
    super(name);
  }
  run(): string {
    //内部访问
    return `${this.name}在运动`;
  }
}
var p = new Person("哈哈哈");
// 内部访问
console.log(p.run());
// 类外部访问公有属性;
console.log(p.name);
var s = new Student("里斯");
// 子类内部访问
console.log(s.run());
// 子类外部访问公有属性;
console.log(s.name);

静态属性 静态方法

class Per {
  public name: string;
  public age: number = 20;
  //静态属性
  static sex = "男";
  constructor(name: string) {
    this.name = name;
  }
  run() {
    /*实例方法*/

    alert(`${this.name}在运动`);
  }
  work() {
    alert(`${this.name}在工作`);
  }
  static print() {
    /*静态方法  里面没法直接调用类里面的属性*/

    console.log("print方法" + Per.sex);
  }
}

// var p=new Per('张三');

// p.run();

Per.print();

console.log(Per.sex);

多态

class Animal {
  name: string;
  constructor(name: string) {
    this.name = name;
  }
  eat() {
    //具体吃什么  不知道   ，  具体吃什么?继承它的子类去实现 ，每一个子类的表现不一样
    console.log("吃的方法");
  }
}

class Dog extends Animal {
  constructor(name: string) {
    super(name);
  }
  //覆盖父类方法
  eat() {
    return this.name + "吃粮食";
  }
}

class Cat extends Animal {
  constructor(name: string) {
    super(name);
  }
  //覆盖父类方法
  eat() {
    return this.name + "吃老鼠";
  }
}

let dog = new Dog("小汪");
console.log(dog.eat());

let cat = new Cat("小嗨");
console.log(cat.eat());

抽象类

typescript中的抽象类：它是提供其他类继承的基类，不能直接被实例化。用abstract关键字定义抽象类和抽象方法，抽象类中的抽象方法不包含具体实现并且必须在派生类中实现。abstract抽象方法只能放在抽象类里面，抽象类和抽象方法用来定义标准 。 标准：Animal 这个类要求它的子类必须包含eat方法。

abstract class Animal {
  public name: string;
  constructor(name: string) {
    this.name = name;
  }
  abstract eat(): any; //抽象方法不包含具体实现并且必须在派生类中实现。

  run() {
    console.log("其他方法可以不实现");
  }
}
// var a=new Animal() /*错误的写法*/
class Dog extends Animal {
  //抽象类的子类必须实现抽象类里面的抽象方法
  constructor(name: any) {
    super(name);
  }
  eat() {
    console.log(this.name + "吃粮食");
  }
}

var d = new Dog("小花花");
d.eat();

class Cat extends Animal {
  //抽象类的子类必须实现抽象类里面的抽象方法
  constructor(name: any) {
    super(name);
  }
  run() {}
  eat() {
    console.log(this.name + "吃老鼠");
  }
}

var c = new Cat("小花猫");
c.eat();