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

Я играл с модификаторами со статическим методом и обнаружил странное поведение.

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

Итак, если у меня есть приведенный ниже фрагмент, он отлично компилируется

//Snippet 1 - Compiles fine
public class A {
    static void ts() {
    }
}

class B extends A {
    static void ts() {
    }
}

Но если я добавлю модификатор final к статическому методу в классе A, то компиляция завершится неудачно, ts () в B не может переопределить ts () в A; переопределенный метод является статическим окончательным .

Почему это происходит, когда статический метод вообще нельзя переопределить?

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

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

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

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

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

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

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

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

Можно подумать, что в сообщении об ошибке будет использоваться слово «скрыто», а не «переопределено» ...

Вы можете подумать о том, чтобы сделать статический метод 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. Но в зависимости от указателя, указывающего на объект, вы будете вызывать метод from Aили from B.

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

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

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

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

Метод 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 ограничивает создание метода с тем же именем в дочернем классе.