类的定义

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();