前言
类的重要概念
- 实例:
new
可以实例化一个类 - super:继承类中
super
直接调用到父级类 - static:定义静态的属性和方法
- 控制修饰符:
public/protected/provate
等 - get/set :存取器
- implements:类和接口之间的继承所用的关键字
- abstract:抽象类
定义一个类
class class_name {
// 类作用域
// 字段
name: ''
age: ''
// 构造函数
constructor() {
}
// 方法
getName() {
}
}
定义类的关键字为 class,后面紧跟类名,类可以包含以下几个模块(类的数据成员):
- 字段 - 字段是类里面声明的变量,字段表示对象的有关数据
- 构造函数 - 类实例化时调用,可以为类的对象分配内存
- 方法 - 方法为对象要执行的操作
在 TS 中使用类
在 ts
中使用类时,字段
与基础介绍中声明变量
用法一致,构造函数和方法可以看 函数
class Car {
// 字段
engine:string;
// 构造函数
constructor(engine:string) {
this.engine = engine
}
// 方法
disp():void {
console.log("发动机为 : "+this.engine)
}
}
// 创建一个对象
var obj = new Car("XXSY1")
// 访问字段
console.log("读取发动机型号 : "+obj.engine) // 读取发动机型号 : XXSY1
// 访问方法
obj.disp() // 发动机为 : XXSY1
类的继承
TypeScript
支持继承类,即我们可以在创建类的时候继承一个已存在的类,这个已存在的类称为父类,继承它的类称为子类。
类继承使用关键字 extends,子类除了不能继承父类的私有成员(方法和属性)和构造函数,其他的都可以继承。
TypeScript
一次只能继承一个类,不支持继承多个类,但 TypeScript
支持多重继承(A 继承 B,B 继承 C)。
语法
class child_class_name extends parent_class_name
例子
class Shape {
Area:number
constructor(a:number) {
this.Area = a
}
}
class Circle extends Shape {
disp():void {
console.log("圆的面积: "+this.Area)
}
}
var obj = new Circle(223);
obj.disp() // 圆的面积: 223
多重继承
TS 不支持继承多个类,所以可以利用多重继承来实现
class Root {
str:string;
}
class Child extends Root {
age: number
constructor() {
super()
this.age = 18
}
}
class Leaf extends Child {} // 多重继承,继承了 Child 和 Root 类
var obj = new Leaf();
obj.str ="hello"
console.log(obj.str) // hello
console.log(obj.age) // 18
继承类的方法重写
类继承后,子类可以对父类的方法重新定义,这个过程称之为方法的重写。
class PrinterClass {
doPrint():void {
console.log("父类的 doPrint() 方法。")
}
}
class StringPrinter extends PrinterClass {
doPrint():void {
// super 关键字是对父级的直接引用,可以引用父级的属性和方法
super.doPrint() // 调用父类的函数
console.log("子类的 doPrint()方法。")
}
}
let obj = new StringPrinter()
console.log(obj.doPrint());
Static 关键字
static
关键字用于定义类的数据成员(属性和方法)为静态的,静态成员可以直接通过类名调用。
例子
class StaticMem {
static num:number;
static disp():void {
console.log("num 值为 "+ StaticMem.num)
}
}
// 静态属性方法不需要实例化就可以访问
StaticMem.num = 12 // 初始化静态变量
StaticMem.disp() // 调用静态方法
访问控制修饰符
TypeScript
中,可以使用访问控制符来保护对类、变量、方法和构造方法的访问。TypeScript
支持 3 种不同的访问权限。
- public(默认):公有,可以被任何地方被访问
- protected :受保护的,可以被他自身及其字类访问
- private :私有,只有被其定义的类访问
- readonly :只读的,只读属性必须在声明时或构造函数里被初始化。
例子
class Encapsulate {
str1:string = "hello"
private str2:string = "world"
readonly name: string;
constructor(theName: string) {
this.name = theName;
}
}
var obj = new Encapsulate("hello")
console.log(obj.str1) // 可访问
console.log(obj.str2) // 编译错误, str2 是私有的
console.log(obj.name) // 可访问,hello
obj.name = "bye"; // 错误! name 是只读的.
存取器
TypeScript
支持通过getters/setters
来截取对对象成员的访问。 它能帮助你有效的控制对对象成员的访问。
存取器要求你将编译器设置为输出ECMAScript 5
或更高。 不支持降级到ECMAScript 3
。 其次,只带有 get
不带有 set
的存取器自动被推断为 readonly
。
例子
let passcode = "secret passcode";
class Employee {
private _fullName: string;
get fullName(): string {
return this._fullName;
}
set fullName(newName: string) {
if (passcode && passcode == "secret passcode") {
this._fullName = newName;
}
else {
console.log("Error: Unauthorized update of employee!");
}
}
}
let employee = new Employee();
employee.fullName = "Bob Smith";
if (employee.fullName) {
alert(employee.fullName);
}
Employee类中对于 fullName
属性的更改增加了劫持
类和接口
类可以实现接口,使用关键字 implements
,并将 interest
字段作为类的属性使用。
例子
interface ILoan {
interest:number
}
class AgriLoan implements ILoan {
interest:number
rebate:number
constructor(interest:number,rebate:number) {
this.interest = interest
this.rebate = rebate
}
}
var obj = new AgriLoan(10,1)
console.log("利润为 : "+obj.interest+",抽成为 : "+obj.rebate )
抽象类
抽象类做为其它派生类的基类使用。 它们一般不会直接被实例化。 不同于接口,抽象类可以包含成员的实现细节。 abstract
关键字是用于定义抽象类和在抽象类内部定义抽象方法。
abstract class Kitty {
constructor(public name: string) {}
printName(): void {
console.log("kitty name: " + this.name);
}
abstract whoIsKeLuKe(): void; // 必须在派生类中实现
}
class Keluke extends Kitty {
constructor() {
// 在派生类的构造函数中必须调用 super()
// 向kitty传入默认值
super("可鲁可");
}
whoIsKeLuKe(): void {
console.log("可鲁可是一直1岁多的发情公猫");
}
whatBreed(): void {
console.log("蓝白");
}
}
let kitty: Kitty; // 允许创建一个对抽象类型的引用
kitty = new Kitty(); // 错误: 不能创建一个抽象类的实例
kitty = new Keluke();
kitty.printName();
kitty.whoIsKeLuKe();
kitty.whatBreed(); // 错误: 方法在声明的抽象类中不存在
总结:
- 抽象类 允许被引用
- 抽象类 不能被实例化
- 允许对一个抽象字类进行实例化和赋值
- 抽象类中通过关键字abstract声明的方法,必须要在派生类中实现,不可在抽象类中使用