Почему переменные интерфейса статические и финальные по умолчанию?

Почему переменные интерфейса статические и финальные по умолчанию в Java?

Из FAQ по дизайну интерфейса Java от Филиппа Шоу:

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

источник

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

Следовательно, если вообще есть интерфейсная переменная, она будет неявно статической, конечной и явно публичной !!!

public : для доступности для всех классов, так же, как методы, присутствующие в интерфейсе

static : поскольку интерфейс не может иметь объект, interfaceName.variableName может использоваться для ссылки на него или непосредственно на variableName в классе, реализующем его.

Финал : сделать их постоянными. Если 2 класса реализуют один и тот же интерфейс, и вы предоставляете им обоим право изменять значение, конфликт будет иметь место в текущем значении переменной var, поэтому разрешена только одна временная инициализация.

Также все эти модификаторы неявны для интерфейса, вам не нужно указывать ни один из них.

( Это не философский ответ, а скорее практический ). Требование к staticмодификатору очевидно, на что ответили другие. По сути, поскольку интерфейсы не могут быть созданы, единственный способ получить доступ к его полям - сделать их полем класса - static.

Причина, по которой interfaceполя автоматически становятся final(постоянными), состоит в том, чтобы предотвратить случайное изменение значения различными значениями переменной интерфейса в различных реализациях, что может непреднамеренно повлиять на поведение других реализаций. Представьте себе сценарий ниже, где interfaceсвойство явно не стало finalJava:

public interface Actionable {
    public static boolean isActionable = false;

    public void performAction();
}

public NuclearAction implements Actionable {

    public void performAction() {
        // Code that depends on isActionable variable
        if (isActionable) {
            // Launch nuclear weapon!!!
        }
    }
}

Теперь просто подумайте, что произойдет, если другой реализующий класс Actionableизменяет состояние интерфейсной переменной:

public CleanAction implements Actionable  {

    public void performAction() {
        // Code that can alter isActionable state since it is not constant
        isActionable = true;
    }
}

Если эти классы загружаются в одной JVM загрузчиком классов, то на поведение класса NuclearActionможет повлиять другой класс, CleanActionкогда его performAction()вызов вызывается после CleanActionвыполнения (в том же потоке или иным образом), что в этом случае может иметь катастрофические последствия. (семантически это).

Поскольку мы не знаем, как каждая реализация interfaceбудет использовать эти переменные, они должны быть неявно final.

Потому что все остальное является частью реализации, и интерфейсы не могут содержать какую-либо реализацию.

public interface A{
    int x=65;
}
public interface B{
    int x=66;
}
public class D implements A,B {
    public static void main(String[] a){
        System.out.println(x); // which x?
    }
}

Вот решение.

System.out.println(A.x); // done

Я думаю, что это одна из причин, почему переменные интерфейса являются статическими.

Не объявляйте переменные внутри интерфейса.

статический - потому что интерфейс не может иметь никакого экземпляра. и последнее - потому что нам не нужно это менять.

так как:

Static : поскольку у нас не может быть объектов интерфейсов, мы должны избегать использования переменных-членов уровня объекта и должны использовать переменные уровня класса, то есть static.

Final : чтобы у нас не было неоднозначных значений для переменных (проблема Алмаза - множественное наследование).

А согласно интерфейсу документации это контракт, а не реализация.

ссылка: ответ Абхишека Джайна на квору

Java не допускает абстрактных переменных и / или определений конструктора в интерфейсах. Решение: Просто повесьте абстрактный класс между вашим интерфейсом и вашей реализацией, который только расширяет абстрактный класс следующим образом:

 public interface IMyClass {

     void methodA();
     String methodB();
     Integer methodC();

 }

 public abstract class myAbstractClass implements IMyClass {
     protected String varA, varB;

     //Constructor
     myAbstractClass(String varA, String varB) {
         this.varA = varA;
         this.varB = VarB;
     }

     //Implement (some) interface methods here or leave them for the concrete class
     protected void methodA() {
         //Do something
     }

     //Add additional methods here which must be implemented in the concrete class
     protected abstract Long methodD();

     //Write some completely new methods which can be used by all subclasses
     protected Float methodE() {
         return 42.0;
     }

 }

 public class myConcreteClass extends myAbstractClass {

     //Constructor must now be implemented!
     myClass(String varA, String varB) {
         super(varA, varB);
     }

     //All non-private variables from the abstract class are available here
     //All methods not implemented in the abstract class must be implemented here

 }

Вы также можете использовать абстрактный класс без какого-либо интерфейса, если вы уверены, что не хотите реализовывать его вместе с другими интерфейсами позже. Обратите внимание, что вы не можете создать экземпляр абстрактного класса, вы ДОЛЖНЫ его сначала расширить.

(Ключевое слово «protected» означает, что только расширенные классы могут получить доступ к этим методам и переменным.)

Spyro

Интерфейс - это контракт между двумя сторонами, который является инвариантным, высеченным в камне и, следовательно, окончательным. См. Дизайн по контракту .

Интерфейс: Служба системных требований.

В интерфейсе переменные по умолчанию присваиваются модификатором public, static, final access. Так как :

public: иногда случается, что интерфейс может быть помещен в какой-то другой пакет. Таким образом, необходимо получить доступ к переменной из любого места в проекте.

статический: как таковой неполный класс не может создать объект. Таким образом, в проекте нам нужно получить доступ к переменной без объекта, чтобы мы могли получить доступ с помощьюinterface_filename.variable_name

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

В Javaинтерфейс не позволяет объявлять переменные экземпляра. Использование переменной, объявленной в интерфейсе в качестве переменной экземпляра, вернет ошибку времени компиляции.

Вы можете объявить постоянную переменную, использование static finalкоторой отличается от переменной экземпляра.

Интерфейс может быть реализован любыми классами, и что, если это значение было изменено одним из реализующих его классов, тогда будут введены в заблуждение другие реализующие классы. Интерфейс в основном является ссылкой для объединения двух связанных, но разных сущностей. Поэтому по этой причине объявленная переменная внутри интерфейса будет неявно конечной, а также статической, поскольку интерфейс не может быть создан.

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

Только что попробовал в Eclipse, переменная в интерфейсе по умолчанию является окончательной, поэтому вы не можете ее изменить. По сравнению с родительским классом переменные однозначно изменяемы. Зачем? С моей точки зрения, переменная в классе - это атрибут, который будет наследоваться детьми, и дети могут изменять его в соответствии с их реальной потребностью. Напротив, интерфейс определяет только поведение, а не атрибут. Единственная причина для добавления переменных в интерфейс - это использовать их как константы, связанные с этим интерфейсом. Тем не менее, это не очень хорошая практика, согласно следующей выдержке:

«Размещение констант в интерфейсе было популярной техникой в ​​первые дни Java, но теперь многие считают это отвратительным использованием интерфейсов, поскольку интерфейсы должны иметь дело со службами, предоставляемыми объектом, а не его данными. Кроме того, используемые константы классом обычно являются детали реализации, но размещение их в интерфейсе продвигает их к общедоступному API класса ".

Я тоже пробовал либо ставить статичную, либо не делать разницы вообще. Код как ниже:

public interface Addable {
    static int count = 6;

    public int add(int i);

}

public class Impl implements Addable {

    @Override
    public int add(int i) {
        return i+count;
    }
}

public class Test {

    public static void main(String... args) {
        Impl impl = new Impl();

        System.out.println(impl.add(4));
    }
}