接口中的构造函数？

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

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

例如，考虑以下消息类：

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
   }
}

如果为该类定义一个接口，以便我可以有更多实现消息接口的类，则只能定义send方法，而不能定义构造函数。那么，如何确保此类的每个实现都确实有一个接收者集？如果我使用类似的方法，setReceiver(String receiver)则不能确定是否真的调用了该方法。在构造函数中，我可以确保这一点。

接受您描述的一些内容：

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

“如果为此类定义一个接口，以便我可以有更多的类来实现消息接口，则只能定义send方法，而不能定义构造函数”

...这些要求正是抽象类的用途。

允许在接口中使用构造函数时遇到的问题是可能同时实现多个接口。当一个类实现多个定义不同构造函数的接口时，该类将必须实现多个构造函数，每个构造函数仅满足一个接口，而不满足其他接口。构造一个调用这些构造函数的对象是不可能的。

或在代码中：

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); 
  }
}

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

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

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

总结一下：当您从父构造函数调用重载方法时，是否会引起麻烦，并引用mindprod：

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

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

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

例如

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

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

第二个原因是在创建子类的对象期间调用了父构造函数。但是，如果实现了多个接口，则在调用接口构造函数期间会发生冲突，即先调用哪个接口的构造函数

如果要确保该接口的每个实现都包含特定字段，则只需在该接口中添加该字段的getter即可：

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

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

接口方法中未引用的依赖项应被视为实现细节，而不是接口强制执行的事情。当然可以有例外，但是通常，您应该将接口定义为预期的行为。给定实现的内部状态不应该是接口的设计问题。

见这个问题的原因（从注释拍摄）。

如果确实需要执行此类操作，则可能需要抽象的基类而不是接口。

这是因为接口不允许在其中定义方法主体，但是我们必须在与接口默认具有抽象修饰符的所有类中定义的构造函数相同的类中定义构造函数。这就是为什么我们不能在接口中定义构造函数的原因。

这是使用该技术的示例。在此特定示例中，代码使用模拟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);
}

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

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

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

对于已声明的方法，JVM无法计算这些已声明的方法所需的内存量，因为将来实现将无法实现。因此无法为接口创建对象。

结论：

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