接口中的构造函数？

Question

我知道在接口中定义构造函数是不可能的。但我想知道为什么，因为我认为它可能非常有用。

因此，您可以确定为该接口的每个实现都定义了类中的某些字段。

例如考虑以下消息类：

public class MyMessage {

   public MyMessage(String receiver) {
      this.receiver = receiver;
   }

   private String receiver;

   public void send() {
      //some implementation for sending the mssage to the receiver
   }
}

如果为这个类定义一个接口，以便我可以有更多的类实现消息接口，我只能定义发送方法而不是构造函数。那么如何确保这个类的每个实现都真正有一个接收器集呢？如果我使用像setReceiver(String receiver) 这样的方法，我不能确定这个方法是否真的被调用了。在构造函数中我可以确保它。

Answer 1

拿一些你描述的东西：

“所以你可以确定一个类中的某些字段是为 这个接口的每个实现。”

"如果为这个类定义一个接口，这样我就可以拥有更多 实现消息接口的类，我只能定义 发送方法而不是构造函数”

...这些要求正是 abstract classes 的用途。

Answer 2

当您在接口中允许构造函数时遇到的一个问题来自于同时实现多个接口的可能性。当一个类实现多个定义不同构造函数的接口时，该类必须实现多个构造函数，每个构造函数只满足一个接口，而不满足其他接口。不可能构造一个调用每个构造函数的对象。

或者在代码中：

interface Named { Named(String name); }
interface HasList { HasList(List list); }

class A implements Named, HasList {

  /** implements Named constructor.
   * This constructor should not be used from outside, 
   * because List parameter is missing
   */
  public A(String name)  { 
    ...
  }

  /** implements HasList constructor.
   * This constructor should not be used from outside, 
   * because String parameter is missing
   */
  public A(List list) {
    ...
  }

  /** This is the constructor that we would actually 
   * need to satisfy both interfaces at the same time
   */ 
  public A(String name, List list) {
    this(name);
    // the next line is illegal; you can only call one other super constructor
    this(list); 
  }
}

Answer 3

接口定义了 API 的契约，即 API 的实现者和用户都同意的一组方法。接口没有实例化实现，因此没有构造函数。

您描述的用例类似于抽象类，其中构造函数调用在子类中实现的抽象方法的方法。

这里的固有问题是，在执行基本构造函数时，子对象尚未构造，因此处于不可预测的状态。

总结一下：从父构造函数调用重载方法是不是自找麻烦，引用mindprod：

一般来说，您必须避免调用任何 构造函数中的非最终方法。 问题是那个实例 初始化器/变量初始化 在派生类中执行 在基础的构造函数之后 类。

Answer 4

您可以尝试的一种解决方法是在您的界面中定义一个getInstance() 方法，以便实现者知道需要处理哪些参数。它不像抽象类那样坚固，但它作为接口提供了更大的灵活性。

但是，此解决方法确实需要您使用getInstance() 来实例化此接口的所有对象。

例如

public interface Module {
    Module getInstance(Receiver receiver);
}

Answer 5

接口中只有静态字段，子类创建对象时不需要初始化，接口的方法必须在子类中提供实际实现，所以接口中不需要构造函数。

第二个原因——子类创建对象的时候调用了父构造函数，但是如果实现的接口不止一个，那么调用接口构造函数的时候就会发生冲突，先调用哪个接口的构造函数

Answer 6

如果你想确保接口的每个实现都包含特定的字段，你只需需要为你的接口添加该字段的 getter：

interface IMyMessage(){
    @NonNull String getReceiver();
}

• 不会破坏封装
• 它会让使用你的接口的每个人都知道Receiver 对象必须以某种方式（通过构造函数或通过setter）传递给类

Answer 7

接口方法中未引用的依赖项应视为实现细节，而不是接口强制执行的内容。当然也有例外，但作为一项规则，您应该将您的界面定义为预期的行为。给定实现的内部状态不应该是接口的设计问题。

Answer 8

这是因为接口不允许在其中定义方法体。但是我们应该在同一个类中定义构造函数，因为接口默认具有抽象修饰符来定义所有方法。这就是为什么我们不能在接口中定义构造函数。

Answer 9

请参阅this question 了解为什么（取自 cmets）。

如果你真的需要做这样的事情，你可能需要一个抽象基类而不是一个接口。

Answer 10

这是使用此技术的示例。在这个特定的示例中，代码使用模拟 MyCompletionListener 调用 Firebase，这是一个被屏蔽为抽象类的接口，一个带有构造函数的接口

private interface Listener {
    void onComplete(databaseError, databaseReference);
}

public abstract class MyCompletionListener implements Listener{
    String id;
    String name;
    public MyCompletionListener(String id, String name) {
        this.id = id;
        this.name = name;
    }
}

private void removeUserPresenceOnCurrentItem() {
    mFirebase.removeValue(child("some_key"), new MyCompletionListener(UUID.randomUUID().toString(), "removeUserPresenceOnCurrentItem") {
        @Override
        public void onComplete(DatabaseError databaseError, DatabaseReference databaseReference) {

        }
    });
    }
}

@Override
public void removeValue(DatabaseReference ref, final MyCompletionListener var1) {
    CompletionListener cListener = new CompletionListener() {
                @Override
                public void onComplete(DatabaseError databaseError, DatabaseReference databaseReference) {
                    if (var1 != null){
                        System.out.println("Im back and my id is: " var1.is + " and my name is: " var1.name);
                        var1.onComplete(databaseError, databaseReference);
                    }
                }
            };
    ref.removeValue(cListener);
}

Answer 11

通常构造函数用于初始化特定类的非静态成员。

接口没有对象创建，因为只有声明的方法，没有定义的方法。为什么我们不能为声明的方法创建对象 is-object 创建只不过是为非静态成员分配一些内存（在堆内存中）。

JVM 将为完全开发并准备使用的成员创建内存。基于这些成员，JVM 计算它们需要多少内存并创建内存。

在声明方法的情况下，JVM 无法计算这些声明方法需要多少内存，因为实现将在未来完成，此时尚未完成。因此接口无法创建对象。

结论：

如果不创建对象，就没有机会通过构造函数初始化非静态成员。这就是为什么接口内部不允许构造函数的原因。（因为接口内部没有使用构造函数）