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

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

Модификатор доступа public (§6.6) относится только к классам верхнего уровня (§7.6) и внутренним классам (§8.5), а не к локальным классам (§14.3) или анонимным классам (§15.9.5).

Модификаторы доступа protected и private относятся только к внутренним классам внутри непосредственно окружающего объявления класса (§8.5).

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

Ошибка компиляции, если одно и то же ключевое слово появляется более одного раза в качестве модификатора для объявления класса, или если объявление класса имеет более одного из модификаторов доступа public, protected и private (§6.6).

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

abstract class Point {
    int x = 1, y = 1;
    void move(int dx, int dy) {
        x += dx;
        y += dy;
        alert();
    }
    abstract void alert();
}
abstract class ColoredPoint extends Point {
    int color;
}
class SimplePoint extends Point {
    void alert() { }
}

Point p = new Point();

Point p = new SimplePoint();

interface Colorable {
    void setColor(int color);
}
abstract class Colored implements Colorable {
    public abstract int setColor(int color);
}

public final class Math {
    private Math() { }  // never instantiate this class
    . . . declarations of class variables and methods . . .
}

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

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

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

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

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

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

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

Vector<String>  x = new Vector<String>();
Vector<Integer> y = new Vector<Integer>();
boolean b = x.getClass() == y.getClass();

Ошибка компиляции возникает, если обобщённый класс является непосредственным или косвенным подклассом Throwable (§11.1.1).

Это ограничение необходимо, так как механизм обработки исключений Java Virtual Machine работает только с необобщёнными классами.

Ошибка компиляции возникает при ссылке на параметр типа обобщённого класса C в любом из следующего:

interface ConvertibleTo<T> {
    T convert();
}
class ReprChange<T extends ConvertibleTo<S>,
                 S extends ConvertibleTo<T>> { 
    T t; 
    void set(S s) { t = s.convert();    } 
    S get()       { return t.convert(); } 
}

class Seq<T> { 
    T      head;
    Seq<T> tail;

    Seq() { this(null, null); } 
    Seq(T head, Seq<T> tail) {
        this.head = head;
        this.tail = tail;
    }
    boolean isEmpty() { return tail == null; }

    class Zipper<S> { 
        Seq<Pair<T,S>> zip(Seq<S> that) { 
            if (isEmpty() || that.isEmpty()) {
                return new Seq<Pair<T,S>>(); 
            } else {
                Seq<T>.Zipper<S> tailZipper =
                    tail.new Zipper<S>();
                return new Seq<Pair<T,S>>( 
                    new Pair<T,S>(head, that.head),
                    tailZipper.zip(that.tail));
            }
        }
    }
}
class Pair<T, S> {
    T fst; S snd;
    Pair(T f, S s) { fst = f; snd = s; }
}
class Test {
    public static void main(String[] args) {
        Seq<String> strs =
            new Seq<String>(
                "a",
                new Seq<String>("b",
                                new Seq<String>()));
        Seq<Number> nums =
            new Seq<Number>(
                new Integer(1),
                new Seq<Number>(new Double(1.5),
                                new Seq<Number>()));

        Seq<String>.Zipper<Number> zipper =
            strs.new Zipper<Number>();

        Seq<Pair<String,Number>> combined =
            zipper.zip(nums);
    }
}

Вложенный класс — это вложенный класс, который не объявлен явно или неявно static.

Вложенный класс может быть классом-членом, не являющимся static (§8.5), локальным классом (§14.3) или анонимным классом (§15.9.5). Класс-член интерфейса неявно static (§9.5), поэтому никогда не считается вложенным классом.

Если вложенный класс объявляет статический инициализатор (§8.7), это ошибка компиляции.

Если вложенный класс объявляет член, который явно или неявно static, то это ошибка компиляции, за исключением случая, когда этот член — константная переменная (§4.12.4).

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

Вложенный класс, который не является вложенным, может объявлять static члены свободно, в соответствии с общими правилами языка программирования Java.

class HasStatic {
    static int j = 100;
}
class Outer {
    class Inner extends HasStatic {
        static final int x = 3;  // OK: constant variable
        static int y = 4;  // Compile-time error: an inner class
    }
    static class NestedButNotInner{
        static int z = 5;    // OK: not an inner class
    }
    interface NeverInner {}  // Interfaces are never inner
}

Оператор или выражение находятся в статическом контексте, если и только если самый внутренний метод, конструктор, инициализатор экземпляра, статический инициализатор, инициализатор поля или оператор явного вызова конструктора, окружающий оператор или выражение, является статическим методом, статическим инициализатором, инициализатором статической переменной или оператором явного вызова конструктора (§8.8.7.1).

Вложенный класс C является непосредственным вложенным классом класса или интерфейса O, если O — это непосредственно окружающее объявление типа для C, и объявление C не происходит в статическом контексте.

Класс C является вложенным классом класса или интерфейса O, если он является либо непосредственным вложенным классом O, либо вложенным классом вложенного класса O.

Необычно, но возможно, что непосредственно окружающее объявление типа для вложенного класса — это интерфейс. Это происходит только в том случае, если класс объявлен в теле метода по умолчанию (§9.4). В частности, это происходит, если анонимный или локальный класс объявлен в теле метода по умолчанию или класс-член объявлен в теле анонимного класса, объявленного в теле метода по умолчанию.

Класс или интерфейс O является нулевым лексически окружающим объявлением типа для самого себя.

Класс O является n-м лексически окружающим объявлением типа для класса C, если он является непосредственно окружающим объявлением типа для (n-1)-го лексически окружающего объявления типа для C.

Экземпляр i непосредственного вложенного класса C класса или интерфейса O связан с экземпляром O, который известен как непосредственно окружающий экземпляр i. Непосредственно окружающий экземпляр объекта, если таковой имеется, определяется при создании объекта (§15.9.2).

Объект o является нулевым лексически окружающим экземпляром самого себя.

Объект o является n-м лексически окружающим экземпляром экземпляра i, если он является непосредственно окружающим экземпляром (n-1)-го лексически окружающего экземпляра i.

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

Для каждого суперкласса S класса C, который сам является непосредственным вложенным классом класса или интерфейса SO, существует экземпляр SO, связанный с i, который известен как непосредственно окружающий экземпляр i относительно S. Непосредственно окружающий экземпляр объекта относительно непосредственного суперкласса его класса, если таковой имеется, определяется при вызове конструктора суперкласса через оператор явного вызова конструктора (§8.8.7.1).

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

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

Любая локальная переменная, используемая, но не объявленная во вложенном классе, должна быть однозначно присвоена (§16 (Однозначное присвоение)) перед телом вложенного класса, в противном случае возникает ошибка компиляции.

Аналогичные правила использования переменных применяются в теле лямбда-выражения (§15.27.2).

Пустое final поле (§4.12.4) лексически окружающего объявления типа не может быть присвоено внутри вложенного класса, в противном случае возникает ошибка компиляции.

class Outer {
    int i = 100;
    static void classMethod() {
        final int l = 200;
        class LocalInStaticContext {
            int k = i;  // Compile-time error
            int m = l;  // OK
        }
    }
    void foo() {
        class Local {  // A local class
            int j = i;
        }
    }
}

class WithDeepNesting {
    boolean toBe;
    WithDeepNesting(boolean b) { toBe = b; }

    class Nested {
        boolean theQuestion;
        class DeeplyNested {
            DeeplyNested(){
                theQuestion = toBe || !toBe;
            }
        }
    }
}

Необязательная extends фраза в объявлении обычного класса указывает прямой родительский класс текущего класса.

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

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

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

Если Тип класса называет класс Enum или любое обращение к Enum (§8.9), произойдёт ошибка компиляции.

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

Учитывая объявление класса (возможно, обобщённого) C<F₁,...,F_n> (n ≥ 0, C ≠ Object), прямой родительский класс типа класса C<F₁,...,F_n> определяется значением в extends фразе объявления C, если такая фраза присутствует, или extends в противном случае.

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

Класс считается прямым потомком своего прямого родителя. Прямой родитель — это класс, чья реализация используется для реализации текущего класса.

Отношение «потомок» — это транзитивное замыкание отношения «прямой потомок». Класс A является потомком класса C, если верно одно из следующих утверждений:

Класс C является родительским классом класса A, когда A является потомком C.

class Point { int x, y; }
final class ColoredPoint extends Point { int color; }
class Colored3DPoint extends ColoredPoint { int z; }  // error

class Point { int x, y; }
class ColoredPoint extends Point { int color; }
final class Colored3dPoint extends ColoredPoint { int z; }

Класс C непосредственно зависит от типа T, если T упоминается в extends или implements фразе C в качестве родительского класса или родительского интерфейса, или в качестве квалификатора в полном квалифицированном имени родительского класса или родительского интерфейса.

Класс C зависит от ссылочного типа T, если верно одно из следующих утверждений:

Если класс зависит от самого себя, это ошибка компиляции.

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

class Point extends ColoredPoint { int x, y; }
class ColoredPoint extends Point { int color; }

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

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

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

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

class Redundant implements java.lang.Cloneable, Cloneable {
    int x;
}

Для объявления класса (возможно, обобщённого) C<F₁,...,F_n> (n ≥ 0, C ≠ Object), непосредственные промежуточные интерфейсы типа класса C<F₁,...,F_n> являются типами, указанными в implements фразе объявления C, если такая фраза присутствует.

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

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

Класс может иметь промежуточный интерфейс несколькими способами.

Класс считается реализующим все свои промежуточные интерфейсы.

Класс не может одновременно быть подтипом двух типов интерфейсов, которые являются различными параметризациями одного и того же обобщённого интерфейса (§9.1.2), или подтипом параметризации обобщённого интерфейса и исходного типа, обозначающего тот же обобщённый интерфейс, в противном случае произойдёт ошибка компиляции.

Это требование было введено для поддержки трансляции путём стирания типов (§4.6).

interface Colorable {
    void setColor(int color);
    int getColor();
}
enum Finish { MATTE, GLOSSY }
interface Paintable extends Colorable {
    void setFinish(Finish finish);
    Finish getFinish();
}

class Point { int x, y; }
class ColoredPoint extends Point implements Colorable {
    int color;
    public void setColor(int color) { this.color = color; }
    public int getColor() { return color; }
}
class PaintedPoint extends ColoredPoint implements Paintable {
    Finish finish;
    public void setFinish(Finish finish) {
        this.finish = finish;
    }
    public Finish getFinish() { return finish; }
}

interface I<T> {}
class B implements I<Integer> {}
class C extends B implements I<String> {}

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

Каждый метод по умолчанию (§9.4.3) промежуточного интерфейса класса может быть переопределён методом в классе; в противном случае метод по умолчанию обычно наследуется, и его поведение соответствует заданному его телом по умолчанию.

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

interface Colorable {
    void setColor(int color);
    int getColor();
}
class Point { int x, y; };
class ColoredPoint extends Point implements Colorable {
    int color;
}

interface Fish  { int getNumberOfScales(); }
interface Piano { int getNumberOfScales(); }
class Tuna implements Fish, Piano {
    // You can tune a piano, but can you tuna fish?
    public int getNumberOfScales() { return 91; }
}

interface Fish       { int    getNumberOfScales(); }
interface StringBass { double getNumberOfScales(); }
class Bass implements Fish, StringBass {
    // This declaration cannot be correct,
    // no matter what type is used.
    public ?? getNumberOfScales() { return 91; }
}

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

Тело класса также может содержать инициализаторы экземпляров (§8.6), статические инициализаторы (§8.7) и объявления конструкторов (§8.8) для класса.

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

Если сам C является вложенным классом, могут быть определения того же типа (переменной, метода или типа) и имени, что и m во внешних областях действия. (Области действия могут быть блоками, классами или пакетами.) Во всех таких случаях член m, объявленный в или унаследованный от C, затемняет (§6.4.1) другие определения того же типа и имени.

Если в объявлении поля у оператора есть инициализатор переменной, то у этого оператора есть семантика присваивания (§15.26) объявленной переменной.

Если оператор относится к переменной класса (то есть к static полю), то к его инициализатору применяются следующие правила:

Если оператор относится к переменной экземпляра (то есть полю, которое не является static), то к его инициализатору применяются следующие правила:

Ссылки из инициализаторов переменных на поля, которые могут ещё не быть инициализированы, подчиняются дополнительным ограничениям, как указано в §8.3.3 и §16 (Определённое присваивание).

Проверка исключений для инициализатора переменной в объявлении поля указана в §11.2.3.

Инициализаторы переменных также используются в объявлениях локальных переменных (§14.4), где инициализатор вычисляется и присваивание выполняется каждый раз при выполнении объявления локальной переменной.

class Point {
    int x = 1, y = 5;
}
class Test {
    public static void main(String[] args) {
        Point p = new Point();
        System.out.println(p.x + ", " + p.y);
    }
}

1, 5

class Test {
    float f = j;
    static int j = 1;
}

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

Для ссылки по простому имени на переменную класса f, объявленную в классе или интерфейсе C, это ошибка времени компиляции, если:

Для ссылки по простому имени на переменную экземпляра f, объявленную в классе C, это ошибка времени компиляции, если:

class Test1 {
    int i = j;  // compile-time error:
                // incorrect forward reference
    int j = 1;
}

class Test2 {
    Test2() { k = 2; }
    int j = 1;
    int i = j;
    int k;
}

class Z {
    static int i = j + 2; 
    static int j = 4;
}

class Z {
    static { i = j + 2; }
    static int i, j;
    static { j = 4; }
}

class Z {
    static int peek() { return j; }
    static int i = peek();
    static int j = 1;
}
class Test {
    public static void main(String[] args) {
        System.out.println(Z.i);
    }
}

0

class UseBeforeDeclaration {
    static {
        x = 100;
          // ok - assignment
        int y = x + 1;
          // error - read before declaration
        int v = x = 3;
          // ok - x at left hand side of assignment
        int z = UseBeforeDeclaration.x * 2;
          // ok - not accessed via simple name

        Object o = new Object() { 
            void foo() { x++; }
              // ok - occurs in a different class
            { x++; }
              // ok - occurs in a different class
        };
    }

    {
        j = 200;
          // ok - assignment
        j = j + 1;
          // error - right hand side reads before declaration
        int k = j = j + 1;
          // error - illegal forward reference to j
        int n = j = 300;
          // ok - j at left hand side of assignment
        int h = j++;
          // error - read before declaration
        int l = this.j * 3;
          // ok - not accessed via simple name

        Object o = new Object() { 
            void foo(){ j++; }
              // ok - occurs in a different class
            { j = j + 1; }
              // ok - occurs in a different class
        };
    }

    int w = x = 3;
      // ok - x at left hand side of assignment
    int p = x;
      // ok - instance initializers may access static fields

    static int u =
        (new Object() { int bar() { return x; } }).bar();
	    // ok - occurs in a different class

    static int x;

    int m = j = 4;
      // ok - j at left hand side of assignment
    int o =
        (new Object() { int bar() { return j; } }).bar(); 
        // ok - occurs in a different class
    int j;
}

Формальные параметры метода или конструктора, если таковые имеются, указываются списком параметров, разделённых запятыми. Каждый параметр состоит из типа (при необходимости, предваряемого модификатором final и/или одним или несколькими аннотациями) и идентификатора (при необходимости, за которым следуют квадратные скобки), определяющего имя параметра.

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

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

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

В грамматике для VariableArityParameter обратите внимание, что эллипсы (...) — это самостоятельный токен (§3.11). Разрешается вставлять пробелы между эллипсами и типом, но с точки зрения стиля это не рекомендуется.

Если последний формальный параметр является параметром с переменным числом аргументов, то метод является методом с переменным числом аргументов. В противном случае это метод с фиксированным числом аргументов.

Правила аннотаций-модификаторов в объявлении формального параметра и в объявлении параметра получателя задаются в §9.7.4 и §9.7.5.

Ошибка компиляции возникает, если final используется более одного раза как модификатор в объявлении формального параметра.

Область действия и затенение формального параметра определяются в §6.3 и §6.4.

Ошибка компиляции возникает, если метод или конструктор объявляют два формальных параметра с одинаковым именем. (То есть, в их объявлениях упоминается тот же Identifier.)

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

Объявленный тип формального параметра зависит от того, является ли он параметром с переменным числом аргументов:

Если объявленный тип параметра с переменным числом аргументов имеет нереализуемый элементный тип (§4.7), то при объявлении метода с переменным числом аргументов возникает предупреждение компилятора, если метод не аннотирован @SafeVarargs (§9.6.4.7) или предупреждение не подавляется с помощью @SuppressWarnings (§9.6.4.5).

При вызове метода или конструктора (§15.12) значения выражений фактических аргументов инициализируют вновь созданные переменные параметров, каждый из которых имеет объявленный тип, перед выполнением тела метода или конструктора. Identifier, который появляется в FormalParameter, может использоваться как простое имя в теле метода или конструктора для ссылки на формальный параметр.

Вызовы метода с переменным числом аргументов могут содержать больше выражений фактических аргументов, чем формальных параметров. Все выражения фактических аргументов, которые не соответствуют формальным параметрам, предшествующим параметру с переменным числом аргументов, будут вычислены, и результаты будут сохранены в массиве, который будет передан в вызов метода (§15.12.4.2).

Формальный параметр метода или конструктора типа float всегда содержит элемент множества значений с плавающей точкой (§4.2.3); аналогично, формальный параметр метода или конструктора типа double всегда содержит элемент множества значений с двойной точностью. Не разрешается, чтобы формальный параметр метода или конструктора типа float содержал элемент множества значений с плавающей точкой расширенной экспоненты, который не является элементом множества значений с плавающей точкой, а также для формального параметра метода или конструктора типа double содержал элемент множества значений с двойной точностью расширенной экспоненты, который не является элементом множества значений с двойной точностью.

Там, где выражение фактического аргумента, соответствующее переменной параметра, не является FP-строгим (§15.4), вычисление этого выражения фактического аргумента разрешает использование промежуточных значений из соответствующих множеств значений с расширенной экспонентой. Перед сохранением в переменной параметра результат такого выражения преобразуется к ближайшему значению в соответствующем стандартном множестве значений путём применения преобразования вызова (§5.3).

class Test {
    Test(/* ?? ?? */) {}
      // No receiver parameter is permitted in the constructor of
      // a top level class, as there is no conceivable type or name.

    void m(Test this) {}
      // OK: receiver parameter in an instance method

    static void n(Test this) {}
      // Illegal: receiver parameter in a static method                         

    class A {
        A(Test Test.this) {}
          // OK: the receiver parameter represents the instance
          // of Test which immediately encloses the instance
          // of A being constructed.

        void m(A this) {}
          // OK: the receiver parameter represents the instance 
          // of A for which A.m() is invoked.

        class B {
            B(Test.A A.this) {}
              // OK: the receiver parameter represents the instance 
              // of A which immediately encloses the instance of B 
              // being constructed.

            void m(Test.A.B this) {}
              // OK: the receiver parameter represents the instance 
              // of B for which B.m() is invoked.
        }
    }
}

Два метода или конструктора, M и N, имеют одинаковую подпись, если у них одинаковое имя, одинаковые параметры типа (если есть) (§8.4.4), и, после адаптации формальных типов параметров N к параметрам типа M, одинаковые формальные типы параметров.

Подпись метода m1 является подписью-подмножеством подписи метода m2, если выполняется одно из следующих условий:

Две подписи методов m1 и m2 являются эквивалентными для переопределения, если либо m1 является подписью-подмножеством m2, либо m2 является подписью-подмножеством m1.

Объявление двух методов с эквивалентными для переопределения подписями в классе является ошибкой компиляции.

class Point {
    int x, y;
    abstract void move(int dx, int dy);
    void move(int dx, int dy) { x += dx; y += dy; }
}

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

class CollectionConverter {
    List toList(Collection c) {...}
}
class Overrider extends CollectionConverter {
    List toList(Collection c) {...}
}

class CollectionConverter {
    <T> List<T> toList(Collection<T> c) {...}
}

Метод является обобщенным, если он объявляет одну или несколько переменных типа (§4.4).

Эти переменные типа известны как параметры типа метода. Формат раздела параметров типа обобщенного метода идентичен разделу параметров типа обобщенного класса (§8.1.2).

Объявление обобщенного метода определяет набор методов, по одному для каждого возможного вызова раздела параметров типа с помощью аргументов типа. Аргументы типа могут не нуждаться в явном указании при вызове обобщенного метода, так как они часто могут быть выведены (§18 (Вывод типов)).

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

Два метода или конструктора M и N имеют одинаковые параметры типа, если оба следующих утверждения верны:

Где два метода или конструктора M и N имеют одинаковые параметры типа, тип, упоминаемый в N, может быть адаптирован к параметрам типа M путем применения θ, как определено выше, к типу.

Результат объявления метода либо объявляет тип значения, которое метод возвращает (тип возвращаемого значения), либо использует ключевое слово void, чтобы указать, что метод не возвращает значение.

Если результат не void, то тип возвращаемого значения метода обозначается UnannType, если после списка формальных параметров нет скобок, и задается в §10.2 в противном случае.

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

Объявление метода d1 с типом возвращаемого значения R₁ является заменяемым по типу возвращаемого значения для другого метода d2 с типом возвращаемого значения R₂, если выполняется любое из следующих условий:

Неявное преобразование разрешено в определении, несмотря на то, что оно не обосновано, как специальное разрешение, чтобы обеспечить плавную миграцию от необобщенного к обобщенному коду. Если неявное преобразование используется для определения того, что R₁ заменяемо по типу возвращаемого значения для R₂, то R₁ обязательно не является подтипом R₂, и правила переопределения (§8.4.8.3, §9.4.1) потребуют предупреждения о неявном преобразовании во время компиляции.

Оператор throws используется для обозначения всех типов исключений (§11.1.1), которые могут быть выброшены операторами в теле метода или конструктора (§11.2.2).

Ошибка компиляции возникает, если Тип исключения, указанный в операторе throws, не является подтипом (§4.10) типа исключения.

Переменные типов допускаются в операторе throws, хотя они не допускаются в операторе try (§14.20).

Допускается, но не обязательно указывать классы необрабатываемых исключений (§11.1.1) в операторе throws.

Связь между оператором throws и проверкой исключений для тела метода или конструктора описана в §11.2.3.

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

Требование объявлять обрабатываемые исключения позволяет компилятору Java гарантировать, что код для обработки таких условий ошибки был включен. Методы или конструкторы, которые не обрабатывают исключительные ситуации, выброшенные как обрабатываемые исключения в их телах, обычно вызывают ошибки компиляции, если им не хватает соответствующих типов исключений в операторах throws. Язык программирования Java таким образом поощряет стиль программирования, где редкие и по-настоящему исключительные условия документируются таким образом.

Связь между оператором throws метода и операторами throws переопределенных или скрытых методов указана в §8.4.8.3.

import java.io.FileNotFoundException;
interface PrivilegedExceptionAction<E extends Exception> { 
    void run() throws E;
} 
class AccessController {
    public static <E extends Exception> 
    Object doPrivileged(PrivilegedExceptionAction<E> action) throws E {
        action.run();
        return "success";
    }
}
class Test {
    public static void main(String[] args) {
        try {
            AccessController.doPrivileged(
              new PrivilegedExceptionAction<FileNotFoundException>() {
                  public void run() throws FileNotFoundException {
                      // ... delete a file ...
                  } 
              }); 
        } catch (FileNotFoundException f) { /* Do something */ }
    }
}

Тело метода — это либо блок кода, реализующий метод, либо просто точка с запятой, указывающая на отсутствие реализации.

Тело метода должно быть точкой с запятой, если метод является abstract или native (§8.4.3.1, §8.4.3.4). Более точно:

Если для метода, объявленного void, должна быть предоставлена реализация, но реализация не требует исполняемого кода, тело метода должно быть написано как блок, не содержащий операторов: "{ }".

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

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

Другими словами, метод с типом возвращаемого значения должен возвращать значение только с помощью оператора return, который предоставляет возвращаемое значение; метод не может "выпасть из своего тела". См. §14.17 для точных правил о return операторах в теле метода.

class DizzyDean {
    int pitch() { throw new RuntimeException("90 mph?!"); }
}

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

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

Когда вызывается метод (§15.12), количество фактических аргументов (и любые явные типы аргументов) и типы аргументов во время компиляции используются для определения подписи вызываемого метода (§15.12.2). Если вызываемый метод — это метод экземпляра, фактический вызываемый метод будет определяться во время выполнения с помощью динамического поиска метода (§15.12.4).

class Point {
    float x, y;
    void move(int dx, int dy) { x += dx; y += dy; }
    void move(float dx, float dy) { x += dx; y += dy; }
    public String toString() { return "("+x+","+y+")"; }
}

class Point {
    int x = 0, y = 0;
    void move(int dx, int dy) { x += dx; y += dy; }
    int color;
}
class RealPoint extends Point {
    float x = 0.0f, y = 0.0f;
    void move(int dx, int dy) { move((float)dx, (float)dy); }
    void move(float dx, float dy) { x += dx; y += dy; }
}

class Point {
    int x = 0, y = 0, color;
    void move(int dx, int dy) { x += dx; y += dy; }
    int getX() { return x; }
    int getY() { return y; }
}
class RealPoint extends Point {
    float x = 0.0f, y = 0.0f;
    void move(int dx, int dy) { move((float)dx, (float)dy); }
    void move(float dx, float dy) { x += dx; y += dy; }
    float getX() { return x; }
    float getY() { return y; }
}

class Point {
    int x = 0, y = 0;
    void move(int dx, int dy) { x += dx; y += dy; }
    int getX() { return x; }
    int getY() { return y; }
    int color;
}
class RealPoint extends Point {
    float x = 0.0f, y = 0.0f;
    void move(int dx, int dy) { move((float)dx, (float)dy); }
    void move(float dx, float dy) { x += dx; y += dy; }
    int getX() { return (int)Math.floor(x); }
    int getY() { return (int)Math.floor(y); }
}

class Test {
    public static void main(String[] args) {
        RealPoint rp = new RealPoint();
        Point p = rp;
        rp.move(1.71828f, 4.14159f);
        p.move(1, -1);
        show(p.x, p.y);
        show(rp.x, rp.y);
        show(p.getX(), p.getY());
        show(rp.getX(), rp.getY());
    }
    static void show(int x, int y) {
        System.out.println("(" + x + ", " + y + ")");
    }
    static void show(float x, float y) {
        System.out.println("(" + x + ", " + y + ")");
    }
}

(0, 0)
(2.7182798, 3.14159)
(2, 3)
(2, 3)

Формальные параметры конструктора идентичны по синтаксису и семантике формальным параметрам метода (§8.4.1).

Конструктор не-private внутреннего вложенного класса неявно объявляет в качестве первого формального параметра переменную, представляющую немедленно окружающий экземпляр класса (§15.9.2, §15.9.3).

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

Тот факт, что не-private внутренний вложенный класс может быть доступен другим компилятором, чем тот, который его скомпилировал, в то время как локальный или анонимный класс всегда доступен тому же компилятору, что и скомпилировал его, объясняет, почему бинарное имя не-private внутреннего вложенного класса определяется как предсказуемое, но бинарное имя локального или анонимного класса не является таковым (§13.1).

Ошибка компиляции возникает, если в классе объявлены два конструктора с совместимыми подписями (§8.4.2).

Ошибка компиляции возникает, если в классе объявлены два конструктора с одинаковой стёртой подписью (§4.6).

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

Если одно и то же ключевое слово встречается более одного раза в качестве модификатора в объявлении конструктора, или если объявление конструктора имеет более одного из модификаторов доступа public, protected и private (§6.6), то это ошибка времени компиляции.

В нормальном объявлении класса объявление конструктора без модификаторов доступа имеет доступ по умолчанию (пакетный доступ).

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

В отличие от методов, конструктор не может быть abstract, static, final, native, strictfp или synchronized:

Конструктор является обобщенным, если он объявляет одну или несколько переменных типа (§4.4).

Эти переменные типа известны как параметры типа конструктора. Формат раздела параметров типа обобщенного конструктора идентичен разделу параметров типа обобщенного класса (§8.1.2).

Конструктор может быть обобщенным независимо от того, является ли класс, в котором он объявлен, обобщенным.

Объявление обобщенного конструктора определяет набор конструкторов, по одному для каждого возможного вызова раздела параметров типа с помощью аргументов типа. Аргументы типа могут не потребоваться явно при вызове обобщенного конструктора, так как их часто можно вывести (§18 (Выведение типов)).

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

Раздел throws для конструктора идентичен по структуре и поведению разделу throws для метода (§8.4.6).

Тип конструктора состоит из его сигнатуры и типов исключений, заданных его разделом throws.

Перегрузка конструкторов по поведению идентична перегрузке методов (§8.4.9). Перегрузка разрешается во время компиляции для каждого выражения создания экземпляра класса (§15.9).

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

Формат конструктора по умолчанию для анонимного класса указан в §15.9.5.1.

Если неявно объявлен конструктор по умолчанию, но у суперкласса нет доступного конструктора, принимающего нуль аргументов и не имеющего throws блока, то это ошибка на этапе компиляции.

public class Point {
    int x, y;
}

public class Point {
    int x, y;
    public Point() { super(); }
}

package p1;
public class Outer {
    protected class Inner {}
}
package p2;
class SonOfOuter extends p1.Outer {
    void foo() {
        new Inner();  // compile-time access error
    }
}

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

Класс public аналогичным образом может предотвратить создание экземпляров вне пакета, объявив по крайней мере один конструктор, чтобы предотвратить создание конструктора по умолчанию с доступом public, и не объявив конструктор с public или protected доступом (§6.6.2).

class ClassOnly {
    private ClassOnly() { }
    static String just = "only the lonely";
}

package just;
public class PackageOnly {
    PackageOnly() { }
    String[] justDesserts = { "cheesecake", "ice cream" };
}

Тело объявления перечисления может содержать константы перечисления. Константа перечисления определяет экземпляр типа перечисления.

Для удобства приведена следующая конструкция из §15.12:

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

Идентификатор в КонстантеПеречисления может использоваться в имени для ссылки на константу перечисления.

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

За константой перечисления могут следовать аргументы, которые передаются в конструктор перечисления при создании константы во время инициализации класса, как описано позже в этом разделе. Вызываемый конструктор выбирается по обычным правилам разрешения перегрузки (§15.12.2). Если аргументы опущены, предполагается пустой список аргументов.

Необязательное тело класса константы перечисления неявным образом определяет объявление анонимного класса (§15.9.5), которое расширяет непосредственно окружающий тип перечисления. Тело класса регулируется обычными правилами анонимных классов; в частности, оно не может содержать конструкторов. Методы экземпляров, объявленные в этих телах классов, могут вызываться за пределами окружающего типа перечисления только в том случае, если они переопределяют доступные методы в окружающем типе перечисления (§8.4.8).

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

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

Метод equals в Enum - это метод final, который просто вызывает super.equals на своём аргументе и возвращает результат, тем самым выполняя сравнение по идентичности.

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

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

Любые объявления конструкторов или членов в теле объявления перечисления применяются к типу перечисления точно так же, как если бы они присутствовали в теле объявления обычного класса, если не указано иное.

Ошибка компиляции, если объявление конструктора в объявлении перечисления является public или protected (§6.6).

Ошибка компиляции, если объявление конструктора в объявлении перечисления содержит оператор вызова конструктора суперкласса (§8.8.7.1).

Ошибка компиляции, если в конструкторе, инициализаторе экземпляра или инициализаторе переменной экземпляра типа перечисления ссылаются на static поле типа перечисления, если это поле не является константной переменной (§4.12.4).

В объявлении перечисления объявление конструктора без модификаторов доступа является private.

В объявлении перечисления без объявлений конструкторов неявно объявлен конструктор по умолчанию. Конструктор по умолчанию является private, не имеет формальных параметров и не имеет throws.

На практике компилятор, вероятно, будет отражать тип Enum, объявляя параметры String и int в конструкторе по умолчанию типа перечисления. Однако эти параметры не указаны как «неявно объявленные», потому что разные компиляторы не должны согласовывать форму конструктора по умолчанию. Только компилятор типа перечисления знает, как создать константы перечисления; другие компиляторы могут просто полагаться на неявно объявленные public static поля типа перечисления (§8.9.3), не заботясь о том, как эти поля были инициализированы.

Ошибка компиляции, если в объявлении перечисления E присутствует abstract метод m в качестве члена, если в E нет хотя бы одной константы перечисления, и все константы перечисления E имеют тела классов, которые предоставляют конкретные реализации m.

Ошибка компиляции для объявления перечисления, которое объявляет финализатор (§12.6). Экземпляр типа перечисления никогда не может быть финализирован.

enum Coin {
    PENNY(1), NICKEL(5), DIME(10), QUARTER(25);
    Coin(int value) { this.value = value; }

    private final int value;
    public int value() { return value; }
}

import java.util.Map;
import java.util.HashMap;

enum Color {
    RED, GREEN, BLUE;
    Color() { colorMap.put(toString(), this); }

    static final Map<String,Color> colorMap =
        new HashMap<String,Color>();
}

import java.util.Map;
import java.util.HashMap;

enum Color {
    RED, GREEN, BLUE;

    static final Map<String,Color> colorMap =
        new HashMap<String,Color>();
    static {
        for (Color c : Color.values())
            colorMap.put(c.toString(), c);
    }
}

Членами типа перечисления E являются все следующие:

Следует, что объявление типа перечисления E не может содержать полей, конфликтующих с неявно объявленными полями, соответствующими константам перечисления E, и не может содержать методов, конфликтующих с неявно объявленными методами или переопределяющих final методы класса Enum<E>.

public class Test {
    enum Season { WINTER, SPRING, SUMMER, FALL }

    public static void main(String[] args) {
        for (Season s : Season.values())
            System.out.println(s);
    }
}

WINTER
SPRING
SUMMER
FALL

class Test {
    enum CoinColor { COPPER, NICKEL, SILVER }

    static CoinColor color(Coin c) {
        switch (c) {
            case PENNY:
                return CoinColor.COPPER;
            case NICKEL:
                return CoinColor.NICKEL;
            case DIME: case QUARTER:
                return CoinColor.SILVER;
            default:
                throw new AssertionError("Unknown coin: " + c);
        }
    }

    public static void main(String[] args) {
        for (Coin c : Coin.values())
            System.out.println(c + "\t\t" +
                               c.value() + "\t" + color(c));
    }
}

PENNY           1       COPPER
NICKEL          5       NICKEL
DIME            10      SILVER
QUARTER         25      SILVER

enum Operation {
    PLUS {
        double eval(double x, double y) { return x + y; }
    },
    MINUS {
        double eval(double x, double y) { return x - y; }
    },
    TIMES {
        double eval(double x, double y) { return x * y; }
    },
    DIVIDED_BY {
        double eval(double x, double y) { return x / y; }
    };

    // Each constant supports an arithmetic operation
    abstract double eval(double x, double y);

    public static void main(String args[]) {
        double x = Double.parseDouble(args[0]);
        double y = Double.parseDouble(args[1]);
        for (Operation op : Operation.values())
            System.out.println(x + " " + op + " " + y +
                               " = " + op.eval(x, y));
    }
}

java Operation 2.0 4.0
2.0 PLUS 4.0 = 6.0
2.0 MINUS 4.0 = -2.0
2.0 TIMES 4.0 = 8.0
2.0 DIVIDED_BY 4.0 = 0.5

import java.util.List;
import java.util.ArrayList;
class Card implements Comparable<Card>,
                      java.io.Serializable {
    public enum Rank { DEUCE, THREE, FOUR, FIVE, SIX, SEVEN,
                       EIGHT, NINE, TEN,JACK, QUEEN, KING, ACE }

    public enum Suit { CLUBS, DIAMONDS, HEARTS, SPADES }

    private final Rank rank;
    private final Suit suit;
    public Rank rank() { return rank; }
    public Suit suit() { return suit; }

    private Card(Rank rank, Suit suit) {
        if (rank == null || suit == null)
            throw new NullPointerException(rank + ", " + suit);
        this.rank = rank;
        this.suit = suit;
    }

    public String toString() { return rank + " of " + suit; }

    // Primary sort on suit, secondary sort on rank
    public int compareTo(Card c) {
        int suitCompare = suit.compareTo(c.suit);
        return (suitCompare != 0 ?
                    suitCompare :
                    rank.compareTo(c.rank));
    }

    private static final List<Card> prototypeDeck =
        new ArrayList<Card>(52);

    static {
        for (Suit suit : Suit.values())
            for (Rank rank : Rank.values())
                prototypeDeck.add(new Card(rank, suit));
    }

    // Returns a new deck
    public static List<Card> newDeck() {
        return new ArrayList<Card>(prototypeDeck);
    }
}

import java.util.List;
import java.util.ArrayList;
import java.util.Collections;
class Deal {
    public static void main(String args[]) {
        int numHands     = Integer.parseInt(args[0]);
        int cardsPerHand = Integer.parseInt(args[1]);
        List<Card> deck  = Card.newDeck();
        Collections.shuffle(deck);
        for (int i=0; i < numHands; i++)
            System.out.println(dealHand(deck, cardsPerHand));
    }

    /**
     * Returns a new ArrayList consisting of the last n
     * elements of deck, which are removed from deck.
     * The returned list is sorted using the elements'
     * natural ordering.
     */
    public static <E extends Comparable<E>>
    ArrayList<E> dealHand(List<E> deck, int n) {
        int deckSize = deck.size();
        List<E> handView = deck.subList(deckSize - n, deckSize);
        ArrayList<E> hand = new ArrayList<E>(handView);
        handView.clear();
        Collections.sort(hand);
        return hand;
    }
}

java Deal 4 3
[DEUCE of CLUBS, SEVEN of CLUBS, QUEEN of DIAMONDS]
[NINE of HEARTS, FIVE of SPADES, ACE of SPADES]
[THREE of HEARTS, SIX of HEARTS, TEN of SPADES]
[TEN of CLUBS, NINE of DIAMONDS, THREE of SPADES]