Question

在C＃或Java中，如何创建一个只能通过它实现的接口实例化的类？

很抱歉，如果之前有人问这个问题。

编辑：很抱歉让您感到困惑，这个问题只是出于好奇而被问到：

例如我有：

interface iA
{
  int addNum();
}

interface iB
{
  int minusNum();
}

class A implements iA, iB
{
  private int A;
  public int addNum()
  {
    A += 10;
    return A;
  }

  public int minusNum()
  {
    A -= 10;
    return A;
  }
}

class TestIface
{
  public static void main(String args[]) {
    A testA = new A();
    iA testiA = new A();
    iB testiB = new A();

    testA.minusNum(); // No error, it has access to both methods
    testA.addNum();

    testiA.minusNum();//ERROR
    testiA.addNum();

    testiB.minusNum();
    testiB.addNum();//ERROR
  }
}

我想知道是否有办法阻止dev只是make testA并访问这两种方法。

Answer 1

如何将构造函数设为私有？

class A implements iA
{
  public int returnNum()
  {
    return 10;
  }
  private A(){}

  public static iA getInstance(){
    return new A();
  }

}

Answer 2

您可以将构造函数设为私有，并定义一个创建新实例的静态Create方法。

  public interface ITest
  {
  }
  public class A : ITest
  {
      private A()
      {
      }
      public static ITest Create()
      {
          return new A();
      }
  }

然后创建类实例的唯一方法（除了反射，但这是另一个故事！）是这样调用Create方法：

ITest test = A.Create();

Answer 3

您无法通过界面实例化。您只能将其声明为接口。如果您的目标是只能通过addNum和iA访问minusNum，只能通过iB访问，您可以尝试显式接口实现（尽管它有自己的缺点）：< / p>

class A : iA, iB
{
    private int A;

    int iA.addNum()
    {
        A += 10;
        return A;
    }

    int iB.minusNum()
    {
        A -= 10;
        return A;
    }
}

这至少会为您提供所需的编译时间效果：

class TestIface
{
    public static void main(String args[]) {

        A testA = new A();
        testA.minusNum(); // does not compile
        testA.addNum();   // does not compile

        iA testiA = new A ();
        testiA.minusNum();//does not compile
        testiA.addNum();

        iB testiB = new A ();
        testiB.minusNum();
        testiB.addNum();//does not compile
    }
}

但是，这并不意味着addNum只能通过声明的变量iA来访问。为了说明，你可以这样做：

A testObj = new A ();
(testObj as iA).addNum (); // this will compile

你甚至可以这样做：

iB testObj = new A ();
(testObj as iA).addNum (); // this will also compile, and execute fine

如果你想进一步阻止对具体类的显式强制转换，你需要接受别人提供的建议：使你的具体类成为一个嵌套的私有类，并引入一个工厂来生成实例：

class Factory
{
    private class A : iA, iB
    {
        int iA.addNum () {...}
        int iB.minusNum () {...}
    }

    public iA GetInstanceOfiA () 
    {
        return new A ();
    }

    public iB GetInstanceOfiB () 
    {
        return new A ();
    }
}

这仍然不能阻止从iA到iB的转换，我想你必须创建两个单独的具体类来迎合。

如何创建只能通过接口访问的类？

3 个答案: