Java 如何确保您的代码遵循可靠的原则？

我对面向对象的设计有疑问。假设我必须为电话实现一个通用的账单计算器。在输入中，我可以使用通话记录（以秒为单位的电话号码和持续时间），并希望获得每次通话的价格

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

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

以下是代码（避免了所有的get/set和简单性检查）：

import java.io.*；
导入java.util.*；
//一般呼叫，带有数字，持续时间（秒）
//和价格（评估）
集体电话{
公共字符串号；
公共时间；
公开双价；
公共呼叫（字符串编号，整数持续时间）{
这个数字=数字；
这个。持续时间=持续时间；
}
公共字符串toString（）{
退货编号+“（“+工期+”）-->“+价格；
}
}
//确定通话价格的策略
界面策略{
无效设置成本（调用）；
}
//通话每秒钟收费3美分
类secondsPrice实现IStrategy{
公共无效设置成本（调用）{
call.price=0.03*call.duration；
}
}
//谈话每分钟收费55美分
//四舍五入分钟值。3:02=>4分钟。
类minutesPrice实现了IST策略{
公共无效设置成本（调用）{
int duration=call.duration；
整数分钟=持续时间/60；
如果（持续时间%60>0）{
分钟=分钟+1；
}
call.price=0.55*分钟；
}
}
//每分钟通话收费1美分。
类低价策略{
公共无效设置成本（调用）{
call.price=0.01*（call.duration/60）；
}
}
//为每个类设置价格的泛型类
//登入日志
抽象类BillHandler{
公共作废评估票据（列表日志）{
用于（调用aCall:log）{
IStrategy s=billStrategy（aCall）；
s、 设定成本（aCall）；
}
}
抽象信息技术战略（Call）；
}
//橙色计费策略的具体实施。
类OrangeBill扩展了BillHandler{
IStrategy billStrategy（呼叫）{
如果（call.duration我可以提出以下建议：


IStrategy
对我来说似乎是多余的。一个策略适用于多个运营商的概率似乎很低。因此，如果有一个1:1的策略到运营商的映射，我会去掉额外的接口
您可以使用责任链模式来实现具体的
BillHandler
s，因为这将允许您摆脱
Call
上的多个if-else条件
这个问题属于另一个网站：@JFPicard有问题的特定代码应该适合这里，但是对于“如何确定…”的总体问题这可能适用于抽象，松散耦合和单一责任是SOLID principle的重要原则。首先你应该关注抽象。@GulMdErshad关于我的示例，你的意思是什么？我使用了抽象类和接口，那么你将如何修改代码？我修改代码以符合模式。现在看起来应该更好了。
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);

    }
}