Java 为对象组合选择正确的模式

有一个名为“Bill”的类。 账单可以是“电力”、“食品”或“客户”，它们都是POJO。 因此它包含三个对象：

    public class Bill{
      private Electricity el1;
      private Food el2;
      private Customer el3;
      //setters and getters
      public setElectricity(...)
      ...
    }

账单列表使用一些DTO填充。 每一次，我都需要检查所有的元素，以确定我有什么类型的账单

我的目标是重构这个设计

我也可以有一个对象并设置与类型相关的内容，但它有任何标准模式吗

是否存在基于请求的类型可以成为类的类的模式？ 我的意思是，就人口数量而言，账单将是电力、食品或客户

注意：我的应用程序倾向于组合而不是继承 它也是一个基于“契约式设计”的应用程序

编辑： 比尔不是它的对象的抽象。 让我们假设，食物只是食物的规格，比如颜色和收据！ 票据在一个时间点上可以是且只能是一个对象

---

票据是一个抽象实体，因此它应该是一个

抽象类。所有其他类型的票据应从其扩展，例如：
电票据
，
食品票据
，
煤气票据
等
票据是一个抽象实体，因此它应该是一个
抽象
类。所有其他类型的票据都应该从中扩展，例如：
ElectricityBill
、
FoodBill
、
GasBill
等
如果ElectricityBill、FoodBill、GasBill具有一些公共功能，则将Bill创建为抽象类，并从Bill扩展其他类

若它们有完全不同的行为和状态（我对此表示怀疑），那个么创建Bill作为接口，并让其他具体类实现它们

我通常称之为简单工厂模式（不要将其与工厂方法/抽象工厂模式混淆）

如果ElectricityBill、FoodBill、GasBill具有一些公共功能，则将Bill创建为抽象类，并从Bill扩展其他类

若它们有完全不同的行为和状态（我对此表示怀疑），那个么创建Bill作为接口，并让其他具体类实现它们

我通常称之为简单工厂模式（不要将其与工厂方法/抽象工厂模式混淆）

因为你有一个大对象，有很多参数，其中一些参数是可选的

您可以使用创建
Bill
类的实例

与抽象工厂模式和工厂方法模式不同
其意图是启用多态性
构建器模式是找到伸缩构造函数的解决方案
反模式。当
对象构造函数参数组合的增加导致
构造函数的指数列表。而不是使用大量
构造器，构造器模式使用另一个对象，构造器
逐步接收每个初始化参数，然后返回
一次生成的构造对象

假设您正在建造一所房子：

public House getHouse() {
    return this.houseBuilder.getHouse();
  }

  public void constructHouse() {
    this.houseBuilder.buildBasement();
    this.houseBuilder.buildStructure();
    this.houseBuilder.bulidRoof();
    this.houseBuilder.buildInterior();
  }

来自
的示例，因为您有一个包含许多参数的大对象，其中一些参数是可选的

您可以使用创建
Bill
类的实例

与抽象工厂模式和工厂方法模式不同
其意图是启用多态性
构建器模式是找到伸缩构造函数的解决方案
反模式。当
对象构造函数参数组合的增加导致
构造函数的指数列表。而不是使用大量
构造器，构造器模式使用另一个对象，构造器
逐步接收每个初始化参数，然后返回
一次生成的构造对象

假设您正在建造一所房子：

public House getHouse() {
    return this.houseBuilder.getHouse();
  }

  public void constructHouse() {
    this.houseBuilder.buildBasement();
    this.houseBuilder.buildStructure();
    this.houseBuilder.bulidRoof();
    this.houseBuilder.buildInterior();
  }

如果账单只能包含一个Instance，为什么不使用界面呢

    public interface Billable {

        double getPrize();
    }

    public class Electricity implements Billable {

        @Override
        public double getPrize() {
            return 20.0;
        }
    }

    public class Bill {

        /**
         * Billable to bill.
         */
        Billable billable;
        /*
         * Discount percent applied to bill.
         */
        @Min(0)
        @Max(100)
        double discount;
        /**
         * VAT percent applied to bill.
         */
        @Min(0)
        @Max(100)
        double vat;

        public Bill(@NotNull Billable billable) {
            this.billable = billable;
            discount = 10.0;
            vat = 21.0;
        }


        public double getFinalPrize() {
            double discountFactor = 1 - discount / 100;
            double vatFactor = 1 + vat / 100;
            return billable.getPrize() * discountFactor * vatFactor;
        }

        public static void main(String[] args) {
            Electricity electricity = new Electricity();
            Bill electricityBill = new Bill(electricity);
            System.out.println(electricityBill.getFinalPrize());

        }
    }

如果账单只能包含一个Instance，为什么不使用界面呢

    public interface Billable {

        double getPrize();
    }

    public class Electricity implements Billable {

        @Override
        public double getPrize() {
            return 20.0;
        }
    }

    public class Bill {

        /**
         * Billable to bill.
         */
        Billable billable;
        /*
         * Discount percent applied to bill.
         */
        @Min(0)
        @Max(100)
        double discount;
        /**
         * VAT percent applied to bill.
         */
        @Min(0)
        @Max(100)
        double vat;

        public Bill(@NotNull Billable billable) {
            this.billable = billable;
            discount = 10.0;
            vat = 21.0;
        }


        public double getFinalPrize() {
            double discountFactor = 1 - discount / 100;
            double vatFactor = 1 + vat / 100;
            return billable.getPrize() * discountFactor * vatFactor;
        }

        public static void main(String[] args) {
            Electricity electricity = new Electricity();
            Bill electricityBill = new Bill(electricity);
            System.out.println(electricityBill.getFinalPrize());

        }
    }

ElectricityBill
，
FoodBill
，
GasBill
。每个字段都有哪些不同的字段？您已经向我们展示了一些关于类的组成的信息，但没有展示行为。每个账单的行为是相同的，例如chargeCustomer（），还是不同的，例如electric.turnOffPower（）、gas.ShutdoffValve（）、food.lockStore（）？事实上它们有很多不同之处，我所做的只是我真实代码的一个示例，但为了更清楚地说明，我们假设账单也有一个customer对象。
ElectricityBill
，
FoodBill
，
GasBill
。每个字段都有哪些不同的字段？您已经向我们展示了一些关于类的组成的信息，但没有展示行为。每个账单的行为是相同的，例如chargeCustomer（），还是不同的，例如electric.turnOffPower（）、gas.ShutdoffValve（）、food.lockStore（）？事实上它们有很多不同之处，我所做的只是我真实代码的一个示例，但为了更清楚，假设Bill也有一个客户对象。有什么标准模式可以应用吗？至少可以提到一个应用的模式？它基本上是PTI，即程序到接口。一个类的任何模式在某个时间点上都可以是少数几个对象中的一个？赞赏并投票支持你的答案，但仍然没有得到我想要的。是否存在基于请求的类型可以成为类的类的模式？我的意思是，就人口数量而言，账单将是电力、食品或客户。是否有任何标准模式适用于此？至少可以提到一个应用的模式？它基本上是PTI，即程序到接口。一个类的任何模式在某个时间点上都可以是少数几个对象中的一个？赞赏并投票支持你的答案，但仍然没有得到我想要的。是否存在基于请求的类型可以成为类的类的模式？我的意思是，账单将是电力、食品或客户的账单