Поведінка кінцевого статичного методу

Я грав із модифікаторами статичним методом і натрапив на дивну поведінку.

Як ми знаємо, статичні методи не можна перекрити, оскільки вони асоціюються з класом, а не інстанцією.

Отже, якщо у мене є фрагмент нижче, він складається добре

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

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

Але якщо я включу остаточний модифікатор до статичного методу в класі A, то компіляція не вдається ts () в B не може замінити ts () в A; метод, що перекрито, є статичним остаточним .

Чому це трапляється, коли статичний метод взагалі не можна змінити?

Статичні методи не можна перекрити, але їх можна приховати. ts()Метод B не перекриваючи (не підлягає поліморфізм) ts()А , але вона буде приховати. Якщо ви зателефонуєте ts()в B (НЕ A.ts()або B.ts()... просто ts()), той з B буде називатися, а не А. Оскільки це не піддається поліморфізму, виклик ts()в A ніколи не буде перенаправлений на той, який знаходиться в B.

Ключове слово finalвідключить метод не приховувати. Тому їх не можна приховати, і спроба зробити це призведе до помилки компілятора.

Сподіваюся, це допомагає.

статичні методи не можна перекрити

Це не зовсім так. Приклад код дійсно означає, що метод ts в B приховує метод ts в A. Отже, його не зовсім переважає. На Javaranch є приємне пояснення.

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

A.ts()і B.ts()завжди будуть окремими методами.

Справжня проблема полягає в тому, що Java дозволяє викликати статичні методи на об’єкті екземпляра. Статичні методи з однаковим підписом від батьківського класу приховані, коли викликаються з екземпляра підкласу. Однак ви не можете змінити / приховати остаточні методи .

Ви можете подумати, що повідомлення про помилку буде використовувати слово приховане замість перекресленого ...

Можливо, ви можете подумати про те, щоб статичний метод остаточним, враховуючи наступне:

Проводячи наступні класи:

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ключових словах гарантує , що метод конкретного орган буде запускати кожен раз, коли виклик методу. Тепер, якщо статичний метод створений у дочірньому класі з тим самим іменем і здійснюється виклик методу, метод у підкласі виконується, що не повинно бути випадком, якщо остаточний префікс перед іменем статичного методу в батьківському класі . Отже, заключне ключове слово обмежує створення методу з тим самим іменем у дочірньому класі.