02.类和对象

目录介绍

• 01.对象类型
  • 1.1 对象字面量
  • 1.2 可选属性
  • 1.3 只读属性
  • 1.4 索引签名
  • 1.5 对象类型别名
  • 1.6 对象解构
  • 1.7 对象高级用法
• 02.interface
  • 2.1 接口介绍
  • 2.2 可选属性
  • 2.3 只读属性
  • 2.4 函数类型
  • 2.5 继承
• 03.类与对象
  • 3.1 类基本语法
  • 3.2 类的成员
  • 3.3 类的继承
  • 3.4 抽象类
  • 3.6 静态成员
  • 3.7 接口与类
  • 3.8 泛型类
  • 3.9 类与对象关系
  • 3.10 接口VS类

01.对象类型

1.1 对象字面量

对象类型的最简单声明方法，就是使用大括号表示对象，在大括号内部声明每个属性和方法的类型。

使用 {} 定义对象，并指定属性类型。

let user: { name: string; age: number } = {
    //属性的类型可以用分号结尾，也可以用逗号结尾。
    name: "Alice",
    age: 25,
};

1.2 可选属性

使用 ? 标记可选属性。

let user: { name: string; age?: number } = {
  name: "Alice",
};

1.3 只读属性

使用 readonly 标记只读属性。

let user: { readonly name: string; age: number } = {
  name: "Alice",
  age: 25,
};

user.name = "Bob"; // 报错：无法修改只读属性

1.4 索引签名

允许对象具有动态属性。

let user: { [key: string]: string | number } = {
  name: "Alice",
  age: 25,
};

user.email = "alice@example.com"; // 合法

1.5 对象类型别名

使用 type 定义对象类型别名。

type User = {
  name: string;
  age: number;
};

let user: User = {
  name: "Alice",
  age: 25,
};

1.6 对象解构

解构赋值用于直接从对象中提取属性。

从对象中提取属性并赋值给变量。

let user = { name: "Alice", age: 25 };
let { name, age } = user;

console.log(name); // Alice
console.log(age); // 25

1.7 对象高级用法

1.对象展开：使用 ... 展开对象。

let user = { name: "Alice", age: 25 };
let updatedUser = { ...user, age: 26 };

console.log(updatedUser); // { name: "Alice", age: 26 }

2.对象合并：使用 Object.assign 合并对象。

let user = { name: "Alice" };
let details = { age: 25 };

let merged = Object.assign({}, user, details);
console.log(merged); // { name: "Alice", age: 25 }

3.对象冻结：使用 Object.freeze 冻结对象，防止修改。

let user = Object.freeze({ name: "Alice", age: 25 });
user.age = 26; // 报错：无法修改冻结对象

02.接口

• 定义：interface 是一种纯粹的类型定义工具，用于描述对象的形状（即对象的结构和属性）。
• 用途：主要用于类型检查，确保对象符合特定的结构。
• 特点： 不能包含实现（如方法的具体逻辑）。可以被类实现（implements），也可以用于定义函数、对象、数组等的类型。

2.1 接口介绍

使用 interface 定义对象的结构。

interface User {
  name: string;
  age: number;
}

let user: User = {
  name: "Alice",
  age: 25,
};

2.2 可选属性

interface User {
  name: string;
  age?: number;
}

2.3 只读属性

interface User {
  readonly name: string;
  age: number;
}

2.4 函数类型

interface User {
  name: string;
  greet(): void;
}

let user: User = {
  name: "Alice",
  greet() {
      console.log(`Hello, ${this.name}`);
  },
};

2.5 继承

接口可以继承其他接口。

interface Person {
  name: string;
}

interface User extends Person {
  age: number;
}

let user: User = {
  name: "Alice",
  age: 25,
};

03.类与对象

TypeScript 中的类和对象是面向对象编程（OOP）的核心概念。

TypeScript 在 JavaScript 类的基础上增加了类型支持，使得类的定义和使用更加安全和灵活。

• 定义：class 是一种面向对象的编程工具，用于创建对象实例。
• 用途：用于封装数据和行为，支持继承、多态等面向对象特性。
• 特点：可以包含属性、方法以及它们的实现。可以创建实例（new 关键字）。

3.1 类基本语法

使用 class 关键字定义类。

class Person {
    name: string;
    age: number;
    constructor(name: string, age: number) {
        this.name = name;
        this.age = age;
    }
    greet(): void {
        console.log(`Hello, my name is ${this.name}`);
    }
}

创建对象，使用 new 关键字创建类的实例。

const person = new Person("Alice", 30);
person.greet(); // "Hello, my name is Alice"

3.2 类的成员

1.属性：类的属性可以定义类型，并支持默认值。

class Person {
    name: string = "Unknown";
    age: number;
}

2.方法：类的方法可以定义参数类型和返回值类型。

class Person {
    greet(message: string): void {
        console.log(message);
    }
}

3.构造函数：构造函数用于初始化对象，参数可以定义类型。

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

4.访问修饰符：TypeScript 提供了三种访问修饰符：

• public：默认值，成员可以在任何地方访问。
• private：成员只能在类内部访问。
• protected：成员可以在类内部和子类中访问。

class Person {
    public name: string;
    private age: number;
    protected gender: string;

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

5.只读属性：使用 readonly 关键字定义只读属性。

class Person {
    readonly id: number;

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

const person = new Person(1);
person.id = 2; // 错误，id 是只读的

3.3 类的继承

1.继承：使用 extends 关键字实现继承。

class Animal {
    name: string;

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

    move(distance: number = 0): void {
        console.log(`${this.name} moved ${distance}m`);
    }
}

class Dog extends Animal {
    bark(): void {
        console.log("Woof! Woof!");
    }
}

const dog = new Dog("Buddy");
dog.move(10); // "Buddy moved 10m"
dog.bark();   // "Woof! Woof!"

2.方法重写：子类可以重写父类的方法。

class Dog extends Animal {
    move(distance: number = 5): void {
        console.log(`${this.name} ran ${distance}m`);
    }
}

3.super关键字：使用 super 调用父类的构造函数或方法。

class Dog extends Animal {
    constructor(name: string) {
        super(name); // 调用父类的构造函数
    }

    move(distance: number = 5): void {
        super.move(distance); // 调用父类的 move 方法
    }
}

3.4 抽象类

使用 abstract 关键字定义抽象类，抽象类不能直接实例化，只能被继承。

abstract class Animal {
    abstract makeSound(): void;

    move(): void {
        console.log("Moving...");
    }
}

派生类必须实现抽象类中的所有抽象方法。

class Dog extends Animal {
    makeSound(): void {
        console.log("Woof! Woof!");
    }
}

const dog = new Dog();
dog.makeSound(); // "Woof! Woof!"
dog.move();      // "Moving..."

3.6 静态成员

使用 static 关键字定义静态成员，静态成员属于类而不是实例。

class MathUtils {
    static PI: number = 3.14;

    static calculateArea(radius: number): number {
        return this.PI * radius * radius;
    }
}

console.log(MathUtils.calculateArea(5)); // 78.5

3.7 接口与类

接口可以用于约束类的结构。

interface PersonInterface {
    name: string;
    greet(): void;
}

class Person implements PersonInterface {
    name: string;

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

    greet(): void {
        console.log(`Hello, my name is ${this.name}`);
    }
}

3.8 泛型类

使用泛型使类适用于多种类型。

class Box<T> {
    private value: T;

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

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

const box = new Box<number>(42);
console.log(box.getValue()); // 42

3.9 类与对象关系

• 类：是对象的模板，定义了对象的属性和方法。
• 对象：是类的实例，具有类定义的属性和方法。

class Car {
    brand: string;

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

    drive(): void {
        console.log(`Driving a ${this.brand}`);
    }
}

const myCar = new Car("Toyota");
myCar.drive(); // "Driving a Toyota"

3.10 接口VS类

特性	interface	class
定义	类型定义	对象模板
实现	不能包含实现	可以包含实现
实例化	不能实例化	可以实例化
继承	支持接口继承	支持类继承
默认值	不能定义默认值	可以定义默认值
静态成员	不能定义静态成员	可以定义静态成员
使用场景	类型检查、定义对象形状	封装数据和行为、创建对象实例

interface使用场景

• 定义对象的形状（如 API 响应、函数参数等）。
• 实现多态性（通过类实现接口）。
• 定义可重用的类型。

class使用场景

• 封装数据和行为。
• 创建对象实例。
• 实现继承和多态。