理解@Override方法？

Question

@Override方法在Java中是如何工作的？

我正在尝试学习@Override方法以及继承在Java语言中是如何工作的。我相信我已经了解了子类和父类是如何工作的。

下面我有一个驱动类，一个父类，然后是两个子类。

我尝试做的是让SimpleBankAccount类中的toString方法调用。但是，将调用子类中的toString方法。

public class AccountsDriver{
    final public static double INTEREST_RATE = 0.01;  // 1%

    public static void main( String[] args ){
        CheckingAccount checking = new CheckingAccount( 100.0 );
        SavingAccount savings = new SavingAccount( 1000.0, INTEREST_RATE );

        double monthlyExpenses = 756.34;
        int electricBillCheckNum = 2123;
        double electricBill = 60.34;
        int registationCheckNum = 2124;
        double registration = 50.00;
        double dinnerMoney = 55.32;
        double futureCar = 200.0;
        double textbook = 90.0;
        checking.deposit( monthlyExpenses );
        checking.processCheck( electricBillCheckNum, electricBill );
        checking.withdraw( dinnerMoney );
        checking.processCheck( registationCheckNum, registration );
        System.out.print( checking.toString() );
        savings.deposit( futureCar );
        savings.applyInterest( );
        savings.withdraw( textbook );
        System.out.print( savings.toString() );
    }
}
public class SimpleBankAccount
{
    protected double balance;
    public boolean withdraw(double amount){
        if (balance - amount >= 0){
            balance -= amount;
            return true;
        }else{
            return false;
        }
    }
    public String toString(){
        //display balance as currency
        String balanceStr = NumberFormat.getCurrencyInstance().format(balance);
        return "Balance: " +balanceStr+ "\n";
    }
}
public class CheckingAccount extends SimpleBankAccount
{
    int lastCheck;
    public CheckingAccount(double amount){
        balance = amount;
    }
    public boolean processCheck(int checkNum, double amount){
        if (lastCheck == checkNum){
            return false;
        }else{
            balance -= amount;
            lastCheck = checkNum;
            return true;
        }
    }
    public String toString(){
        //display the balance as currency
        String balanceStr = NumberFormat.getCurrencyInstance().format(balance);
        return "Checking Account: \n Balance: " +balanceStr+ "\n Last processed check: " +lastCheck;
    }
}
public class SavingAccount extends SimpleBankAccount
{
    double interestRate;
    public SavingAccount(double amount, double interestRate){
        balance = amount;
        this.interestRate = interestRate;
    }
    public void applyInterest(){
        balance = (balance*interestRate)+balance;
    }
    public String toString(){
        //display balance as currency
        String balanceStr = NumberFormat.getCurrencyInstance().format(balance);
        return "Saving Account: \n Balance: " +balanceStr+ "\n APR: " +interestRate;
    }
}

有人能指出我做错了什么吗？

Answer 1

在您的代码中，您没有使用@Override注释(这是可选的)，尽管您仍在覆盖该方法。来自Predefined Annotation Types

@Override注解通知编译器该元素将覆盖在超类中声明的元素。

另外：

虽然在重写方法时不需要使用此注释，但它有助于防止错误。如果标记为@Override的方法无法正确覆盖其超类中的方法，则编译器会生成一个错误。

根据注释中的sprinter，除非您执行super.methodName()来调用父方法，否则将调用子方法。

Answer 2

重写一个方法基本上做到了它所说的.覆盖传递到父级并被调用的内容...父对象不再被调用，现在调用的是子对象中被覆盖的方法。

如果您还想在重写父对象的toString()方法后将其包含在父对象的toString()方法中，则可以通过特定的调用强制调用被覆盖的子对象toString()方法中的父对象：

super.toString()；

也就是说..。调用此方法的父级版本。

...
@Override
public String toString() {
  return super.toString() + (concatenate your additional child info onto the super info.)
}

超级。(方法) ..。调用已重写的父方法。

这就像this.toString()调用这个类中的toString()方法一样……super.toString()调用超类(父类)中的方法。

我们通常不需要用“这个”，“这个”...是隐含的。我们确实需要明确地声明“超级”。(如果这就是我们想要的名称，而不是‘this’，或者与‘this’一起使用。)

我要补充的是，有时您希望通过调用来执行超级方法来启动其他类型的重写方法。子对象中被重写方法内部的方法版本。然后，它完成超级方法正在做的所有工作，您只是添加了一些额外的功能，子类现在将这些功能添加到基本的超级方法工作中。通常，你仍然希望它也能运行...因此，您可以从方法内部调用它，您已经用一个调用覆盖了该方法，以同时执行super.yourOverriddenMethod()；...通常是第一个。

Answer 3

Firsly @Override不是一个方法，它被称为注解

现在

假设你扩展了一个类，但是你对类的父类中的一些方法不满意，你想让他们做其他的事情。然后在类中覆盖该方法。

例如，您的超类具有如下方法

public void print(){
System.out.println("Hi");
}

但是当您调用此方法时，您希望它打印"Hello“，然后在子类中执行如下操作

public void print(){
System.out.prinlnt("Hello");
}

编译器检测到您有一个与父类具有相同签名的方法，这意味着您希望覆盖父类方法并运行自己的实现。

即使您不使用注解@Override，您仍然会覆盖该方法

所以问题是@Override的用法是什么？

它基本上有三个目的

1. 假设您在没有@Override的情况下进行重写，并且错误地将print()定义为printt()，您认为您正在重写print，但由于拼写错误，printt()现在是一个单独的方法，现在您正在调用print()，您认为您的print()将被调用，但您没有print()方法来为print()设置父调用，这不是错误，您将思考为什么不调用您的print()。

所以使用@Override可以防止你在方法名中犯任何拼写错误。现在，如果您使用

@Override
public void printt() // that is actually an error, without @Override it's not

第二个是，例如，你不知道你的超类有一个(Int i)，它打印i的平方方法，你在你的类中定义了一个方法

1. ()方法，现在你或你的用户错误地调用了print(int i)，然后父版本被调用了，你会认为我从来没有定义过一个打印数字平方的函数，那么它是从哪里来的。

@Override还将阻止您对要覆盖的方法签名进行任何更改，这意味着您知道在您的父级中有一个您想要覆盖的方法print()。

1. 第三个是readability，如果其他人阅读了您的类定义，他可以看到带有@Override注释的方法也在parent中，这是一个重写版本。

谢谢