1、ts 中类的定义
class Person {
name: string; // 属性 前面省略了public关键词
constructor(name: string) { // 构造函数 实例化的时候触发的方法
this.name = name
}
getName(): string {
return this.name
}
setName(name: string): void {
this.name = name
}
}
let p = new Person('lilies')
p.setName('88')
console.log(p.getName());2、ts 中实现继承
父类与子类有同样的方法，在调用子类方式时，先找子类的方法
class Person {
name: string
constructor(name: string) {
this.name = name
}
run(): string {
return `${this.name}父类`
}
}
class Web extends Person {
constructor(name: string) {
super(name) // 初始化父类的构造函数
}
run(): string {
return `${this.name}子类`
}
work() {
console.log(`${this.name}工作`);
}
}
let w = new Web('11')
console.log(w.run());
w.work()3、修饰符
typescript 里面定义属性的时候给我们提供了三种修饰符
public（公有）：在类里面、子类、类外面都可以访问
protected（保护类型）： 在类里面、子类里面可以方法，在类外面无法访问
private（私有）：在类里面可以访问，子类与类外面无法访问
属性不加修饰符，默认是公有
class Person {
// public name: string // 公有属性
// protected name: string // 保护类型
private name: string // 私有类型
constructor(name: string) {
this.name = name
}
run(): string {
return `${this.name}父类`
}
}
class Web extends Person {
constructor(name: string) {
super(name) // 初始化父类的构造函数
}
// run(): string {
// return `${this.name}子类`
// }
work() {
console.log(`${this.name}工作`);
}
}
let w = new Web('11')
w.work()
// 类外部访问公有属性
let p = new Person('哈哈哈')
/*
类外部访问公有属性：正常打印哈哈哈
类外部无法访问保护类型、私有类型：可以打印出来哈哈哈，但是语法会报错，之所以可以打印出来是因为浏览器将其转化为es5代码执行
*/
console.log(p.run());
console.log(p.name); // 哈哈哈4、静态方法、属性
// 静态属性 静态方法
function Person() {
this.run1 = function () {
// 实例方法
console.log('实例方法');
}
}
Person.a = '静态属性'
Person.run2 = function () {
// 静态方法
console.log('静态方法');
}
let p = new Person()
Person.run2() // 静态方法的调用ts 静态
class Person {
public name: string
public age: number = 18
static sex = 'x'// 静态属性
constructor(name: string) {
this.name = name
}
run() {
console.log(`${this.name}run`);
}
work() {
console.log(`${this.name}work`);
}
static print() {
// 静态方法无法直接调用类里面的属性
console.log('静态方法' + Person.sex);
}
}
let p = new Person('Person')
p.run()
Person.print()
console.log(Person.sex);5、多态
多态属于继承，父类定义一个方法不去实现，让继承它的子类去实现，每一个子类有不同的表现
class Animal {
name: string
constructor(name: string) {
this.name = name
}
eat() {
// 具体的操作不知道，由继承它的子类去实现，每一个子类的表现不一样
console.log('吃');
}
}
class Dog extends Animal {
constructor(name: string) {
super(name)
}
eat() {
console.log(`${this.name}汪汪`);
}
}
class Cat extends Animal {
constructor(name: string) {
super(name)
}
eat() {
console.log(`${this.name}喵喵`);
}
}
let a = new Cat('猫')
a.eat()
6、抽象类
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}Dog`);
}
}
var d = new Dog('小黄')
d.eat()
class Cat extends Animal {
constructor(name: string) {
super(name)
}
eat() {
console.log(`${this.name}喵喵`);
}
}
var c = new Cat('小猫')
c.eat()
