Oop 使用接口进行数据隐藏

我有一个接口I和两个方法func A和func B，还有一个类C和接口的实现，我有两个用户U1和U2。 我想要的功能是，如果u1访问类C，则应调用func A，如果u2访问类C，则应调用func B。

---

如何使用OOPs实现这一点？

我将重点介绍您提出的问题。为什么要这样做，以及这是否是一个关于OO设计原则的好主意是另一个问题

首先，您的要求类似于以下内容：（注意）

现在，让我们为用户1和用户2创建一个

User

角色和两个实现：

public interface User
{
    void Access(I x);
}

class User1 : User
{
    public void Access(I x)  {  x.A();  }
}

class User2 : User
{
    public void Access(I x)  {  x.B();  }
}

最后，将用户1和2实例化如下：

User u1 = new User1();
User u2 = new User2();

I c = new C();
u1.Access(c);    // will call c.A()
u2.Access(c);    // will call c.B()

和“访问”您的C，如下所示：

User u1 = new User1();
User u2 = new User2();

I c = new C();
u1.Access(c);    // will call c.A()
u2.Access(c);    // will call c.B()

请注意，此代码几乎完全将类

C

排除在游戏之外，而是将重点放在接口上（

I

）。但是，如果您希望您的代码专门使用

C

，只需在适当的位置（即使用方法

Access

的参数）将

I

替换为

C

---

---

（注意：）我选择C#作为示例，但翻译成您选择的语言应该很容易。

我将重点讨论您提出的问题。为什么要这样做，以及这是否是一个关于OO设计原则的好主意是另一个问题

首先，您的要求类似于以下内容：（注意）

现在，让我们为用户1和用户2创建一个

User

角色和两个实现：

public interface User
{
    void Access(I x);
}

class User1 : User
{
    public void Access(I x)  {  x.A();  }
}

class User2 : User
{
    public void Access(I x)  {  x.B();  }
}

最后，将用户1和2实例化如下：

User u1 = new User1();
User u2 = new User2();

I c = new C();
u1.Access(c);    // will call c.A()
u2.Access(c);    // will call c.B()

和“访问”您的C，如下所示：

User u1 = new User1();
User u2 = new User2();

I c = new C();
u1.Access(c);    // will call c.A()
u2.Access(c);    // will call c.B()

请注意，此代码几乎完全将类

C

排除在游戏之外，而是将重点放在接口上（

I

）。但是，如果您希望您的代码专门使用

C

，只需在适当的位置（即使用方法

Access

的参数）将

I

替换为

C

---

---

（注意：）我选择C#作为示例，但是翻译成您选择的语言应该很容易。

确定您想要做什么肯定需要更多的澄清，但是

而不是将逻辑放在用户类中，像OO一样思考，可能是工厂，比如：

abstract class C : I
{
  public void A() { }
  public void B() { }
  public abstract void CallMethod();
}

class C1 : C
{
  public override void CallMethod() { A(); }
}

class C2 : C
{
  public override void CallMethod() { B(); }
}

static class Factory
{
  public static I GetI(User user) 
  {
    // This is where your if blocks will go, 
    // and it will return either a new C1 or a new C2
  }
}

这样做的好处是允许用户保持简单，其中没有业务代码。工厂只需要足够聪明，就可以知道它要根据用户创建哪个C。调用real方法的所有实际工作都是在C本身中完成的

---

编辑：您可能需要稍微修改一下接口和C类-在这种情况下，您需要在接口中使用CallMethod（）方法。或者你的工厂可能会返回C而不是I。当然，在不知道全部情况的情况下，很难说哪个是正确的。

确实需要更多的澄清来确定你想要做什么，但是

而不是将逻辑放在用户类中，像OO一样思考，可能是工厂，比如：

abstract class C : I
{
  public void A() { }
  public void B() { }
  public abstract void CallMethod();
}

class C1 : C
{
  public override void CallMethod() { A(); }
}

class C2 : C
{
  public override void CallMethod() { B(); }
}

static class Factory
{
  public static I GetI(User user) 
  {
    // This is where your if blocks will go, 
    // and it will return either a new C1 or a new C2
  }
}

这样做的好处是允许用户保持简单，其中没有业务代码。工厂只需要足够聪明，就可以知道它要根据用户创建哪个C。调用real方法的所有实际工作都是在C本身中完成的

编辑：您可能需要稍微修改一下接口和C类-在这种情况下，您需要在接口中使用CallMethod（）方法。或者您的工厂可以返回C而不是I。当然，在不了解全部情况的情况下，很难说哪个是正确的。

我认为您真正想要的是：

只有一种方法的接口I

两个类以不同的方式实现它：func A和func B

将用户作为参数的接口的工厂

例子 比如说：

U1是巴尼，U2是弗雷德

func A正在打印“我爱你Betty”

func B正在打印“我的俱乐部Wilma在哪里？！”

接口引号是使用方法emitQuote（）定义的

类C和D将分别用A和B实现I

定义工厂（工厂类或工厂方法无关紧要）并将用户开关放在那里

通过这种方式，您可以调用：

Quote q = myFactory.getQuoteFor(u);
q.emitQuote();

这是纯面向对象的，我认为以TDD方式编写非常简单。

我认为您真正想要的是：

只有一种方法的接口I

两个类以不同的方式实现它：func A和func B

将用户作为参数的接口的工厂

例子 比如说：

U1是巴尼，U2是弗雷德

func A正在打印“我爱你Betty”

func B正在打印“我的俱乐部Wilma在哪里？！”

接口引号是使用方法emitQuote（）定义的

类C和D将分别用A和B实现I

定义工厂（工厂类或工厂方法无关紧要）并将用户开关放在那里

通过这种方式，您可以调用：

Quote q = myFactory.getQuoteFor(u);
q.emitQuote();

---

这是纯面向对象的，我认为用TDD方式编写非常简单。

你想要这个功能，为什么确切？你想要这个功能，为什么确切？