Question

我有一个程序从两个文件读取，一个文件用于创建帐户，另一个用于引用与每个帐户相关的事物，并提供计算成本的值。

首先，第一个文件......

创建帐户（国内或商业）
- 如果是国内，则为帐户分配读取的MeterNumber
- 如果是Commercial，则创建一个Meter对象数组
  - 每个仪表都有一个MeterNumber，可以有三种类型的 Tariff （Peak，OffPeak，Custom）
    - 创建适当的关税
    - 每种资费都有成本（kWh）功能，可以返回成本

然后，第二个文件有一个仪表编号列表，读取的资费，以及读取的电量。每个仪表编号可以在不同的资费类型下出现多次。

然后，我的问题就是引用一个特定的电表，其电价类型和要计算的kWh值，并返回与每个电表相关的总成本

我一直在Main类的基础上工作：

加载第二个文件（仪表读数）并以某种方式存储它们
加载第一个文件并通过访问来计算应付给每个帐户的相对于读数的金额？帐户。 MeterNumber [x]。 SOMETHING .Tariff [y] .cost（v）??。

其中x是被引用的MeterNumber，y是要读取的关税，v是要计算的kWh值，以及为该帐户的应付总额做出贡献的输出
遍历所有帐户，然后打印一份AccountNumbers列表及其应付总金额

当试图以某种方式调用cost（）函数时出现问题，我根本不知道如何从创建它的方式访问它，并且由于任何数量和类型的不同而导致不同资费类型的成本计算与计量表相关的关税，每米的Tarrif数目中的每种关税都是未知的关税类型。

任何帮助都会很棒，谢谢。

代码段：

Account，Main调用Account.load（）

public static Account load(Scanner sc) {
      if (sc.hasNextLine()) {
         AccountNumber accountNumber = AccountNumber.fromString(sc.nextLine());
         String kind = sc.next();
         sc.nextLine();

         if (kind.equals("D")) {
            return new DomesticAccount(sc, accountNumber);
         } else {
            return new CommercialAccount(sc, accountNumber);
         }
      } else {
         return null;
      }
   }

CommercialAccount，DomesticAccount是相同的，但只存储MeterNumber，而不是Meters数组

public class CommercialAccount extends Account {

   private Meter[] meters;

   public CommercialAccount(Scanner sc, AccountNumber accountNumber) {
      this.accountNumber = accountNumber;
      int n = sc.nextInt();
      sc.nextLine();
      meters = new Meter[n];
      for (int i = 0; i < n; i++) {
         meters[i] = Meter.load(sc);
      }
   }


   public MeterNumber[] getMeterNumbers() {
      MeterNumber[] ms = new MeterNumber[meters.length];
      for (int i = 0; i < meters.length; i++) {
         ms[i] = meters[i].getMeterNumber();
      }
      return ms;
   }
}

仪表

public class Meter {

   private MeterNumber meterNumber;

   private Tariff[] tariffs;

   public Meter(MeterNumber meterNumber, Tariff[] tariffs) {
      this.meterNumber = meterNumber;
      this.tariffs = tariffs;
   }

   public static Meter load(Scanner sc) {
      MeterNumber meterNumber = MeterNumber.fromString(sc.nextLine());
      int n = sc.nextInt();
      sc.nextLine();
      Tariff[] tariffs = new Tariff[n];
      String[] tariffTypes = new String[n];
      for (int i = 0; i < n; i++) {
         String kind = sc.next();
         sc.nextLine();
         if (kind.equals("P")) {
            tariffs[i] = PeakTariff.PEAK_TARIFF;
            tariffTypes[i] = "P";
         } else if (kind.equals("O")) {
            tariffs[i] = OffPeakTariff.OFF_PEAK_TARIFF;
            tariffTypes[i] = "O";
         } else {
            tariffs[i] = ContractedTariff.load(sc);
            tariffTypes[i] = "S";
         }
      }
      return new Meter(meterNumber, tariffs);
   }

   public MeterNumber getMeterNumber() {
      return meterNumber;
   }


}

关税

public abstract class Tariff {

   public abstract double cost(double kWh);

}

ContractedTariff

public class ContractedTariff extends Tariff {

   private double r1, r2, r3, // rates in $/kWh
                  t1, t2;     // thresholds in kWh

   public static ContractedTariff load(Scanner sc) {
      ContractedTariff ct = new ContractedTariff(sc.nextDouble(), sc.nextDouble(),
         sc.nextDouble(), sc.nextDouble(), sc.nextDouble());
      sc.nextLine();
      return ct;
   }

   public double cost(double kWh) {
      return 666.0; // placeholder
   }

}

OffPeakTariff，PeakTariff基本相同。

public class OffPeakTariff extends Tariff {

   public static final double RATE = 0.1543; // $/kWh

   // only one instance is required.
   public static final OffPeakTariff OFF_PEAK_TARIFF = new OffPeakTariff();

   public double cost(double kWh) {
      return 666.0;  // placeholder
   }   

}

从另一个对象创建的对象访问对象的方法

0 个答案: