如何在TypeScript中处理重复的相似类型

interface Greeting<T> {
  name: T;
  sayHello(): void;
}

class Person implements Greeting<string> {
  constructor(public name: string) {}
  sayHello() {
    console.log(`Hello, my name is ${this.name}.`);
  }
}

class Animal implements Greeting<string> {
  constructor(public name: string) {}
  sayHello() {
    console.log(`Hello, I'm an animal called ${this.name}.`);
  }
}

const person = new Person("Alice");
person.sayHello(); // Output: Hello, my name is Alice.

const animal = new Animal("Dog");
animal.sayHello(); // Output: Hello, I'm an animal called Dog.

type Greeting = {
  name: string;
  sayHello(): void;
};

type Person = Greeting & {
  age: number;
};

type Animal = Greeting & {
  species: string;
};

const person: Person = {
  name: "Alice",
  age: 25,
  sayHello() {
    console.log(`Hello, my name is ${this.name} and I'm ${this.age} years old.`);
  }
};

const animal: Animal = {
  name: "Dog",
  species: "Canine",
  sayHello() {
    console.log(`Hello, I'm an animal called ${this.name} and I'm a ${this.species}.`);
  }
};

person.sayHello(); // Output: Hello, my name is Alice and I'm 25 years old.
animal.sayHello(); // Output: Hello, I'm an animal called Dog and I'm a Canine.