Question

我对面向对象的设计存有疑问。假设我必须为电话实施通用的账单评估程序。在输入中，我可以使用呼叫记录（数字和持续时间，以秒为单位），我想得到每个呼叫的价格。

我认为使用通用的调用类和抽象的 BillEvaluator ，对于每次调用，根据抽象函数设置“账单策略”IStragety 。每个子类（OrangeBill，VodafoneBill，..）都必须根据某些标准（持续时间，数量......）实施账单策略。最后，实际价格由实现IStragety的类评估。

这是一个很好的解决方案吗？如果我想尝试一个新的PhoneOperator，那么我将不得不创建一个新的BillHandler子类，或者我是否可以创建一个新的IStrategy实现。但如果沃达丰决定添加新的账单策略（例如，超过1小时的通话是免费的），那么我将不得不修改VodafoneBill类...所以我的解决方案不尊重SOLID原则！

这是代码（为了简单起见，避免了所有的get / set和检查）：

import java.io.*;
import java.util.*;
// A generic call, with a number, duration in seconds 
// and a price (to evaluate)
class Call{
    public String number;
    public int duration;
    public double price;

    public Call(String number, int duration){
        this.number = number;
        this.duration = duration;
    }

    public String toString(){
        return number + " (" + duration + ")-->" + price;
    }
}

// Strategy to determine the price of a call
interface IStrategy{

    void setCost(Call call);
}

// Each seconds of the call is charged of 3 cents
class secondsPrice implements IStrategy{

    public void setCost(Call call){
        call.price = 0.03 * call.duration;
    }
}

// each minutes of the conversation is charged 55 cents
// round the minutes value Es. 3:02 => 4 minutes.
class minutesPrice implements IStrategy{

    public void setCost(Call call){
        int duration = call.duration;        
        int minutes = duration / 60;

        if(duration % 60 > 0){
            minutes = minutes + 1;
        }
        call.price = 0.55 * minutes;
    }
}

// each minutes of conversation is charged 1 cents.
class lowPrice implements IStrategy{

    public void setCost(Call call){

        call.price = 0.01 * (call.duration / 60);
    }
}

// Generic class that set the price for each 
// call in the log
abstract class BillHandler{


    public void evaluateBill(List<Call> log){

        for(Call aCall : log){
            IStrategy s = billStrategy(aCall);
            s.setCost(aCall);
        }
    }

    abstract IStrategy billStrategy(Call call);
}

// Concrete implementation of the Orange Billing strategy.
class OrangeBill extends BillHandler{

    IStrategy billStrategy(Call call){

        if(call.duration <= 180){
            return new secondsPrice();
        }
        else{
            return new minutesPrice();
        }
    }
}

class VodafoneBill extends BillHandler{

    IStrategy billStrategy(Call call){

        if(call.number.equals("122")){
            return new lowPrice();
        }
        else if(call.duration < 100){
            return new secondsPrice();
        }
        else{
            return new minutesPrice();
        }
    }
}

class myCode
{



    public static void main (String[] args) throws java.lang.Exception
    {
        myCode c = new myCode();

        List<Call> log = new ArrayList<>();
        log.add(new Call("122", 180));
        log.add(new Call("114", 179));
        log.add(new Call("122", 200));
        log.add(new Call("411", 54));

        System.out.println(log);

        BillHandler bill = new OrangeBill();
        bill.evaluateBill(log);

        System.out.println("OrangeBill:");
        System.out.println(log);

        bill = new VodafoneBill();
        bill.evaluateBill(log);

        System.out.println("VodafoneBill:");
        System.out.println(log);

    }
}

修改

使用责任链模式

进行可能的实施

import java.io.*;
import java.util.*;

// A generic call, with a number, duration in seconds 
// and a price (to evaluate)
class Call{
    public String number;
    public int duration;
    public double price;

    public Call(String number, int duration){
        this.number = number;
        this.duration = duration;
    }

    public String toString(){
        return number + " (" + duration + ")-->" + price;
    }
}

// Interface implemented by different Provider
interface BillHandler{    

    void priceCall(Call call);
}

//Orange provider
class OrangeBill implements BillHandler{

    private callHandler secondsH = new orangeSecondsHandler();
    private callHandler minutesH = new orangeMinutesHandler();
    private callHandler commondH = new commonFareHandler();

    public void priceCall(Call call){
        secondsH.processCall(call);
    }

    OrangeBill(){
        secondsH.setSuccessor(minutesH);
        minutesH.setSuccessor(commondH);
    }
}
// Vodafone provider
class VodafoneBill implements BillHandler{

    private callHandler secondsH = new vodafoneSecondsHandler();
    private callHandler minutesH = new vodafoneMinutesHandler();
    private callHandler lowCallH = new vodafoneLowCallHandler();
    private callHandler commondH = new commonFareHandler();

    public void priceCall(Call call){
        secondsH.processCall(call);
    }

    VodafoneBill(){
        lowCallH.setSuccessor(secondsH);
        secondsH.setSuccessor(minutesH);
        minutesH.setSuccessor(commondH);
    }
}

// Generic call handler
abstract class callHandler{

    public callHandler next;

    public void setSuccessor(callHandler next){
        this.next = next;
    }

    abstract public boolean isChargable(Call call);
    abstract public void priceCall(Call call);

    public void processCall(Call call){
        if(isChargable(call)){
            priceCall(call);
        }
        else{
            next.processCall(call);
        }
    }
}

// Concrete implementations of different call handler based
// on its provider policy

// Each seconds of the call is charged of 3 cents
class orangeSecondsHandler extends callHandler{

    public boolean isChargable(Call call){
        return call.duration <= 180;
    }

    public void priceCall(Call call){
        call.price = 0.03 * call.duration;
    }
}

// each minutes of the conversation is charged 55 cents
// round the minutes value Es. 3:02 => 4 minutes.
class orangeMinutesHandler extends callHandler{

    public boolean isChargable(Call call){
        return call.duration <= 180;
    }
    public void priceCall(Call call){
        int duration = call.duration;        
        int minutes = duration / 60;

        if(duration % 60 > 0){
            minutes = minutes + 1;
        }
        call.price = 0.55 * minutes;
    }
}

// Each seconds of the call is charged of 5 cents
class vodafoneSecondsHandler extends callHandler{

    public boolean isChargable(Call call){
        return call.duration <= 100;
    }

    public void priceCall(Call call){
        call.price = 0.05 * call.duration;
    }
}

// each minutes of the conversation is charged 30 cents
// round the minutes value Es. 3:02 => 4 minutes.
class vodafoneMinutesHandler extends callHandler{

    public boolean isChargable(Call call){
        return call.duration <= 250;
    }
    public void priceCall(Call call){
        int duration = call.duration;        
        int minutes = duration / 60;

        if(duration % 60 > 0){
            minutes = minutes + 1;
        }
        call.price = 0.30 * minutes;
    }
}

// Call to selected number are charged by 0.02 cents
// for every minute, without round!
class vodafoneLowCallHandler extends callHandler{

    public boolean isChargable(Call call){
        return call.number.equals("122");
    }
    public void priceCall(Call call){
        int duration = call.duration;        
        int minutes = duration / 60;

        call.price = 0.02 * minutes;
    }
}

class commonFareHandler extends callHandler{
    public boolean isChargable(Call call){
        return true;
    }
    public void priceCall(Call call){       
        call.price = 1 * call.duration;
    }
}



class myCode
{   
    public static void main (String[] args) throws java.lang.Exception
    {
        myCode c = new myCode();

        List<Call> log = new ArrayList<>();
        log.add(new Call("122", 180));
        log.add(new Call("114", 179));
        log.add(new Call("122", 200));
        log.add(new Call("411", 54));

        System.out.println(log);

        // Evaluate the bill with Orange
        BillHandler bill = new OrangeBill();
        for(Call call : log)
            bill.priceCall(call);

        System.out.println("OrangeBill:");
        System.out.println(log);

        // Evaluate the bill with Vodafone
        bill = new VodafoneBill();
        for(Call call : log)
            bill.priceCall(call);

        System.out.println("VodafoneBill:");
        System.out.println(log);

    }
}

Answer 1

我可以提出以下建议：

IStrategy对我来说似乎多余。一种策略适用于多个运营商的概率似乎很低。因此，如果策略与运营商之间存在1：1的映射，我会删除额外的接口。
您可以使用“责任链”模式来实现具体的BillHandler，因为这样可以让您摆脱Call上的多个if-else条件。请看this示例。

如何确保您的代码遵循SOLID原则？

修改

1 个答案: