Чому я не можу оголосити статичні методи в інтерфейсі?

Ця тема говорить найбільше - що є причиною того, що статичні методи не можуть бути оголошені в інтерфейсі?

public interface ITest {
    public static String test();
}

Код, наведений вище, дає мені таку помилку (принаймні, у Eclipse): "Незаконні модифікатори для методу інтерфейсу ITest.test (); дозволені лише загальнодоступні та абстрактні".

Тут є кілька проблем. Перший - питання декларування статичного методу без його визначення. Це різниця між

public interface Foo {
  public static int bar();
}

і

public interface Foo {
  public static int bar() {
    ...
  }
}

Перше неможливо з причин, про які згадує Espo : ви не знаєте, який клас реалізації є правильним визначенням.

Java могла дозволити останнє; і насправді, починаючи з Java 8, це і є!

Причина, чому у вас не може бути статичного методу в інтерфейсі, полягає в тому, як Java вирішує статичні посилання. Java не намагатиметься шукати екземпляр класу при спробі виконання статичного методу. Це тому, що статичні методи не залежать від екземплярів, і тому вони можуть бути виконані прямо з файлу класу. Зважаючи на те, що всі методи в інтерфейсі абстрактні, VM повинен буде шукати певну реалізацію інтерфейсу, щоб знайти код за статичним методом, щоб його можна було виконати. Потім це суперечить тому, як працює дозвіл статичного методу і вводить непослідовність у мову.

Я відповім на ваше запитання прикладом. Припустимо, у нас був клас Math зі статичним методом add. Ви б назвали цей метод так:

Math.add(2, 3);

Якби Math був інтерфейсом замість класу, він не міг би мати жодних визначених функцій. Як таке, говорити щось на зразок Math.add (2, 3) не має сенсу.

Причина полягає в принципі дизайну в тому, що java не допускає багаторазового успадкування. Проблему з багаторазовим успадкуванням можна проілюструвати наступним прикладом:

public class A {
   public method x() {...}
}
public class B {
   public method x() {...}
}
public class C extends A, B { ... }

Тепер, що станеться, якщо ви зателефонуєте на Cx ()? Чи буде виконано Ax () або Bx ()? Кожна мова з багаторазовим успадкуванням має вирішити цю проблему.

Інтерфейси дозволяють в Java якось обмежувати багатократне успадкування. Щоб уникнути вищезазначеної проблеми, їм заборонено використовувати методи. Якщо ми розглянемо ту саму проблему з інтерфейсами та статичними методами:

public interface A {
   public static method x() {...}
}
public interface B {
   public static method x() {...}
}
public class C implements A, B { ... }

Тут же проблема, що трапиться, якщо ви зателефонуєте на Cx ()?

Статичні методи - це не інстанційні методи. Контексту екземпляра немає, тому реалізувати його через інтерфейс мало сенсу.

Тепер Java8 дозволяє нам визначати навіть Статичні методи в інтерфейсі.

interface X {
    static void foo() {
       System.out.println("foo");
    }
}

class Y implements X {
    //...
}

public class Z {
   public static void main(String[] args) {
      X.foo();
      // Y.foo(); // won't compile because foo() is a Static Method of X and not Y
   }
}

Примітка: Методи в інтерфейсі досі залишаються загальнодоступними абстрактними, якщо ми не використовуємо явно ключові слова за замовчуванням / статичні, щоб зробити їх методами за замовчуванням та статичними методами.

Там дуже хороший і лаконічну відповідь на ваше запитання тут . (Мене це вразило як такий добре зрозумілий спосіб пояснення, що я хочу зв'язати це звідси.)

Здається, статичний метод в інтерфейсі може підтримуватися в Java 8 , ну, моє рішення просто визначити їх у внутрішньому класі.

interface Foo {
    // ...
    class fn {
        public static void func1(...) {
            // ...
        }
    }
}

Цей самий прийом можна використовувати і в анотаціях:

public @interface Foo {
    String value();

    class fn {
        public static String getValue(Object obj) {
            Foo foo = obj.getClass().getAnnotation(Foo.class);
            return foo == null ? null : foo.value();
        }
    }
}

До внутрішнього класу завжди слід звертатися у формі Interface.fn...замість того Class.fn..., тоді можна позбутися від неоднозначної проблеми.

Для поліморфізму використовується інтерфейс, який стосується Об'єктів, а не типів. Тому (як уже зазначалося) стати статичним інтерфейсом немає сенсу.

Java 8 Якщо б змінився світ, у вас можуть бути статичні методи в інтерфейсі, але це змушує вас забезпечити реалізацію для цього.

public interface StaticMethodInterface {
public static int testStaticMethod() {
    return 0;
}

/**
 * Illegal combination of modifiers for the interface method
 * testStaticMethod; only one of abstract, default, or static permitted
 * 
 * @param i
 * @return
 */
// public static abstract int testStaticMethod(float i);

default int testNonStaticMethod() {
    return 1;
}

/**
 * Without implementation.
 * 
 * @param i
 * @return
 */
int testNonStaticMethod(float i);

}

Незаконне поєднання модифікаторів: статичного та абстрактного

Якщо член класу оголошений статичним, він може використовуватися з його іменем класу, яке приурочене до цього класу, без створення об'єкта.

Якщо член класу оголошується абстрактним, вам потрібно оголосити клас абстрактним, і вам потрібно забезпечити реалізацію абстрактного члена у його спадковому класі (Підклас).

Вам потрібно надати реалізацію абстрактному члену класу в підкласі, де ви збираєтеся змінити поведінку статичного методу, також оголошеного як абстрактний, який обмежений базовим класом, що невірно

Оскільки статичні методи не можуть бути успадковані. Тому не потрібно розміщувати його в інтерфейсі. Інтерфейс - це в основному договір, якого повинні дотримуватися всі його абоненти. Розміщення статичного методу в інтерфейсі змусить абонентів здійснити його. що тепер стає суперечливим тому, що статичні методи не можуть бути успадковані.

З Java 8 інтерфейси тепер можуть мати статичні методи.

Наприклад, компаратор має статичний метод naturalOrder ().

Вимога про те, що інтерфейси не можуть мати реалізацію, також була знята. Тепер інтерфейси можуть оголосити реалізацію методу "за замовчуванням", які є як звичайні реалізації з одним винятком: якщо ви успадкуєте як інтерфейс за замовчуванням від інтерфейсу, так і звичайну реалізацію від суперкласу, реалізація суперкласу завжди матиме пріоритет.

Можливо, приклад коду допоможе, я буду використовувати C #, але ви повинні мати змогу слідувати далі.

Давайте робити вигляд, що у нас є інтерфейс під назвою IPayable

public interface IPayable
{
    public Pay(double amount);
}

Тепер у нас є два конкретні класи, які реалізують цей інтерфейс:

public class BusinessAccount : IPayable
{
    public void Pay(double amount)
    {
        //Logic
    }
}

public class CustomerAccount : IPayable
{
    public void Pay(double amount)
    {
        //Logic
    }
}

Тепер давайте зробимо вигляд, що у нас є колекція різних облікових записів, для цього ми використаємо загальний список типу IPayable

List<IPayable> accountsToPay = new List<IPayable>();
accountsToPay.add(new CustomerAccount());
accountsToPay.add(new BusinessAccount());

Тепер ми хочемо заплатити $ 50,00 за всі ці рахунки:

foreach (IPayable account in accountsToPay)
{
    account.Pay(50.00);
}

Тож тепер ви бачите, як інтерфейси неймовірно корисні.

Вони використовуються лише на інстанційних об'єктах. Не на статичних класах.

Якби ви зробили статичну оплату, під час переходу через IPayable в accountToPay не було б можливості зрозуміти, чи слід викликати оплату на BusinessAcount або CustomerAccount.