Понимание метода @Override?

Question

Как метод @Override работает в Java?

Я пытаюсь изучить метод @Override и как наследование работает в Java. Я считаю, что я собрал, как работают дочерние и родительские классы.

Ниже у меня есть один класс драйвера, один родительский класс, а затем два дочерних класса.

То, что я пытаюсь сделать, это иметь вызван метод toString в классе SimpleBankAccount. Однако методы 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 (это необязательно), хотя вы все еще переопределяете метод. От Предопределенные типы аннотаций :

@ Аннотация переопределения информирует компилятор о том, что элемент предназначен для переопределения элемента, объявленного в суперклассе.

Также :

Хотя эту аннотацию не требуется использовать при переопределении метода, она помогает предотвратить ошибки. Если метод, помеченный @Override, не может корректно переопределить метод в одном из его суперклассов, компилятор генерирует ошибку.

В соответствии со спринтером в комментариях, дочерние методы вызываются, если вы не сделаете это. super.methodName() чтобы вызвать родительский метод.

Answer 2

Firsly @Override - это не метод, который называется аннотацией

Теперь

Предположим, что вы расширяете класс, но вас не устраивает какой-то метод в родительском классе вашего класса. Вы хотите, чтобы они сделали что-то еще. Затем вы переопределяете этот метод в своем классе.

Например, у вашего суперкласса есть метод, подобный следующему

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

Но когда вы вызываете этот метод, вы хотите, чтобы он напечатал «Hello», затем в подклассе вы делаете что-то вроде ниже

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

Компилятор обнаруживает, что у вас есть метод с такой же сигнатурой, что и у вашего родительского класса, это означает, что вы хотите переопределить метод родительского класса и запустить собственную реализацию.

Даже если вы не используете аннотацию @Override, вы все равно переопределяете этот метод

, поэтому вопрос в том, что такое использование @Override?

Он в основном служит 3 целям

1. Предположим, что вы переопределяете без @Override и по ошибке вы определяете print () как printt () по ошибке, вы думаете, что переопределяете print, но из-за этой опечатки printt () теперь является отдельным методом , теперь вы вызываете print () и думаете, что будет вызвана ваша print (), но у вас нет метода print () для вызова родительского print (), это не rror, и вы будете думать, почему ваш print () не вызывается.

, поэтому использование @Override предотвращает любую опечатку в имени метода. теперь, если вы делаете

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

Во-вторых, например, вы не знаете, что у вашего суперкласса есть print (int i), который печатает метод квадрата i, и вы определяете метод print () в своем классе, теперь вы или ваш пользователь по ошибке вызывает print (int i), затем вызывается родительская версия, и вы будете думать, что я никогда не определял функцию, которая печатает квадрат числа, и откуда он берется.

@ Override также не позволит вам вносить какие-либо изменения в сигнатуру метода, которую вы хотите переопределить, а также означает, что вы знаете, что у вашего родителя есть метод print (), который вы хотите переопределить.

Третий - читаемость , если кто-то еще прочитает ваше определение класса, он увидит, что метод, аннотированный @Override, также находится в parent, и это переопределенная версия.

Спасибо

Answer 3

Переопределение метода в основном делает то, что он говорит ... переопределяет то, что отправилось бы к родителю и было вызвано ... родитель больше не вызывается, теперь ваш переопределенный метод в дочернем объекте - это то, что вызывается .

Если вы также хотите включить то, что «сказал» родительский элемент, в его метод toString () после того, как вы его переопределите, вы бы принудительно вызвали родительский элемент внутри вашего переопределенного дочернего метода toString () с помощью конкретный c вызов:

super.toString ();

То есть ... вызвать родительскую версию этого метода.

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

super . (метод) ... вызывает переопределенный родительский метод.

Это похоже на то, как this.toString () вызывает метод toString () в ЭТОМ классе ... super.toString () вызывает метод в классе SUPER (родитель.)

Обычно нам не нужно использовать «это», «это». ... подразумевается. Нам нужно явно указать «супер». (если это то, что мы хотим вызвать вместо или вместе с 'this.')

Я добавлю, что иногда вы хотите запускать другие типы переопределенных методов с помощью вызова super. версия метода изнутри переопределенного метода в дочернем элементе. Затем он выполняет всю ту работу, которую выполняет супер, и вы просто добавляете немного дополнительной функциональности, которую дочерний класс теперь добавит к этой работе базовых c методов супер. Часто вы все еще хотели, чтобы это тоже выполнялось ... поэтому вы вызываете его из метода, который вы переопределили, с помощью вызова, чтобы также выполнить super.yourOverriddenMethod (); ... обычно первый.