如何制作只能通过接口访问的类？

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

我想知道是否有办法阻止开发人员只创建 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 访问，您可以尝试显式接口实现（尽管它有其自身的缺点）：

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 的转换，我猜你必须创建两个单独的具体类来满足。