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

Question

我对面向对象的设计有疑问。假设我必须为电话实现一个通用的账单评估器。在输入中，我可以使用调用日志(数量和持续时间以秒为单位)，并且我想获取每次调用的价格。

我的想法是使用通用的Call类和抽象的BillEvaluator，对于每个调用，基于抽象函数设置“账单策略”IStragety 。 每个子类(OrangeBill、VodafoneBill 等)都必须根据某些标准(持续时间、数量等)实现账单策略。最后，实际价格由实现 IStragety 的类评估。

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

这是代码(为了简单起见，避免了所有的获取/设置和检查):

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 对我来说似乎是多余的。一种策略适用于多个运营商的可能性似乎很低。因此，如果策略与运算符(operator)存在 1:1 映射，我会删除额外的接口(interface)。
• 您可以使用责任链模式来实现具体的 BillHandler，因为这将允许您摆脱 Call 上的多个 if-else 条件。看this示例。