Question

我正面临设计问题。这只能通过应用oops概念来解决。我在描述下面的问题。

问题：假设您有一个名为X的类。它有两个付费（可充电）方法，如m，n。他们可能是这些方法的许多消费者类。某人支付m ，某人支付n 而某人支付m，n 。

现在我必须设计我的X类，消费者只能看到他们付款的方法。我们如何通过OOPS概念来实现这一目标？ 我可以在我的X类中进行适当的更改以实现此设计。样本类写在下面。

class X { // service class

    public m(){ // do some stuff
    }

    public n(){ // do some stuff
    }
}

Answer 1

创建3个接口：一个包含m方法，一个包含n，第三个包含两个（第三个接口可以扩展另外两个）。然后让你的班级X实现这些接口。

然后，您可以根据需要向消费者公开适当的界面，同时仍然使用相同的X类。

interface M { // exposed to customers paying for m
    void m();
}

interface N { // exposed to customers paying for n
    void n();
}

interface Mn extends M, N {} // exposed to customers paying for both

class X implements Mn {

    @Override
    public m(){ // do some stuff
    }

    @Override
    public n(){ // do some stuff
    }
}

Answer 2

您最好使用多态概念

例如，基于m和n具有不同类型的假设：

class X{  // service class

    public Pay(NType n){ // do some stuff
        }
    public Pay(MType m){ // do some stuff
        }
    public Pay(NType n, MType m){ // do some stuff
            Pay(n);
            Pay(m); 
        }
}

Answer 3

我认为你没有利用阶级状态。类可以在其关于用户的实例字段中存储信息，并相应地更改其行为。

一种可能的选择是：

class Payment {

    int paymentType = 0; // fill with constructor for i.e.

    public pay(int sum){
        // some common behavior
        switch(this.paymentType){
           case 1:
              // pay 1 logic
              break;
           case 2:
              // pay 2 logic
              break;  
        }
        // some other common behavior
    }
}

在另一种设计中，您可以使用策略模式来获得一系列解耦算法。

在上面的代码中，我假设我们正在谈论一些逻辑相关的代码。如果代码没有任何共同之处，您甚至可以将其拆分为其他类。

更新：我不建议使用它，但您可以实现模板方法模式。问题是你要过度使用继承。

abstract class Payment {

    public Pay(int sum){
       // some common code
       this.doPay(sum);
    }

    abstract protected doPay(int sum);
}

class PaymentOne : Payment {

    protected doPay(int sum){
        // pay 1 logic
    }
}

class PaymentTwo : Payment {

    protected doPay(int sum){
        // pay 2 logic
    }
}

我怎样才能通过oops概念实现这一目标

3 个答案: