Объявление интерфейса может содержать модификаторы интерфейса.

Правила для модификаторов аннотаций в объявлении интерфейса указаны в §9.7.4 и §9.7.5.

Модификатор доступа public (§6.6) относится ко всем видам объявлений интерфейсов.

Модификаторы доступа protected и private относятся только к вложенным интерфейсам, объявления которых непосредственно заключены в объявлении класса (§8.5.1).

Модификатор static относится только к вложенным интерфейсам (§8.5.1, §9.5), а не к интерфейсам верхнего уровня (§7.6).

Если одно и то же ключевое слово появляется более одного раза в качестве модификатора для объявления интерфейса, это является ошибкой компиляции.

Если в объявлении интерфейса присутствуют два или более (различных) модификатора интерфейса, то принято, хотя и необязательно, что они появляются в порядке, соответствующем показанному выше в производстве для МодификатораИнтерфейса.

Интерфейс является обобщённым, если он объявляет одну или более переменные типов (§4.4).

Эти переменные типов известны как параметры типов интерфейса. Раздел параметров типа следует за именем интерфейса и ограничен угловыми скобками.

Следующие правила из §8.1.2 и §4.4 показаны здесь для удобства:

Правила для модификаторов аннотаций в объявлении параметра типа указаны в §9.7.4 и §9.7.5.

В разделе параметров типа интерфейса переменная типа T непосредственно зависит от переменной типа S, если S является границей T, в то время как T зависит от S, если либо T непосредственно зависит от S, либо T непосредственно зависит от переменной типа U, которая зависит от S (используя это определение рекурсивно). Это ошибка компиляции, если переменная типа в разделе параметров типа интерфейса зависит от себя.

Область видимости и перекрытие параметра типа интерфейса указаны в §6.3.

Ссылка на параметр типа интерфейса I в любом месте в объявлении поля или члена типа I является ошибкой компиляции.

Объявление обобщённого интерфейса определяет набор параметризованных типов (§4.5), по одному для каждого возможного параметризации раздела параметров типа аргументами типа. Все эти параметризованные типы разделяют один и тот же интерфейс во время выполнения.

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

Эти другие указанные интерфейсы являются прямыми суперинтерфейсами объявляемого интерфейса.

Любой класс, который implements объявленный интерфейс, также считается реализующим все интерфейсы, которые этот интерфейс extends.

Следующее производство из §8.1.5 показано здесь для удобства:

Каждый Тип интерфейса в extends части объявления интерфейса должен указывать доступный тип интерфейса (§6.6), в противном случае произойдет ошибка компиляции.

Если у Тип интерфейса есть аргументы типа, он должен обозначать правильно сформированный параметризованный тип (§4.5), и ни один из аргументов типа не может быть аргументами типа с подстановкой, в противном случае произойдет ошибка компиляции.

Для объявления (возможно, обобщенного) интерфейса I<F₁,...,F_n> (n ≥ 0), прямые суперинтерфейсы типа интерфейса I<F₁,...,F_n> — это типы, указанные в extends части объявления I, если такая extends часть присутствует.

Для объявления обобщенного интерфейса I<F₁,...,F_n> (n > 0), прямые суперинтерфейсы параметризованного типа интерфейса I<T₁,...,T_n>, где T_i (1 ≤ i ≤ n) — это тип, — это все типы J<U₁ θ,...,U_k θ>, где J<U₁,...,U_k> является прямым суперинтерфейсом I<F₁,...,F_n> и θ — это подстановка [F1:=T1,...,Fn:=Tn].

Взаимоотношение «суперинтерфейс» — это транзитивное замыкание отношения «прямой суперинтерфейс». Интерфейс K является суперинтерфейсом интерфейса I, если выполняется одно из следующих условий:

Интерфейс I называется подинтерфейсом интерфейса K, когда K является суперинтерфейсом I.

Хотя каждый класс является расширением класса Object, не существует одного интерфейса, расширением которого являются все интерфейсы.

Интерфейс I непосредственно зависит от типа T, если T упоминается в extends части I либо как суперинтерфейс, либо как квалификатор в полном квалифицированном имени суперинтерфейса.

Интерфейс I зависит от ссылочного типа T, если выполняется любое из следующих условий:

Ошибка компиляции возникает, если интерфейс зависит от самого себя.

Если при загрузке интерфейсов обнаруживаются циклически объявленные интерфейсы, то генерируется ClassCircularityError (§12.2.1).

Тело интерфейса может объявлять члены интерфейса, то есть поля (§9.3), методы (§9.4), классы (§9.5) и интерфейсы (§9.5).

Область действия объявления члена m, объявленного в или унаследованного типом интерфейса I, указана в §6.3.

Если два метода интерфейса (будь то объявленные в одном интерфейсе, унаследованные одним интерфейсом или один объявлен, а другой унаследован) имеют одинаковое имя, но разные сигнатуры, которые не являются эквивалентными переопределению (§8.4.2), то имя метода называется перегруженным.

Этот факт не вызывает затруднений и сам по себе никогда не приводит к ошибке компиляции. Нет необходимых взаимосвязей между типами возвращаемых значений или между throws-пунктами двух методов с одинаковым именем, но разными сигнатурами, которые не являются эквивалентными переопределению.

interface PointInterface {
    void move(int dx, int dy);
}
interface RealPointInterface extends PointInterface {
    void move(float dx, float dy);
    void move(double dx, double dy);
}

Метод по умолчанию имеет тело блока. Этот блок кода предоставляет реализацию метода в случае, если класс реализует интерфейс, но не предоставляет собственную реализацию метода.

Метод static также имеет тело блока, которое предоставляет реализацию метода.

Ошибка компиляции, если объявление метода интерфейса abstract (явно или неявно) и имеет блок в качестве тела.

Ошибка компиляции, если объявление метода интерфейса default или static и имеет точку с запятой в качестве тела.

Ошибка компиляции, если тело метода static пытается обратиться к текущему объекту с использованием ключевого слова this или ключевого слова super.

Правила для return операторов в теле метода указаны в §14.17.

Если метод объявлен с типом возвращаемого значения (§8.4.5), то возникает ошибка компиляции, если тело метода может завершиться нормально (§14.1).

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

В силу правила AnnotationTypeElementDeclaration, объявление метода в объявлении типа аннотации не может иметь формальные параметры, параметры типа или throws-клаузу. Следующее правило из §4.3 приводится здесь для удобства:

В силу правила AnnotationTypeElementModifier, объявление метода в объявлении типа аннотации не может быть default или static. Таким образом, тип аннотации не может объявлять столько же методов, сколько обычный тип интерфейса. Обратите внимание, что тип аннотации всё ещё может унаследовать метод по умолчанию от своего неявного суперинтерфейса, java.lang.annotation.Annotation, хотя такого метода по умолчанию нет в Java SE 8.

По соглашению, единственными AnnotationTypeElementModifierами, которые должны присутствовать в элементе типа аннотации, являются аннотации.

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

@interface Verboten {
    String[][] value();
}

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

Если любой метод, объявленный в типе аннотации, имеет сигнатуру, эквивалентную по переопределению любой public или protected методу, объявленному в классе Object или в интерфейсе java.lang.annotation.Annotation, это является ошибкой компиляции.

Если объявление типа аннотации T содержит элемент типа T, прямо или косвенно, это является ошибкой компиляции.

@interface SelfRef { SelfRef value(); }

@interface Ping { Pong value(); }
@interface Pong { Ping value(); }

Тип аннотации без элементов называется типом аннотации-метки.

Тип аннотации с одним элементом называется типом аннотации с одним элементом.

По соглашению, имя единственного элемента в типе аннотации с одним элементом — value. Языковая поддержка этого соглашения предоставляется аннотациями с одним элементом (§9.7.3).

/**
 * Describes the "request-for-enhancement" (RFE)
 * that led to the presence of the annotated API element.
 */
@interface RequestForEnhancement {
    int    id();        // Unique ID number associated with RFE
    String synopsis();  // Synopsis of RFE
    String engineer();  // Name of engineer who implemented RFE
    String date();      // Date RFE was implemented
}

/**
 * An annotation with this type indicates that the 
 * specification of the annotated API element is 
 * preliminary and subject to change.
 */
@interface Preliminary {}

/**
 * Associates a copyright notice with the annotated API element.
 */
@interface Copyright {
    String value();
}

/**
 * Associates a list of endorsers with the annotated class.
 */
@interface Endorsers {
    String[] value();
}

interface Formatter {}

// Designates a formatter to pretty-print the annotated class
@interface PrettyPrinter {
    Class<? extends Formatter> value();
}

/**
 * Indicates the author of the annotated program element.
 */
@interface Author {
    Name value();
}
/**
 * A person's name.  This annotation type is not designed
 * to be used directly to annotate program elements, but to
 * define elements of other annotation types.
 */
@interface Name {
    String first();
    String last();
}

@interface Quality {
    enum Level { BAD, INDIFFERENT, GOOD }
    Level value();
}

Элемент типа аннотации может иметь значение по умолчанию, указанное после списка параметров элемента (пустого) с ключевым словом default и Значением элемента (§9.7.1).

Если тип элемента не соответствует (§9.7) указанному значению по умолчанию, это ошибка времени компиляции.

Значения по умолчанию не компилируются в аннотации, а применяются динамически во время чтения аннотаций. Таким образом, изменение значения по умолчанию влияет на аннотации даже в классах, которые были скомпилированы до внесения изменений (при условии, что эти аннотации не имеют явного значения для элемента по умолчанию).

@interface RequestForEnhancementDefault {
    int    id();       // No default - must be specified in 
                       // each annotation
    String synopsis(); // No default - must be specified in 
                       // each annotation
    String engineer()  default "[unassigned]";
    String date()      default "[unimplemented]";
}

Обычная аннотация указывает имя типа аннотации и, необязательно, список пар имя-значение элементов через запятые. Каждая пара содержит значение элемента, связанное с элементом типа аннотации (§9.6.1).

Обратите внимание, что знак «@» (@) является отдельным токеном (§3.11). Разрешено помещать пробелы между ним и ИмяТипа, но это не рекомендуется по соображениям стиля.

ИмяТипа задаёт тип аннотации, соответствующей аннотации. Аннотация считается «типа» этого типа.

Если ИмяТипа не указывает доступный тип аннотации (§6.6) в точке появления аннотации, это ошибка компиляции.

Идентификатор в паре имя-значение должен быть простым именем одного из элементов (т.е. методов) типа аннотации; в противном случае произойдёт ошибка компиляции.

Тип возвращаемого значения этого метода определяет тип элемента пары имя-значение.

Если тип элемента — массив, то не обязательно использовать фигурные скобки для указания значения элемента в паре имя-значение. Если значение элемента не является ИнициализаторМассиваЗначенийЭлементов, то со значением элемента связывается массив, содержащий только это значение элемента. Если значение элемента — ИнициализаторМассиваЗначенийЭлементов, то со значением элемента связывается массив, представленный этим инициализатором.

Ошибка компиляции возникает, если тип элемента не совместим со значением элемента. Тип элемента T совместим со значением элемента V тогда и только тогда, когда выполняется одно из следующих условий:

Обратите внимание, что если T не является типом массива или типом аннотации, значение элемента должно быть УсловнымВыражением (§15.25). Использование УсловногоВыражения, а не более общей конструкции, подобной Выражению, является синтаксическим приёмом, предотвращающим использование выражений присваивания в качестве значений элементов. Так как выражение присваивания не является константным выражением, оно не может быть совместимым значением элемента для примитивного или String-типизированного элемента.

Формально, говорить о ЗначенииЭлемента как о строго FP (§15.4) некорректно, так как оно может быть аннотацией или литералом класса. Тем не менее, можно говорить о ЗначенииЭлемента как о строго FP, когда это константное выражение, массив константных выражений или аннотация, значения элементов которой (рекурсивно) являются константными выражениями; в конце концов, каждое константное выражение является строго FP.

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

Обычная аннотация может, но не обязана, содержать пары имя-значение для элементов со значениями по умолчанию.

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

Аннотация на объявлении типа аннотации называется метааннотацией.

Аннотация типа T может появиться как метааннотация в объявлении типа T самого по себе. Более того, цикличности в транзитивном замыкании отношения «аннотирует» допустимы.

Например, допустимо аннотировать объявление типа аннотации S метааннотацией типа T, а само объявление T — метааннотацией типа S. В предварительно определённых типах аннотаций есть несколько таких цикличности.

@RequestForEnhancement(
    id       = 2868724,
    synopsis = "Provide time-travel functionality",
    engineer = "Mr. Peabody",
    date     = "4/1/2004"
)
public static void travelThroughTime(Date destination) { ... }

@RequestForEnhancement(
    id       = 4561414,
    synopsis = "Balance the federal budget"
)
public static void balanceFederalBudget() {
    throw new UnsupportedOperationException("Not implemented");
}

Аннотация-метка — это сокращённая запись, предназначенная для использования с типами аннотаций-меток (§9.6.1).

Она является сокращением для обычной аннотации:

@TypeName()

Разрешено использовать аннотации-метки для типов аннотаций с элементами, при условии, что все элементы имеют значения по умолчанию (§9.6.2).

@Preliminary public class TimeTravel { ... }

Аннотация с одним элементом — это сокращение, предназначенное для использования с типами аннотаций с одним элементом (§9.6.1).

Она является сокращением для обычной аннотации:

@TypeName(value = ElementValue)

Разрешено использовать аннотации с одним элементом для типов аннотаций с несколькими элементами, при условии, что один элемент имеет имя value, а все остальные элементы имеют значения по умолчанию (§9.6.2).

@Copyright("2002 Yoyodyne Propulsion Systems, Inc.")
public class OscillationOverthruster { ... }

@Endorsers({"Children", "Unscrupulous dentists"})
public class Lollipop { ... }

@Endorsers("Epicurus")
public class Pleasure { ... }

class GorgeousFormatter implements Formatter { ... }

@PrettyPrinter(GorgeousFormatter.class)
public class Petunia { ... }

// Illegal; String is not a subtype of Formatter
@PrettyPrinter(String.class)
public class Begonia { ... }

@Author(@Name(first = "Joe", last = "Hacker"))
public class BitTwiddle { ... }

@Quality(Quality.Level.GOOD)
public class Karma { ... }

Ошибка компиляции, если в контексте объявления или контексте типа появляются несколько аннотаций одного типа T, если T не повторяемая (§9.6.3) и оба T и содержащий тип аннотации T применимы в контексте объявления или контексте типа (§9.6.4.1).

Хотя это не обязательно, принято, чтобы несколько аннотаций одного типа располагались непрерывно.

Если контекст объявления или контекст типа содержит несколько аннотаций повторяемого типа аннотации T, то считается, что контекст не содержит явно объявленных аннотаций типа T и содержит одну неявно объявленную аннотацию содержащего типа аннотации T.

Неявно объявленная аннотация называется контейнерной аннотацией, а несколько аннотаций типа T, которые появились в контексте, называются базовыми аннотациями. Элементы (массива) value элемента контейнерной аннотации — это все базовые аннотации в порядке следования слева направо, в котором они появились в контексте.

Ошибка компиляции, если в контексте объявления или контексте типа есть несколько аннотаций повторяемого типа аннотации T и какие-либо аннотации содержащего типа аннотации T.

Другими словами, повторение аннотаций, где аннотация того же типа, что и их контейнер, также присутствует, невозможно. Это запрещает запутанный код, например:

@Foo(0) @Foo(1) @FooContainer({@Foo(2)})
class A {}

Если бы этот код был допустим, потребовались бы несколько уровней вложенности: сначала аннотации типа Foo содержались бы неявно объявленной контейнерной аннотацией типа FooContainer, а затем эта аннотация и явно объявленная аннотация типа FooContainer содержались бы в ещё одной неявно объявленной аннотации. Эта сложность нежелательна, по мнению разработчиков языка программирования Java. Другой подход, рассматривающий аннотации типа Foo так, как будто они появились рядом с @Foo(2) в явной аннотации @FooContainer, нежелателен, потому что это может изменить то, как рефлексивные программы интерпретируют аннотацию @FooContainer.

Ошибка компиляции, если в контексте объявления или контексте типа присутствует одна аннотация повторяемого типа аннотации T и несколько аннотаций содержащего типа аннотации T.

Это правило предназначено для того, чтобы разрешить следующий код:

@Foo(1) @FooContainer({@Foo(2)})
class A {}

При наличии только одной аннотации повторяемого типа аннотации Foo, контейнерная аннотация не объявляется неявно, даже если FooContainer является содержащим типом аннотации Foo. Однако повторение аннотации типа FooContainer, как в:

@Foo(1) @FooContainer({@Foo(2)}) @FooContainer({@Foo(3)})
class A {}

запрещено, даже если FooContainer повторяема с собственным типом содержащей аннотации. Нежелательно повторять аннотации, которые сами являются контейнерами, когда присутствует аннотация базового повторяемого типа.