如何通过从继承到组合来简化java代码

我编写了多级继承类的底层类，但不知道如何将它们组合到单个程序中。有人建议我使用组合而不是继承，有人建议使用

enum

创建匿名子类而不是复杂的继承结构。我们如何使用组合来代替继承，或者使用

enum

来代替我使用的继承？我应该做些什么来简化问题？应该如何做

我正在使用Java编写一个计算税收的代码。我有一个基本类

纳税人
。纳税人可以有多个
收入来源
。可以有多种类型的
纳税人
或
收入来源
。每个收入来源可以有许多收入标题，用于计算
应纳税收入
<对于不同类型的
纳税人
和
应纳税所得额
，code>税率将有所不同。最终结果将
税率
应用于
可征税收入

基类纳税人定义为

public abstract class TaxPayer {
    private List<IncomeSource> incomeSource;
    double taxRate;
    Address address;
    other attributes here;

    public Double getTaxRate(){
        return 0.25; //default tax rate
     }
}

public abstract class IncomeSource {
    private String incomeSourceName;
    private Double incomeHeading1, incomeHeading2, incomeHeading3, ...;
    private Double taxableIncome = incomeHeading1 + incomeHeading2 - incomeHeading3;
}

纳税人
的子类通常修改要应用于
应纳税所得额
的
税率
，有时通过某种逻辑更改
应纳税所得额
。例如：

abstract class IndividualPerson extends TaxPayer{
    if (incomeSource.taxableIncome > 250000) taxRate = ratex;
    if (incomeSource.taxableIncome > 500000) taxRate = ratey;
    @override
    public getTaxRate() {
        return taxRate;
    }
}
class Female extends IndividualPerson {
    if (incomeSource.getNumberOfIncomeSource() > 1) taxRate = taxRate + rate1;
    else taxRate = taxRate - rate2
    if (address.isRural() = true) taxRate = taxRate - rate3;
    if (attributeX = true) taxRate = taxRate + rate4;
    if ("Some other attribute" = true) taxableIncome = taxableIncome - someAmount;
}

我们必须检查
纳税人
和
收入来源
的属性，以确定
税率
。有时，
应纳税所得额
可以根据
纳税人
类型和其他条件进行修改

我对如何将底层类组合在一起以生成可用代码感到困惑。有人建议我不要使用复杂的多级继承，而是使用composition或
enum
以较低的复杂度实现所需的结果。如何做到这一点？请给出足够详细的答案，让初学者理解。
好的，我不会对你的案例进行编程，但我会给你一些指导，告诉你什么是组合，以及如何使用枚举解决它。
你的问题似乎是，你有一个纳税人，唯一可以分享的是默认税率

使用composition，而不是使用继承，您的类中有一个实例：

public class TaxPayer {
    private List<IncomeSource> incomeSource;
    double taxRate;
    Address address;
    other attributes here;

    public Double getTaxRate(){
        return 0.25; //default tax rate
     }
}

public class Male {
   private TaxPayer taxPayer = new TaxPayer();

   public Double getTaxRate(){
      return taxPayer.getTaxRate();
   }
}

现在您可以使用：

TaxPayer.MALE.getTaxRate();

在你的代码中

第三个选项是定义一个接口并将defaultTaxRate定义为常量

public interface TaxPayer {
  Double getTaxRate();
}

public class Male implements TaxPayer {
  public Double getTaxRate(){
    return Constants.DEFAULT_TAX_RATE;
  }
}

public class Constants {
  public static final double DEFAULT_TAX_RATE = 0.25;
}

现在最重要的一点是，你为什么要做这些过度扩展

首先，您只能扩展一个类，因此它使您的类的版本更少，更难使用。枚举和接口可以为您解决这一问题（因为您仍然可以对其应用枚举）

如您所见，通过使用接口或枚举，它比抽象类更具可扩展性

其次，如果您向抽象类添加一个方法，那么从抽象类扩展的所有类都将继承此方法，并被迫处理/实现此额外方法的行为，或者有一个部分不可用的API。
最好更改为组合。
您可以这样做，从多重继承或接口更改为组合

继承：

Class A{ }
Class B extends Class A{ }
Class C extends Class B{ }


接口：

Interface A{ }
Interface B implements Class A{ }
Class C implements Class B{ }


组成：

class C{  
    A objA = new A();  
    B objB = new B();

    public void test(){  
        objA.doSomething();
    } 
    public void methodA(){ 
        objA.method();
    }
}


“我对如何将底层类组合在一起以生成可用代码感到困惑”。我建议你尽你最大的努力来完成你的课程，然后把结果发布到网上，让人们发表评论。有很多不同的方式来做，没有一个是错误的，所以代码审查网站可能更适合你的问题。如果你考虑做更多的应用程序，考虑使用<代码> BigDecimal < /代码>。使用起来很麻烦，但双精度
只是实数的近似值；例如，0.20不能精确表示。在你第一次重写之后。
Class A{ }
Class B extends Class A{ }
Class C extends Class B{ }

Interface A{ }
Interface B implements Class A{ }
Class C implements Class B{ }

class C{  
    A objA = new A();  
    B objB = new B();

    public void test(){  
        objA.doSomething();
    } 
    public void methodA(){ 
        objA.method();
    }
}