在軟體開發領域，面向對象程式設計 (OOP) 已成為建立複雜且可擴充應用程式的基本範例。支援 OOP 概念的最流行的程式設計語言之一是 TypeScript。TypeScript 是 JavaScript 的超集，它增加了靜态類型和其他功能以增強代碼的可維護性和可讀性。在這篇部落格中，我們将探讨 TypeScript 中面向對象程式設計的強大功能，以及它如何幫助我們建構健壯且高效的應用程式。

1. 了解面向對象程式設計（OOP）：面向對象程式設計是一種程式設計範式，專注于對象的建立和操作以解決複雜問題。它強調類和對象的概念、封裝、繼承和多态性。這些原則使開發人員能夠構模組化塊化、可重用和可維護的代碼。

2. TypeScript 中的類和對象：在TypeScript 中，類是建立對象的藍圖。它定義了類的對象将具有的屬性和行為。我們可以建立一個類的多個執行個體，這些執行個體稱為對象。對象有自己的狀态（屬性）和行為（方法）。

讓我們以 TypeScript 中的“Person”類為例：

class Person {
  private name: string;
  private age: number;

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

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

// Creating an instance of the Person class
const john = new Person("Kwame", 25);
john.greet(); // Output: Hello, my name is Kwame and I am 25 years old.

複制

在上面的示例中，我們定義了一個名為“Person”的類，它具有私有屬性（name和age）、一個用于初始化這些屬性的構造函數以及一個用于greet()列印問候語的公共方法。然後我們建立該類的一個執行個體并調用該greet()方法。

3. 封裝和通路修飾符：封裝是 OOP 的一個原則，它可以将資料和方法捆綁在一個類中，進而向外界隐藏内部實作細節。在 TypeScript 中，我們可以使用通路修飾符來實作封裝。 TypeScript 中共有三種通路修飾符：

* public：預設修飾符。公共成員可以從任何地方通路。 * private: 私有成員隻能在定義它們的類中通路。 * protected：受保護的成員可以在定義它們的類及其子類中通路。

4. 繼承和多态：繼承允許類從其他類繼承屬性和方法。它促進了代碼重用，并允許我們在現有類的基礎上建立更專業的類。TypeScript 支援單繼承，其中一個類可以從單個基類繼承。

class Animal {
  protected name: string;

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

  public makeSound(): void {
    console.log("Generic animal sound");
  }
}

class Dog extends Animal {
  constructor(name: string) {
    super(name);
  }

  public makeSound(): void {
    console.log("Woof woof!");
  }
}

const myDog = new Dog("Buddy");
myDog.makeSound(); // Output: Woof woof!

複制

在上面的示例中，我們有一個帶有受保護屬性名稱和makeSound()方法的“Animal”類。“Dog”類擴充了“Animal”類并覆寫了makeSound()為狗提供特定聲音的方法。我們建立“Dog”類的一個執行個體并調用該makeSound()方法，該方法輸出“Woof woof!”。

5. 多态性使我們能夠使用單個接口或基類來表示多個相關類。這使我們能夠編寫更靈活和可擴充的代碼。TypeScript 通過繼承和接口支援多态性。

interface Shape {
  calculateArea(): number;
}

class Rectangle implements Shape {
  private width: number;
  private height: number;

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

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

class Circle implements Shape {
  private radius: number;

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

  public calculateArea(): number {
    return Math.PI * Math.pow(this.radius, 2);
  }
}

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

console.log(rectangle.calculateArea()); // Output: 50
console.log(circle.calculateArea());    // Output: 28.274333882308138

複制

在這個例子中，我們定義了一個帶有calculateArea()方法的“Shape”接口。“Rectangle”和“Circle”類實作了這個接口并提供了它們自己的方法實作。我們建立這些類的執行個體并調用calculateArea()計算并傳回相應形狀面積的方法。

6. 抽象： Abstraction是 OOP 中的一個重要概念，它使我們能夠以簡化和通用的方式表示複雜的現實世界實體。它側重于定義對象的基本特征和行為，同時隐藏不必要的細節。在TypeScript中，可以通過抽象類和接口來實作抽象。

抽象類：抽象類是其他類的藍本，不能直接執行個體化。它可能包含抽象方法（沒有實作）和具體方法（有實作）。從抽象類繼承的子類必須提供抽象方法的實作。

abstract class Animal {
  protected name: string;

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

  abstract makeSound(): void;

  public sleep(): void {
    console.log("Zzzz...");
  }
}

class Dog extends Animal {
  constructor(name: string) {
    super(name);
  }

  public makeSound(): void {
    console.log("Woof woof!");
  }
}

const myDog = new Dog("Buddy");
myDog.makeSound(); // Output: Woof woof!
myDog.sleep();     // Output: Zzzz...

複制

在這個例子中，“Animal”類被聲明為抽象類，它有一個抽象方法makeSound()。“Dog”類擴充了“Animal”類并提供了該makeSound()方法的實作。我們建立“Dog”類的執行個體并調用抽象和具體方法。

7. 接口：接口是定義對象的結構和行為的契約。它描述了類必須實作的屬性和方法。接口使我們能夠在 TypeScript 中實作多重繼承行為。

interface Shape {
  calculateArea(): number;
}

interface Color {
  color: string;
}

class Rectangle implements Shape, Color {
  private width: number;
  private height: number;
  public color: string;

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

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

const rectangle: Shape & Color = new Rectangle(5, 10, "blue");
console.log(rectangle.calculateArea()); // Output: 50
console.log(rectangle.color);          // Output: blue

複制

在這個例子中，我們定義了兩個接口，“Shape”和“Color”。“Rectangle”類實作這兩個接口并提供所需的屬性和方法。我們建立“Rectangle”類的執行個體并通路接口定義的方法和屬性。

8.泛型： Generics允許我們建立可以處理各種資料類型的可重用元件。它們通過使我們能夠定義在使用時而不是聲明時确定的類型來提供靈活性和類型安全性。泛型廣泛用于集合、資料結構和算法中。

class Box<T> {
  private value: T;

  constructor(value: T) {
    this.value = value;
  }

  public getValue(): T {
    return this.value;
  }
}

const numberBox = new Box<number>(10);
console.log(numberBox.getValue()); // Output: 10

const stringBox = new Box<string>("Hello");
console.log(stringBox.getValue()); // Output: Hello

複制

在此示例中，我們建立了一個名為“Box”的通用類，它可以儲存任何類型的值。T我們在建立類的執行個體時定義類型參數。該getValue()方法傳回指定類型的存儲值。

9. 通路器（Getters 和 Setters）： TypeScript 支援使用通路器，也稱為 getters 和 setters，以提供對類屬性的受控通路。getter 和 setter 允許我們在檢索或配置設定屬性值時定義自定義邏輯，進而實作更好的封裝和驗證。

class Person {
  private _name: string;

  get name(): string {
    return this._name;
  }

  set name(newName: string) {
    if (newName.length > 0) {
      this._name = newName;
    } else {
      console.log("Name cannot be empty.");
    }
  }
}

const person = new Person();
person.name = "John";
console.log(person.name); // Output: John

person.name = ""; // Output: Name cannot be empty.

複制

在此示例中，我們定義了一個具有私有屬性 _name 的“Person”類。我們定義了一個 gettername()和一個 setter name(newName: string)。setter 驗證新名稱并僅在它不為空時設定該值。我們使用 getter 和 setter 配置設定和檢索名稱屬性。

結論：

面向對象程式設計是建構複雜且可維護的應用程式的強大範例，TypeScript 為 OOP 概念提供了強大的支援。通過類、對象、繼承、封裝、多态、抽象、泛型和通路器，TypeScript 使開發人員能夠編寫子產品化、可重用和類型安全的代碼。通過接受這些 OOP 原則，您可以增強 TypeScript 項目的結構、可維護性和可擴充性。

使用 TypeScript 探索面向對象程式設計

結論：

繼續閱讀

面向對象基本概念面向對象一、基本概念：

面向對象——基本概念

【面向對象】Part 1 基本概念

Day17面向對象作業

day17面向對象基礎面向對象基礎

《手把手陪您學Python》41——類方法與執行個體方法

Objective-C 面向對象基礎-構造方法

如何了解面向對象程式設計思想

對面向對象的了解(轉載原因:舉例簡單明了)

面向對象與面向過程思想的概述

學生管理系統java

Java-接口練習

學生資訊管理系統（IO流）

*學生管理系統java面向對象版本

對象序列化之Boost.Serialization

Python程式可列印今天的年，月和日