Поведение финального статического метода

Статические методы нельзя переопределить, но их можно скрыть. Метод ts() B не переопределяет (не подвержен полиморфизму) ts() метода A, но скрывает его. Если вы вызываете ts() в B (НЕ A.ts() или B.ts() ... только ts()), будет вызван один из B, а не A. Поскольку это не подвергается полиморфизму, вызов ts() в A никогда не будет перенаправлен на тот, что в Б.

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

Надеюсь это поможет.

статические методы нельзя переопределить

Это не совсем так. Код примера действительно означает, что метод ts в B скрывает метод ts в A. Так что это не совсем переопределение. На Javaranch есть хорошее объяснение.

Статические методы принадлежат классу, а не экземпляру.

A.ts() и B.ts() всегда будут отдельными методами.

Настоящая проблема заключается в том, что Java позволяет вам вызывать статические методы для экземпляра объекта. Статические методы с той же сигнатурой из родительского класса скрыты при вызове из экземпляра подкласса. Однако вы не можете переопределить/скрыть финальные методы. .

Вы могли бы подумать, что в сообщении об ошибке будет использоваться слово hidden вместо overridden...

Вы можете подумать о том, чтобы сделать статический метод final, учитывая следующее:

Наличие следующих классов:

class A {
    static void ts() {
        System.out.print("A");
    }
}
class B extends A {
    static void ts() {
        System.out.print("B");
    }
}

Теперь «правильный» способ вызова этих методов будет

A.ts();
B.ts();

что приведет к AB, но вы также можете вызывать методы для экземпляров:

A a = new A();
a.ts();
B b = new B();
b.ts();

что также приведет к AB.

Теперь рассмотрим следующее:

A a = new B();
a.ts();

это напечатает A. Это может вас удивить, поскольку на самом деле у вас есть объект класса B. Но поскольку вы вызываете его из ссылки типа A, он вызовет A.ts(). Вы можете напечатать B с помощью следующего кода:

A a = new B();
((B)a).ts();

В обоих случаях объект, который у вас есть, на самом деле относится к классу B. Но в зависимости от указателя, указывающего на объект, вы будете вызывать метод из A или из B.

Теперь предположим, что вы являетесь разработчиком класса A и хотите разрешить создание подклассов. Но вы действительно хотите, чтобы метод ts() всякий раз вызывался, даже из подкласса, то есть делал то, что вы хотите, и не был скрыт версией подкласса. Затем вы можете сделать его final и предотвратить его скрытие в подклассе. И вы можете быть уверены, что следующий код вызовет метод из вашего класса A:

B b = new B();
b.ts();

Хорошо, допустим, это как-то устроено, но в некоторых случаях это может иметь смысл.

Вы не должны вызывать статические методы для экземпляров, а непосредственно для классов - тогда у вас не будет этой проблемы. Также IntelliJ IDEA, например, покажет вам предупреждение, если вы вызовете статический метод для экземпляра, а также если вы сделаете статический метод окончательным.

Метод ts() в B не переопределяет метод ts() в A, это просто другой метод. Класс B не видит метод ts() в A, поскольку он статичен, поэтому он может объявить свой собственный метод с именем ts().

Однако, если метод является окончательным, компилятор обнаружит, что в A есть метод ts(), который не следует переопределять в B.

Я думаю, что ошибка компиляции здесь вводит в заблуждение. Он не должен был говорить «переопределенный метод является статическим окончательным», но вместо этого он должен был сказать «переопределенный метод является окончательным». Статический модификатор здесь неуместен.

Статический метод нельзя переопределить в Java, в отличие от нестатических методов. Но они наследуются как статические и нестатические элементы данных. Вот почему нестатический метод с таким же именем не может быть создан в родительском классе.

class Writer { 
    public static void doo(){
        System.out.println("sth");
    } 
}
class Author extends Writer{ 
    public void doo(){
        System.out.println("ok"); // error overridden method is static
    }
}

Ключевое слово final гарантирует, что тело определенного метода будет запускаться каждый раз при вызове метода. Теперь, если в дочернем классе создается статический метод с тем же именем и выполняется вызов метода, выполняется метод в подклассе, чего не должно быть, если final ставится префикс перед именем статического метода в родительском классе. . Следовательно, ключевое слово final ограничивает создание метода с тем же именем в дочернем классе.