TypeScript 入门：开启面向对象编程之旅

好的，以下是关于“学习笔记——TypeScript基础语法与面向对象”的文章：

TypeScript 作为 JavaScript 的超集，在 JavaScript 的基础上增加了静态类型检查，这使得 TypeScript 能够在编码时检测到许多错误，从而提高代码的质量和可维护性。

TypeScript 具有与 JavaScript 类似的语法，这使得 JavaScript 开发人员能够轻松地上手 TypeScript。但是，TypeScript 也有一些新的语法特性，例如类型声明、接口和类，这些特性可以帮助开发者编写出更健壮的代码。

类型声明

类型声明是 TypeScript 非常重要的一个特点。通过类型声明，可以指定 TypeScript 中变量（参数、形参）、属性、函数返回值的类型。

变量

在 TypeScript 中，变量的类型可以在变量声明时指定，也可以在变量赋值时指定。例如：

let name: string = "John";
let age: number = 30;

数据类型

TypeScript 支持多种数据类型，包括：

• 基本类型：string、number、boolean、null、undefined、symbol
• 对象类型：数组、对象、类
• 函数类型

函数

在 TypeScript 中，函数可以有参数和返回值类型。例如：

function sum(a: number, b: number): number {
  return a + b;
}

类

TypeScript 中的类与 JavaScript 中的类非常相似。类可以包含属性和方法，并且可以继承其他类。例如：

class Person {
  name: string;
  age: number;

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

  greet() {
    console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`);
  }
}

对象

在 TypeScript 中，对象是一种复合数据类型，可以包含多个属性和方法。例如：

const person = {
  name: "John",
  age: 30,
  greet() {
    console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`);
  }
};

面向对象编程

面向对象编程是一种编程范式，它将数据和行为封装在对象中。面向对象编程的三个基本特征是：

• 封装：封装是指将数据和行为封装在对象中，使得它们对外部不可见。
• 继承：继承是指一个类可以从另一个类继承属性和方法。
• 多态：多态是指同一个方法可以对不同的对象执行不同的操作。

继承

在 TypeScript 中，可以使用 extends 来实现继承。例如：

class Student extends Person {
  studentId: number;

  constructor(name: string, age: number, studentId: number) {
    super(name, age);
    this.studentId = studentId;
  }

  getStudentId() {
    return this.studentId;
  }
}

多态

在 TypeScript 中，多态可以通过方法重写来实现。例如：

class Animal {
  makeSound() {
    console.log("Animal makes a sound.");
  }
}

class Dog extends Animal {
  makeSound() {
    console.log("Dog barks.");
  }
}

class Cat extends Animal {
  makeSound() {
    console.log("Cat meows.");
  }
}

const animal = new Animal();
const dog = new Dog();
const cat = new Cat();

animal.makeSound(); // Animal makes a sound.
dog.makeSound(); // Dog barks.
cat.makeSound(); // Cat meows.

抽象类

抽象类是一种不能被实例化的类。抽象类通常包含一些抽象方法，这些抽象方法必须在子类中实现。例如：

abstract class Shape {
  abstract getArea(): number;
}

class Rectangle extends Shape {
  width: number;
  height: number;

  constructor(width: number, height: number) {
    this.width = width;
    this.height = height;
  }

  getArea(): number {
    return this.width * this.height;
  }
}

class Circle extends Shape {
  radius: number;

  constructor(radius: number) {
    this.radius = radius;
  }

  getArea(): number {
    return Math.PI * this.radius ** 2;
  }
}

const rectangle = new Rectangle(5, 10);
const circle = new Circle(5);

console.log(rectangle.getArea()); // 50
console.log(circle.getArea()); // 78.53981633974483

接口

接口是一种特殊的类型，它定义了一组属性和方法。接口可以被类实现，也可以被对象实现。例如：

interface Person {
  name: string;
  age: number;
  greet(): void;
}

class Student implements Person {
  name: string;
  age: number;
  studentId: number;

  constructor(name: string, age: number, studentId: number) {
    this.name = name;
    this.age = age;
    this.studentId = studentId;
  }

  greet() {
    console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`);
  }
}

const student = new Student("John", 30, 123456);

student.greet(); // Hello, my name is John and I am 30 years old.

TypeScript 是一门非常强大的语言，它可以帮助开发者编写出更健壮、更可维护的代码。如果您是 JavaScript 开发人员，那么强烈建议您学习 TypeScript。