是否可以限制抽象类仅声明接口中存在的函数

Question

我的用例是我有2个抽象类（subClassA和subClassB），我想限制如果A类有某种方法（funcA），那么B类也必须有（funcA），反之亦然。

interface A() {
public funcA()
}

abstract Class subClassA implements A{
  funcA(){
    print ("declared in interface and defined in subClassA")
  }

  funcB(){           // restrict to create this method as this method is not present in subClass B.
    print ("this function is not defined in interface.")
  }
}

abstract Class subClassB implements A{
  funcA(){
    print ("declared in interface and defined in subClassB")
  }

  funcC(){           // restrict to create this method as this method is not present in subClass A.
    print ("this function is not defined in interface.")
  }
}

Answer 1

可以通过接口来实现。

首先，让我展示一个带有界面的示例：

interface Foo{
    run(arg: any):void; //method
}

class MyFoo implements Task{
    run(arg: any): void {
        console.log(`running: ${this.name}, arg: ${arg}`);
    }
}

如果你想在派生类中删除重复的方法，那么你可以使用抽象类。这意味着所有派生类都将具有抽象类的方法。

正如 TypeScript 文档所述：

抽象类的作用是作为基类 实现所有抽象成员的子类。上课的时候 没有任何抽象成员，它被称为具体的。

还有一个抽象类的例子：

abstract class PersonBase {
  abstract getName(): string;
 
  printName() {
    console.log("Hello, " + this.getName());
  }
}

以及派生类的示例：

class EmployeeDerived extends PersonBase {
  getName() {
    return "world";
  }
}
 
const d = new EmployeeDerived();
d.printName();

更新：

我想限制如果A类有某种方法（funcA），那么B类也必须有（funcA），反之亦然。

您可以使用界面。什么是接口？接口是一种结构，就像应用程序中的合同，或者类遵循的语法。

这意味着如果你通过接口扩展你的类，那么可扩展的类应该实现接口的所有方法。

因此，为了满足您的要求 如果类 A 有某种方法（funcA），那么类 B 也必须有（funcA），反之亦然，我们需要像您一样创建一个接口并扩展所有应该具有所有这些方法的类方法。

JavaScript 没有接口，但 TypeScript 有接口。让我举个例子：

interface A
{
    // run(arg: any):void; //method
    funcA(): void
}

class Foo implements A
{
    // this method `funcA` should be implemented because `Foo` class inherits `A` interface
    funcA = () => {}
}

class Bar implements A
{
    // this method `funcA` should be implemented because `Foo` class inherits `A` interface
    funcA = () => {}
}

限制创建此方法，因为此方法不存在于 A 子类.

无法限制类中方法的创建。在我看来，这不是有用的功能，如果你使用接口，那么这将是这样的限制。我的意思是，当您将对象分配给接口类型的变量时，该变量将显示位于接口中的 onky 方法：

interface AInterface
{
    // run(arg: any):void; //method
    funcA(): void
}

class Foo implements AInterface
{
    // this method `funcA` should be implemented because `Foo` class inherits `A` interface
    funcA = () => {}
}

class Bar implements AInterface
{
    // this method `funcA` should be implemented because `Foo` class inherits `A` interface
    funcA = () => {}
}

并且有一种可用的方法称为

funcA

: