工厂方法设计模式 Typescript

Question

im just learning design pattern and i do not know whats the benefit of abstraction in below code: i rewrite the code and still work the way we want.

you can see the original code from here

class Creator {
  public factoryMethod() {}

  public someOperation(): string {
    const product = this.factoryMethod();
    return `Creator: The same creator's code has just worked with ${product}`;
  }
}

class ConcreteCreator1 extends Creator {
  public factoryMethod(): string {
    return '{Result of the ConcreteProduct1}';
  }
}

class ConcreteCreator2 extends Creator {
  public factoryMethod(): string {
    return '{Result of the ConcreteProduct2}';
  }
}

function clientCode(creator: Creator) {
  console.log(
    "Client: I'm not aware of the creator's class, but it still works."
  );
  console.log(creator.someOperation());
}

console.log('App: Launched with the ConcreteCreator1.');
clientCode(new ConcreteCreator1());
console.log('');

console.log('App: Launched with the ConcreteCreator2.');
clientCode(new ConcreteCreator2());

Answer 1

Comparing your code to the original, you have changed the abstract class Creator into a concrete class Creator . This means that you can now instantiate this class by calling new Creator() .

The problem is that your base Creator class hasn't really implemented the factoryMethod() method. You have made it into a concrete method that does nothing and returns void . When you call clientCode(new Creator()); you get an output which is not what you want:

"Creator: The same creator's code has just worked with undefined"

Why We Use Abstract Classes

abstract class Creator {
    public abstract factoryMethod(): Product;
/* ... */

The original code example uses the abstract class Creator to establish the contract which all concrete creators must fulfill. It says: "in order to be a Creator , you must have a factoryMethod that returns a Product " .

All concrete classes which extend Creator must implement the factoryMethod method. But the base abstract class Creator does not need to implement it.

The missing implementation is not a problem because an abstract class cannot be instantiated. So it's not possible to have a Creator instance which lacks a factoryMethod .