Java 如果每个'；交易'；是一个对象，如何存储所有交易的总成本？

前言：对不起，所有的代码，我知道大部分是多余的这个问题

此类将描述（大小）、成本和数量作为参数，并返回创建对象的次数（事务编号）、为所有创建对象指定的总数量（总数量），以及（应该）返回所有创建对象的总成本

public class SalesTransaction
{
    private static int counter = 1;
    public final int transaction_number;
    private static int order_quantity = 0;
    public final int total_quantity;
    private static double temp_grand_total = 0;
    public final double grand_total;
    private String size;
    private double cost;
    private int quantity;

    public SalesTransaction(String size, double cost, int quantity)
    {   
        this.size = size;
        this.cost = cost;
        this.quantity = quantity;

        this.transaction_number = counter++;
        order_quantity += quantity;
        this.total_quantity = order_quantity;
        temp_grand_total += totalCostAfterTax(cost*quantity); // this is wrong!
        this.grand_total = temp_grand_total;
    }

    public static double discountAmount(int quantity, double cost)
    {
        double discount_amount = 0; 
        if (quantity > 20)
        {
            discount_amount = cost * 0.10;
        }   
        return discount_amount;
    }

    public static double totalCostBeforeTax(SalesTransaction temp)
    {
        double total_cost;
        int quantity = temp.quantity;
        double cost = temp.cost;
        total_cost = quantity * cost;
        double discount_amount = discountAmount(quantity, total_cost);
        total_cost = total_cost - discount_amount;
        return total_cost;
    }

    public static double totalCostAfterTax(double total_cost)
    {
        total_cost = total_cost * 1.15;
        return total_cost;
    }

    public static void printStats(SalesTransaction temp)
    {
        System.out.println("Transaction Number: " + temp.transaction_number);
        System.out.println("Size: " + temp.size);
        System.out.println("Cost Per Table: "+ temp.cost);
        System.out.println("Number of Tables: " + temp.quantity);
        System.out.println("Total Tables So Far: " + temp.total_quantity);
        double total_cost_before_tax = totalCostBeforeTax(temp);
        double discount_amount = discountAmount(temp.quantity, total_cost_before_tax);
        System.out.println("Discount: " + discount_amount);
        double total_cost_after_tax = totalCostAfterTax(total_cost_before_tax);
        temp.temp_grand_total = total_cost_after_tax;
        System.out.println("Cost for this transaction: " + total_cost_after_tax);
        System.out.println("Total cost: "+ temp.grand_total);
        System.out.println();
    }
}

这只是一个测试类

public class SalesTester
{
    public static void main(String[] args)
    {
        SalesTransaction one = new SalesTransaction("Small", 10.0, 10);
        one.printStats(one);

        SalesTransaction two = new SalesTransaction("Medium", 20.0, 30);
        two.printStats(two);

        SalesTransaction three = new SalesTransaction("Large", 30.0, 40);
        three.printStats(three);
    }
}

问题是我不知道如何存储总计。我试着用存储总量的方法来做，但我明白为什么这样做不起作用

如何跟踪所有事务（对象）的总数，以便在控制台上打印出来

---

我假设在构造函数中有另一种表达方式，但我不确定如何表达，也找不到任何例子

最简单的解决方案是在

SalesTransaction

类上使用一个

static

字段，该字段保存

grand\u total

。类的所有实例共享一个

静态

变量

private static double grandTotal = 0;
public SalesTransaction(double cost) {
    grandTotal += cost;
}

然而，从长远来看，这有一些缺点。这意味着您不能作为不同总计的成员进行交易。这就是为什么它被称为

解决此问题的更好方法是创建一个附加类，例如

TransactionGroup

，它包含

列表中的
saletransaction
对象，并在需要时将成本相加

public class TransactionGroup {
    private List<SalesTransaction> transactions = new ArrayList<>();
    public void addTransaction(SalesTransaction st) {
        transactions.add(st);
    }
    public double getGrandTotal() {
        double sum = 0;
        for (SalesTransaction st : transactions) {
            sum += st.getCost();
        }
        return sum;
    }
}

公共类事务组{
私有列表事务=新的ArrayList（）；
公开作废addTransaction（SalesTransaction st）{
交易。添加（st）；
}
公共双getGrandTotal（）{
双和=0；
for（SalesTransaction st:transactions）{
sum+=st.getCost（）；
}
回报金额；
}
}
最简单的解决方案是在
SalesTransaction
类上使用一个
静态
字段，该字段保存
总计
。类的所有实例共享一个
静态
变量

private static double grandTotal = 0;
public SalesTransaction(double cost) {
    grandTotal += cost;
}

然而，从长远来看，这有一些缺点。这意味着您不能作为不同总计的成员进行交易。这就是为什么它被称为

解决此问题的更好方法是创建一个附加类，例如
TransactionGroup
，它包含
列表中的
saletransaction
对象，并在需要时将成本相加

public class TransactionGroup {
    private List<SalesTransaction> transactions = new ArrayList<>();
    public void addTransaction(SalesTransaction st) {
        transactions.add(st);
    }
    public double getGrandTotal() {
        double sum = 0;
        for (SalesTransaction st : transactions) {
            sum += st.getCost();
        }
        return sum;
    }
}

公共类事务组{
私有列表事务=新的ArrayList（）；
公开作废addTransaction（SalesTransaction st）{
交易。添加（st）；
}
公共双getGrandTotal（）{
双和=0；
for（SalesTransaction st:transactions）{
sum+=st.getCost（）；
}
回报金额；
}
}
我将这些视为行项目，一个事务将由多个行项目组成。事务的属性与行项目完全相同。本练习的目的是练习我想象中的某种簿记技能。我将这些技能视为行项目，一笔交易将由多个行项目组成。交易的属性与行项目完全相同。这个练习的目的是练习一些我想象中的簿记技巧。啊，这真的很有趣，我从来没有想过要单独上一节课来记录。谢谢啊，这真的很有趣，我从来没有想过要单独开一节课来跟踪。谢谢