一、基础
// es6 普通的一个类
// 构造函数为实例添加成员，类的所有方法都定义在类的prototype属性，即原型上面。
class Animal {
name
constructor(name, age){
this.name = name
}
move(distance){
console.log(`The speed of ${this.name} is ${distance}m/s`)
}
}
let a = new Animal("Tom")
console.log(a.move(5))
//ts, 成员，参数，函数返回值加上类型检查，实例加上类类型
class Animal { // 声明了类的实例的类型
name: string
constructor(name: string){
this.name = name
}
move(distance: number): void{
console.log(`The speed of ${this.name} is ${distance}m/s`)
}
}
let a: Animal = new Animal("Tom")
console.log(a.move(5))
二、继承
使用extends关键字实现继承。子类中如果有构造方法，必须使用super关键字来调用父类的构造函数
class Animal {
name: string;
age: number;
constructor(name: string, age: number) {
this.name = name
this.age = age
}
move(distance: number): void {
console.log(`The speed of ${this.name} is ${distance}m/s`)
}
}
class Cat extends Animal {
catkind
// 子类有构造函数，必须使用super调用父类构造方法
constructor(name: string, age: number, catkind: string) {
super(name, age)
this.catkind = catkind
}
// 重写move
move(distance: number): void {
console.log("cat walking...");
super.move(distance)
}
}
class Dog extends Animal {
dogkind
constructor(name: string, age: number, dogkind: string) {
super(name, age)
this.dogkind = dogkind
}
move(distance: number): void {
console.log("dog walking...");
super.move(distance)
}
}
let cat1: Cat = new Cat("Tom", 5, "persian")
console.log(`${cat1.name} is ${cat1.age} years old，its kind is ${cat1.catkind} cat`)
console.log(cat1.move(5))
let dog1: Dog = new Dog("jack", 3, "Husky")
console.log(`${dog1.name} is ${dog1.age} years old，its kind is ${dog1.dogkind} dog`)
console.log(dog1.move(10))
三、public private 和 protected
- public：默认所有的成员和方法都是public。修饰的成员和方法是公开的，可以在任何地方被访问到
- private: 修饰的成员和方法是私有的的，只能在声明它的类的内部被访问, 不允许被实例和子类访问
- protected：修饰的成员和方法是受保护的，只能在声明它的类和子类的内部被访问, 不允许被实例访问
// 1. public
class Animal {
public name: string;
public constructor(name: string) {
this.name = name;
}
public move(distance: number): void {
console.log(`The speed of ${this.name} is ${distance}m/s。`)
}
}
let cat1 = new Animal("Tom")
console.log(cat1.name)
console.log(cat1.move(5))
// 2.1 private-成员
class Animal {
private name: string;
public constructor(name: string) {
this.name = name;
}
public move(distance: number): void {
console.log(`The speed of ${this.name} is ${distance}m/s。`)
}
}
let cat1 = new Animal('Tom');
console.log(cat1);
console.log(cat1.name); // error 实例不能访问
console.log(cat1.move(85)); // 类内部可以访问
class Cat extends Animal{
public constructor(name: string){
super(name);
}
public say() {
console.log(`${this.name} say miao~miao~`);
}
}
let cat2 = new Cat('haha');
console.log(cat2.name) // error 在子类的实例中也不能被访问
// 2.2 private-构造函数
// 构造函数修饰为 private 时，该类不允许被继承或者实例化
class Animal {
public name;
private constructor(name) {
this.name = name;
}
}
class Cat extends Animal { // error a. 不能被继承
constructor(name) {
super(name);
}
}
let cat1 = new Animal('Jack'); // error b. 不能被实例化
// 3.1 protected-成员
class Animal {
protected name: string;
public constructor(name: string) {
this.name = name;
}
public move(distance: number): void {
console.log(`The speed of ${this.name} is ${distance}m/s。`)
}
}
let cat1 = new Animal('Tom');
console.log(cat1.move(85)); // 类内部可以访问
console.log(cat1.name); // error 实例不能访问
class Cat extends Animal{
public constructor(name: string){
super(name);
}
public say() {
console.log(`${this.name} say miao~miao~`); // 在子类中可以访问
}
}
let cat2 = new Cat('haha');
console.log(cat2.say())
console.log(cat2.name) // error 在子类的实例中也不能被访问
// 3.2 protected-构造函数
// 构造函数修饰为 protected 时，该类只允许被继承
class Animal {
public name;
protected constructor(name) {
this.name = name;
}
}
class Cat extends Animal {
constructor(name) {
super(name);
}
}
let a = new Animal('Jack'); // error 不能被实例化
四、readonly
使用readonly关键字将成员设置为只读的。 只读成员必须在声明时或构造函数里被初始化。
class Animal {
readonly name: string;
readonly age: number = 18; // 声明时初始化
public constructor(name: string) {
this.name = name; // 构造函数里初始化
}
}
let a = new Animal('Jack');
console.log(a.name); // Jack
a.name = 'Tom'; // error 只读
注意如果readonly和其他访问修饰符同时存在的话，需要写在其后面。
class Animal {
public readonly name: string;
public constructor(name: string) {
this.name = name;
}
}
五、参数属性
一般，我们先声明类的成员和构造函数内赋值。通过参数属性，我们将声明和赋值合并起来。
// 一般
class Animal {
public name: string;
public constructor(name: string) {
this.name = name;
}
}
let a = new Animal('Jack');
console.log(a.name); // Jack
// 参数属性
class Animal {
// public name: string; // 省略
public constructor(public name: string) {
// 参数属性，必须有修饰符 public，protected，private或readonly
// this.name = name; // 可省略
}
}
let a = new Animal('Jack');
console.log(a.name); // Jack
六、存取器
使用 getter 和 setter 可以改变属性的赋值和读取行为。当类成员上定义存取器时，就不能使用正常成员声明
class Animal {
// name: string 成员声明
constructor(name: string) {
this.name = name;
}
get name() { // 存取器
return 'Jack';
}
set name(value) {
console.log('setter: ' + value);
}
}
let a = new Animal('Kitty');
a.name = 'Tom';
console.log(a.name);
七、静态属性
可以通过static定义创建类的静态成员和方法，这些成员和方法存在于类的本身而不是类的实例上。只能通过类名访问，不能被构造函数实例化
class Animal {
static firstWord = "hello";
constructor(public name: string){}
sayHi(){
console.log(Animal.firstWord)
}
static isAnimal(animal: Animal): void {
console.log(animal instanceof Animal);
}
}
let a = new Animal("Tom")
console.log(Animal.firstWord)
Animal.isAnimal(a)
console.log(a.firstWord) // error, 实例不能访问
a.isAnimal(a) // error
a.sayHi()
八、抽象类
abstract用于定义抽象类和其中的抽象方法。顾名思义，抽象类和抽象方法是对对一些对象的属性和行为进行高度抽象，一般不包含具体实现细节，所以基类使用。所以，抽象类是不允许被实例化的。其次，抽象类中的抽象方法必须被子类实现，因为一般不包含实现细节。
abstract class Animal {
name: string;
constructor(name: string) {
this.name = name;
}
abstract move(distance: number): void;
}
class Cat extends Animal {
constructor(name: string) {
super(name)
}
move(distance: number): void { // 必须实现基类的抽象方法
console.log(`The speed of ${this.name} is ${distance}m/s`)
}
}
let a = new Animal('Jack'); // error,不允许实例化
let cat = new Cat('Tom');
cat.move(5)
九、类和接口
一般来讲，一个类只能继承自另一个类，有时候不同类之间可以有一些共有的属性和行为，这时候就可以把这些通用属性和方法提取成接口（interfaces），用implements关键字来实现。
举例，门是一个类，防盗门是它的子类。车也是一个类，车和防盗门都有报警功能，将其提取成一个报警方法。作为一个接口，防盗门和车等都可以实现它。
interface Alarm {
alert(): void;
}
class Door {
}
class SecurityDoor extends Door implements Alarm {
alert() {
console.log('SecurityDoor alert');
}
}
class Car implements Alarm {
alert() {
console.log('Car alert');
}
}
一个类只能继承自一个类，但也可以实现多个接口
interface Alarm { // 报警
alert(): void;
}
interface controlDoor { // 开关门
openDoor(): void;
closeDoor(): void;
}
class Car implements Alarm, controlDoor {
alert() {
console.log('Car alert');
}
openDoor() {
console.log('Car door open');
}
closeDoor() {
console.log('Car door close');
}
}
类定义会创建两个东西：类的实例类型和一个构造函数。 因为类可以创建出类型，所以你能够在允许使用接口的地方使用类。
class Point {
x: number;
y: number;
}
interface Point3d extends Point { // 类可以被当作接口使用
z: number;
}
let point3d: Point3d = {x: 1, y: 2, z: 3};