续写特殊情况-CSDN博客

本文链接：https://blog.csdn.net/ytpedancerow/article/details/143590509

10. 复习类相关知识类

class Person {
// 属性声明
name: string
age: number
// 构造器
constructor(name: string, age: number) {
this.name = name
this.age = age
}
// ⽅法
speak() {
console.log(`我叫：${this.name}，今年${this.age}岁`)
}
}
// Person实例
const p1 = new Person('周杰伦', 38)

Student继承Person

重写父类方法
override // 重写从⽗类继承的⽅法
override speak() {
console.log(我是学⽣，我叫：${this.name}，今年${this.age}岁，在读${this.grade} 年级,)
}

class Student extends Person {
grade: string
// 构造器
constructor(name: string, age: number, grade: string) {
super(name, age)
this.grade = grade
}
// 备注本例中若Student类不需要额外的属性，Student的构造器可以省略
// 重写从⽗类继承的⽅法
override speak() {
console.log(`我是学⽣，我叫：${this.name}，今年${this.age}岁，在读${this.grade}
年级`,)
}
// ⼦类⾃⼰的⽅法
study() {
console.log(`${this.name}正在努⼒学习中......`)
}
}

11. 属性修饰符

修饰符	含义	具体规则
public	公开的	可以被：类内部、⼦类、类外部访问
protected	受保护的	可以被：类内部、⼦类访问
private	私有的	可以被：类内部访问
readonly	只读属性	属性⽆法修改

11.1 public 修饰符

Person 类

class Person {
// name写了public修饰符，age没写修饰符，最终都是public修饰符
public name: string
age: number
constructor(name: string, age: number) {
this.name = name
this.age = age
}
speak() {
// 类的【内部】可以访问public修饰的name和age
console.log(`我叫：${this.name}，今年${this.age}岁`)
}
}
const p1 = new Person('张三', 18)
// 类的【外部】可以访问public修饰的属性
console.log(p1.name)

Student 继承 Person

class Student extends Person {
constructor(name: string, age: number) {
super(name, age)
}
study() {
// 【⼦类中】可以访问⽗类中public修饰的：name属性、age属性
console.log(`${this.age}岁的${this.name}正在努⼒学习`)
}

属性的简写形式
完整写法

class Person {
public name: string;
public age: number;
constructor(name: string, age: number) {
this.name = name;
this.age = age;
}
}

简写形式

class Person {
constructor(
public name: string,
public age: number
) { }
}

11.2 protected 修饰符

class Person {
// name和age是受保护属性，不能在类外部访问，但可以在【类】与【⼦类】中访问
constructor(
protected name: string,
protected age: number
) {}
// getDetails是受保护⽅法，不能在类外部访问，但可以在【类】与【⼦类】中访问
protected getDetails(): string {
// 类中能访问受保护的name和age属性
return `我叫：${this.name}，年龄是：${this.age}`
}
// introduce是公开⽅法，类、⼦类、类外部都能使⽤
introduce() {
// 类中能访问受保护的getDetails⽅法
console.log(this.getDetails());
}
}
const p1 = new Person('杨超越',18)
// 可以在类外部访问introduce
p1.introduce()
// 以下代码均报错
// p1.getDetails()
// p1.name
// p1.age

Student 继承 Person

class Student extends Person {
constructor(name:string,age:number){
super(name,age)
}
study(){
// ⼦类中可以访问introduce
this.introduce()
// ⼦类中可以访问name
console.log(`${this.name}正在努⼒学习`)
}
}
const s1 = new Student('tom',17)
s1.introduce()

11.3 private 修饰符

class Person {
constructor(
public name: string,
public age: number,
// IDCard属性为私有的(private)属性，只能在【类内部】使⽤
private IDCard: string
) { }
private getPrivateInfo(){
// 类内部可以访问私有的(private)属性 —— IDCard
return `身份证号码为：${this.IDCard}`
}
getInfo() {
// 类内部可以访问受保护的(protected)属性 —— name和age
return `我叫: ${this.name}, 今年刚满${this.age}岁`;
}
getFullInfo(){
// 类内部可以访问公开的getInfo⽅法，也可以访问私有的getPrivateInfo⽅法
return this.getInfo() + '，' + this.getPrivateInfo()
}
}
const p1 = new Person('张三',18,'110114198702034432')
console.log(p1.getFullInfo())
console.log(p1.getInfo())
// 以下代码均报错
// p1.name
// p1.age
// p1.IDCard
// p1.getPrivateInfo()

readonly 修饰符

class Car {
constructor(
public readonly vin: string, //⻋辆识别码，为只读属性
public readonly year: number,//出⼚年份，为只读属性
public color: string,
public sound: string
) { }
// 打印⻋辆信息
displayInfo() {
console.log(`
识别码：${this.vin},
出⼚年份：${this.year},
颜⾊：${this.color},
⾳响：${this.sound}
`);
}
}
const car = new Car('1HGCM82633A123456', 2018, '⿊⾊', 'Bose⾳响');
car.displayInfo()
// 以下代码均错误：不能修改 readonly 属性
// car.vin = '897WYE87HA8SGDD8SDGHF';
// car.year = 2020

12. 抽象类

概述：抽象类是⼀种⽆法被实例化的类，专⻔⽤来定义类的结构和⾏为，类中可以写抽象⽅法，也可以写具体实现。抽象类主要⽤来为其派⽣类提供⼀个基础结构，要求其派⽣类必须实现其中的抽象⽅法。
简记：抽象类不能实例化，其意义是可以被继承，抽象类⾥可以有普通⽅法、也可以有抽象⽅法

通过以下场景，理解抽象类：

我们定义⼀个抽象类Package，表示所有包裹的基本结构，任何包裹都有重量属性weight，包裹都需要计算运费。但不同类型的包裹（如：标准速度、特快专递）都有不同的运费计算⽅式，因此⽤于计算运费的calculate⽅法是⼀个抽象⽅法，必须由具体的⼦类来实现。

abstract class Package {
constructor(public weight: number) { }
// 抽象⽅法：⽤来计算运费，不同类型包裹有不同的计算⽅式
abstract calculate(): number
// 通⽤⽅法：打印包裹详情
printPackage() {
console.log(`包裹重量为: ${this.weight}kg，运费为: ${this.calculate()}元`);
}
}

StandardPackage 类继承了 Package ，实现了 calculate ⽅法

// 标准包裹
class StandardPackage extends Package {
constructor(
weight: number,
public unitPrice: number // 每公⽄的固定费率
) { super(weight) }
// 实现抽象⽅法：计算运费
calculate(): number {
return this.weight * this.unitPrice;
}
}
// 创建标准包裹实例
const s1 = new StandardPackage(10,5)
s1.printPackage()

ExpressPackage 类继承了 Package ，实现了 calculate ⽅法：

class ExpressPackage extends Package {
constructor(
weight: number,
private unitPrice: number, // 每公⽄的固定费率（快速包裹更⾼）
private additional: number // 超出10kg以后的附加费
) { super(weight) }
// 实现抽象⽅法：计算运费
calculate(): number {
if(this.weight > 10){
// 超出10kg的部分，每公⽄多收additional对应的价格
return 10 * this.unitPrice + (this.weight - 10) * this.additional
}else {
return this.weight * this.unitPrice;
}
}
}
// 创建特快包裹实例
const e1 = new ExpressPackage(13,8,2)
e1.printPackage()