Java 如何从子类访问超类中的私有字段而不使用setter？

我已经被提供了一个名为Account的超类，该类具有初始化余额的构造函数，以及存款和提取余额的方法，其中余额被声明为私有。（我根本无法添加或更改此类中的任何方法或变量）

然后，我创建了一个名为SavingsAccount的子类，其构造函数接受初始余额。如果初始余额为负数，则应使用0的余额初始化帐户。此外，它还包含两种过度使用的方法，存款和取款，用于检查存款和取款金额，以确定是否可行。下面是我收到的代码（Account）和我编写的代码（SavingsAccount）

我尝试在if-else条件中调用super（），但是Java给出了一个错误，super（）调用必须是构造函数的第一行。那么，我该如何应对呢？另外，由于我在提供的Account类中没有setBalance（）方法，如何在SavingsAccount类中设置存款和取款方法的余额

Account.Java（用于测试，无法修改）

SavingsAccount.java（由我编写）

公共类SavingsAccount扩展帐户
{
私人整数透支计数=0；
公共安全账户（双倍初始余额）
{
如果（初始_平衡在这种情况下，可以使用

public SafeAccount(double initialBalance) {
    super(initialBalance < 0 ? 0.0 : initialBalance));
}

公共安全账户（双倍初始余额）{
超级（初始平衡<0？0.0：初始平衡））；
}

您也可以调用返回正确初始余额的静态方法。或者您可以使用工厂方法而不是构造函数：

private SafeAccount(double initialBalance) {
    super(initialBalance);
}

public static SafeAccount createSafeAccount(double initialBalance) {
    if (initialBalance < 0) {
        return new SafeAccount(0.0);
    }
    else {
        return new SafeAccount(initialBalance);
    }
}

私人保险账户（双倍初始余额）{
超级（初始余额）；
}
公共静态安全帐户CreateSafeCount（双初始余额）{
如果（初始余额<0）{
返回新的安全帐户（0.0）；
}
否则{
返回新的安全帐户（初始余额）；
}
}

请注意，以这种方式忽略参数值在大多数情况下都是一个坏主意。传递负初始平衡没有意义，因此是错误的标志。因此，应该通过抛出异常来发出信号，而不是将其转换为0.0并隐藏错误，这可能会导致新的错误，甚至更糟糕，更难诊断。

关于你的第二个问题，我真的不知道问题在哪里。你只需要委托给super方法：

@Override
public void deposit(double amount) {
    if (amount < 0) {
        throw new IllegalArgumentException("amount should be positive");
    }
    else {
        super.deposit(amount);
    }
}

@覆盖
公共作废保证金（双倍金额）{
如果（金额<0）{
抛出新的IllegalArgumentException（“金额应为正”）；
}
否则{
超级保证金（金额）；
}
}
在这种情况下，可以使用

public SafeAccount(double initialBalance) {
    super(initialBalance < 0 ? 0.0 : initialBalance));
}

公共安全账户（双倍初始余额）{
超级（初始平衡<0？0.0：初始平衡））；
}

您也可以调用返回正确初始余额的静态方法。或者您可以使用工厂方法而不是构造函数：

private SafeAccount(double initialBalance) {
    super(initialBalance);
}

public static SafeAccount createSafeAccount(double initialBalance) {
    if (initialBalance < 0) {
        return new SafeAccount(0.0);
    }
    else {
        return new SafeAccount(initialBalance);
    }
}

私人保险账户（双倍初始余额）{
超级（初始余额）；
}
公共静态安全帐户CreateSafeCount（双初始余额）{
如果（初始余额<0）{
返回新的安全帐户（0.0）；
}
否则{
返回新的安全帐户（初始余额）；
}
}

请注意，以这种方式忽略参数值在大多数情况下都是一个坏主意。传递负初始平衡没有意义，因此是错误的标志。因此，应该通过抛出异常来发出信号，而不是将其转换为0.0并隐藏错误，这可能会导致新的错误，甚至更糟糕，更难诊断。

关于你的第二个问题，我真的不知道问题在哪里。你只需要委托给super方法：

@Override
public void deposit(double amount) {
    if (amount < 0) {
        throw new IllegalArgumentException("amount should be positive");
    }
    else {
        super.deposit(amount);
    }
}

@覆盖
公共作废保证金（双倍金额）{
如果（金额<0）{
抛出新的IllegalArgumentException（“金额应为正”）；
}
否则{
超级保证金（金额）；
}
}
您可以更改构造函数以使用三元运算符：

public SafeAccount(double initial_balance) {
  super(initial_balance < 0 ? 0.00 : initial_balance);
}

    public SafeAccount(double initialBalance) {
        super(initialBalance < 0 ? 0 : initialBalance);
    }

您可以更改构造函数以使用三元运算符：

public SafeAccount(double initial_balance) {
  super(initial_balance < 0 ? 0.00 : initial_balance);
}

    public SafeAccount(double initialBalance) {
        super(initialBalance < 0 ? 0 : initialBalance);
    }

如果我理解正确的话，你想做一个不能是否定的解释

对于构造函数，只需使用三元运算符：

public SafeAccount(double initial_balance) {
  super(initial_balance < 0 ? 0.00 : initial_balance);
}

    public SafeAccount(double initialBalance) {
        super(initialBalance < 0 ? 0 : initialBalance);
    }

所以，你的最后一节课应该是这样的：

@Override
public void deposit(double amount) {
  if(amount > 0) {
    super.deposit(amount);
  }
}

public class SafeAccount extends Account {

    private int overDraftCount = 0;

    public SafeAccount(double initialBalance) {
        super(initialBalance < 0 ? 0 : initialBalance);
    }

    @Override
    public void deposit(double amount) {
        if (amount > 0) {
            super.deposit(amount);
        }
    }

    @Override
    public void withdraw(double amount) {
        if (amount > getBalance()) {
            overDraftCount++;
            // if you want to set to 0.00
            super.withdraw(getBalance());
        } else {
            super.withdraw(amount);
        }
    }

    public int overdraftAttempts() {
        return overDraftCount;
    }
}

public SavingsAccount(double initial_balance) {
    super(getAdjustedInitialBalance(initial_balance));
}

private static double getAdjustedInitialBalance(double val) {
    return val < 0 ? 0 : val;
}

公共类安全帐户扩展帐户{
私人整数透支计数=0；
公共安全账户（双倍初始余额）{
超级（初始平衡<0？0：初始平衡）；
}
@凌驾
公共作废保证金（双倍金额）{
如果（金额>0）{
超级保证金（金额）；
}
}
@凌驾
公开作废取款（双倍金额）{
如果（金额>getBalance（））{
透支计数++；
//如果要设置为0.00
super.draw（getBalance（））；
}否则{
超级提款（金额）；
}
}
公共整数透支次数（）{
返回透支计数；
}
}

注意：你的代码不遵守java代码约定，也许你应该看看它们（谷歌
java代码约定
，你会发现）。
如果我理解正确，你想建立一个不能是负面的账户

对于构造函数，只需使用三元运算符：

public SafeAccount(double initial_balance) {
  super(initial_balance < 0 ? 0.00 : initial_balance);
}

    public SafeAccount(double initialBalance) {
        super(initialBalance < 0 ? 0 : initialBalance);
    }

所以，你的最后一节课应该是这样的：

@Override
public void deposit(double amount) {
  if(amount > 0) {
    super.deposit(amount);
  }
}

public class SafeAccount extends Account {

    private int overDraftCount = 0;

    public SafeAccount(double initialBalance) {
        super(initialBalance < 0 ? 0 : initialBalance);
    }

    @Override
    public void deposit(double amount) {
        if (amount > 0) {
            super.deposit(amount);
        }
    }

    @Override
    public void withdraw(double amount) {
        if (amount > getBalance()) {
            overDraftCount++;
            // if you want to set to 0.00
            super.withdraw(getBalance());
        } else {
            super.withdraw(amount);
        }
    }

    public int overdraftAttempts() {
        return overDraftCount;
    }
}

public SavingsAccount(double initial_balance) {
    super(getAdjustedInitialBalance(initial_balance));
}

private static double getAdjustedInitialBalance(double val) {
    return val < 0 ? 0 : val;
}

公共类安全帐户扩展帐户{
私人整数透支计数=0；
公共安全账户（双倍初始余额）{
超级（初始平衡<0？0：初始平衡）；
}
@凌驾
公共作废保证金（双倍金额）{
如果（金额>0）{
超级保证金（金额）；
}
}
@凌驾
公开作废取款（双倍金额）{
如果（金额>getBalance（））{
透支计数++；
//如果要设置为0.00
super.撤回（getBal）