概述

类(Class)：定义了一切事物的抽象特点
对象(Object)：类的实例
面向对象(OOP)三大特性：封装继承多态

类的定义

// 定义类
class Person {// 公共属性，默认可以不写public name: string// 构造函数constructor(name: string) {// 初始化name属性this.name = name}
}
// 实例化类
const person = new Person('zs')
console.log(person.name) // zs

类的继承

在面向对象的编程语言中，有一个重要得特征就是继承。继承就是基于某个类来扩展现有的类。

例如，爸爸在北京有一个四合院，儿子可以继承爸爸的四合院，而且还可以自己去买一栋别墅；最终儿子的房产拥有北京的四合院和一栋别墅。

TypeScript中类的继承需要通过extends来配合super来实现。子类若要继承父类的属性和方法需要执行一次super()，它代表实例化父类的构造函数，super() 只能用在子类的构造函数之中，用在其他地方就会报错。

// 定义一个基类，又称超类
class Father {// 在基类中定义一个name属性public name: stringconstructor(name: string) {this.name = name}
}
// 定义一个派生类，又称子类，继承于基类
class Son extends Father {constructor(name: string, public age: number) {// 通过 super 调用基类的构造函数super(name)}getInfo(): void {console.log(this.name); //ZSconsole.log(this.age); //18}}
const a = new Son('ZS', 18)
a.getInfo()

类的静态方法和属性

静态属性和静态方法属于类自身，而不属于实例，访问的时候要用类名访问，而不能用实例对象访问。在 TS中定义静态成员与ES6中一样，都是使用static关键字来说明。

class Hero {static count = 0constructor(public name: string) {// 每创建一个属性 count ++++Hero.count}
}
const hero1 = new Hero('孙悟空')
console.log(Hero.count) // 1
const hero2 = new Hero('哪吒')
console.log(Hero.count) // 2
// console.log(hero1.count);不能访问静态成员count

类里面的修饰符

TypeScript定义属性的时候给我们提供了三种修饰符：

public：公有属性，在当前类里面、子类、类外面都可以访问。属性如果不加修饰符默认就public。
protected：保护类型，在当前类里面、子类里面可以访问，在类外部没法访问。
private：私有属性，在当前类里面可以访问，子类、类外部都没法访问。

class Person {public name: string// 约定 私有成员一般采用 _ 开头private _age: numberprotected hobby: string// 属性初始化constructor(name: string, age: number, hobby: string) {this.name = namethis._age = agethis.hobby = hobby}sayMy() {console.log(this.name, this._age, this.hobby)}
}// 实例化 Person 类
const person = new Person('zs', 18, 'coding')
console.log(person.name) // zs
// console.log(person._age) // 报错 类外访问私有成员 抛出异常
//  console.log(person.hobby) // 报错  类外访问保护成员 抛出异常
person.sayMy() // zs 18 coding,private 成员和 protected 成员可以在类内访问// 定义一个类继承与 Person 类
class Programmer extends Person {constructor(name: string, age: number, hobby: string) {super(name, age, hobby)}sayMy() {console.log(this.name) // zs// console.log(this._age) // 报错 在子类不可以访问父类的私有成员// console.log(this.hobby) // coding 在子类不可以访问父类的私有成员}
}// 实例化 Programmer 类
const programmer = new Programmer('zs', 18, 'coding')
programmer.sayMy()

抽象类

概念

想要理解什么是抽象类，就需要先理解什么是抽象，所谓的抽象就是从众多的事物中抽取出共同的、本质性的特征，而舍弃其非本质的特征。例如苹果、香蕉、生梨、葡萄、桃子等，它们共同的特性就是水果。得出水果概念的过程，就是一个抽象的过程。
抽象类就是将众多类中具有共同部分的功能抽离出来，单独创建一个类作为其他派生类的基类使用。他们不允许被实例化，定义抽象类使用abstract关键字。
抽象方法就是只有方法的定义，没有方法体，方法体需要在子类中进行实现。

// 通过 abstract 关键字 定义一个抽象类，该类不必进行初始化，仅作为基类使用
abstract class Department {// 初始化name成员，参数属性constructor(public name: string) { }printName(): void {console.log('部门名称: ' + this.name)}// 抽象方法必须包含 abstract 关键字abstract printMeeting(): void // 必须在派生类中实现
}class AccountingDepartment extends Department {constructor() {super('会计部') // 在派生类的构造函数中必须调用super()}printMeeting(): void {console.log('会计部是负责管钱的部门')}
}// const department = new Department() // 抛出异常：不能创建一个抽象类的实例
// 实例化抽象子类
const department = new AccountingDepartment()
// 调用抽象类中的方法
department.printName() // 部门名称: 会计部
// 调用在派生类实现的抽象方法
department.printMeeting() // 会计部是负责管钱的部门

多态

多态属于继承，是继承的一种延续，在父类内部有一个公用方法，但是不知道具体做什么，由多个子类继承同一个方法，实现不同效果，这个公用方法也叫方法的重写


class Animall {name: string;constructor(name: string) {this.name = name}eat(): void {console.log('我们都可以吃');}
}class Dog extends Animall {constructor(name: string) {super(name)}eat(): void {console.log(`${this.name}吃骨头`)}
}class Cat extends Animall {constructor(name: string) {super(name)}eat(): void {console.log(`${this.name}吃老鼠`)}
}let dog = new Dog('小黄')
dog.eat()

getters与setters

类中的私有成员和保护成员我们并不是真的不能读写，在TS中提供了getters与setters帮助我们有效的控制对对象成员的访问。

// 定义一个 Person 类
class Person {// 约定 私有成员一般采用 _ 开头private _name: string// 属性初始化constructor(name: string) {this._name = name}// 获取 私有的 _name 属性值get getName(): string {return this._name}// 设置 私有的 _name 属性值set setName(name: string) {this._name = name}
}
// 实例化类
const person = new Person('zs')
console.log(person.getName) // zs 通过 getName 的方式获取
person.setName = 'ls'//通过 setName 的方式设置 _name 的值
console.log(person.getName) // // 重新获取 ls

readonly修饰符

我们可以通过 readonly修饰符将一个属性设置为只读的。只读属性必须在声明时或者在构造函数中进行初始化。

// 定义一个类，且具有一个只读属性
class Person {// readonly name: string// 等同于// public readonly name: string// constructor(name: string) {//     this.name = name// }// 或者constructor(public readonly name: string) { }
}
// 实例化
const person = new Person('zs')
console.log(person.name) // zs
// 修改name的值
// person.name = 'ls' // 错误! name 是只读的.

TS复习-----TS中的类相关推荐

TS复习----TS中的接口
目录概念属性接口函数类型接口可索引的类型类类型接口接口继承概念接口的作用:在面向对象编程中,接口是一种规范的定义,他定义了行为和动作的规范,在程序设计里面,接口起到了一种限制和规范的作 ...
TS复习-----TS中的函数
目录一.ts函数的定义二.ts中定义函数传参 1.函数传参方法 2.可选参数 3.默认参数 4.剩余参数函数重载一.ts函数的定义函数是一种特殊的对象,可以被调用.TS 里的函数和原生,ES ...
3.JAVA基础复习——JAVA中的类与对象
什么是对象: 就是现实中真实的实体,对象与实体是一一对应的,现实中每一个实体都是一个对象在. JAVA中的对象: Java中通过new关键字来创建对象. 类: 用JAVA语言对现实生活中的事物进行描述 ...
【TypeScript 专题】之 Ts 中的类（class）
在 ES6 中,class (类)作为对象的模板被引入,可以通过 class 关键字定义类.它本质仍然是函数,它让对象原型的写法更加清晰.更像面向对象编程的语法. 在 TypeScript 中,除了实 ...
TS学习(八) :TS中的类
TS中类的书写以前在js中书写类是这样的,然后我们在加上TS的类型检查你会发现报错了 class User {constructor(name:string,age:number) {this.na ...
C++中的类所占内存空间总结
C++中的类所占内存空间总结最近在复习c++的一些基础,感觉这篇文章很不错,转载来,大家看看! 类所占内存的大小是由成员变量(静态变量除外)决定的,成员函数(这是笼统的说,后面会细说)是不计算在内的 ...
考研计算机专业课复习,考研中计算机专业课的复习考试.pdf
考研中计算机专业课的复习考试.pdf 第20卷第1期西昌学院学报·自然科学版 VoL20-№1 of ScienceEdition Mar．．2006 2006年3月 Joumal College' ...
TS学习(二) :安装ts与ts配置
一.安装TypeScript npm i -g typescript 二.安装完成后创建ts 使用ts语法可能遇到的报错问题在啥都没配置的默认情况下,TS会做出下面几种假设: 假设当前的执行环境 ...
python基础语法复习[二] 函数、类
python基础语法复习[二] 前言一.函数 1.基本概念 2.一般实例 3.参数传递 (1)传不可变对象 (2)传可变对象 4.函数递归调用实例 (1)eg:实现字符串的反转: (2)递归思想画树 ...

TS复习-----TS中的类

概述