Глава 8. Классы

Класс является обобщённым, если объявление класса объявляет одну или несколько переменных типов (§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.1.

Ссылки на параметр типа класса из статической области или вложенного класса или интерфейса ограничены, как указано в §6.5.5.1.

Объявление обобщённого класса определяет набор параметризованных типов (§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 работает только с необобщёнными классами.

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);
    }
}

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

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

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

Возникает ошибка компиляции, если ТипКласса называет класс, который является sealed (§8.1.1.2), и объявляемый класс не является разрешённым прямым подклассом указанного класса (§8.1.6).

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

Возникает ошибка компиляции, если ТипКласса называет класс Enum, который может быть расширен только перечислением (§8.9), или называет класс Record, который может быть расширен только классом-записью (§8.10).

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

Прямой тип надкласса класса, в объявлении которого отсутствует extends фраза, следующий:

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

Взаимоотношение «надкласс» — это транзитивное замыкание отношения «прямой надкласс». Класс 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 непосредственно зависит от класса или интерфейса A, если A упоминается в extends или implements фразе C как надкласс или надинтерфейс, или как квалификатор в полном квалифицированном формате имени надкласса или надинтерфейса.

Класс C зависит от класса или интерфейса A, если выполняется любое из следующих условий:

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

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

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

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

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

Если какой-либо Тип интерфейса указывает интерфейс, который является sealed (§9.1.1.4), и объявляемый класс не является разрешенным прямым подклассом указанного интерфейса (§9.1.4), то произойдет ошибка компиляции.

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

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

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

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

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

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

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

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

Говорят, что класс является непосредственным подклассом своих прямых суперинтерфейсов и подклассом всех своих суперинтерфейсов.

Класс не может объявить прямой тип суперкласса и прямой тип суперинтерфейса, или два прямых типа суперинтерфейсов, которые являются, или у которых есть супертипы (§4.10.2), которые являются различными параметризациями одного и того же обобщенного интерфейса (§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; }
}

Необязательная permits фраза в объявлении обычного класса определяет все классы, предназначенные в качестве прямых подклассов объявляемого класса (§8.1.1.2).

Если объявление класса содержит permits фразу, но не содержит sealed модификатор, то это ошибка компиляции.

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

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

package p;

sealed class A     permits B, C, p.B {}  // error

non-sealed class B extends A {}
non-sealed class C extends A {}

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

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

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

Если объявление sealed класса C содержит permits фразу, то разрешённые прямые подклассы C — это классы, указанные в permits фразе.

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

Если в объявлении sealed класса C отсутствует permits фраза, то разрешённые прямые подклассы C следующие:

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

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

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

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

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

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

Если декларатор относится к переменной экземпляра (то есть полю, которое не является 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.

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

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

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

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

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

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

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

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

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 и §6.4.1.

Ссылки на параметр типа метода из вложенного класса или интерфейса ограничены, как указано в §6.5.5.1.

Два метода или конструктора 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) от Throwable, возникает ошибка компиляции.

Переменные типа допускаются в блоке 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.1.

Ссылки на параметр типа конструктора из явного оператора вызова конструктора или вложенного класса или интерфейса ограничены, как указано в §6.5.5.1.

Раздел 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.

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

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

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

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

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

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

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

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

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

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

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

Если в объявлении перечисления из конструктора, инициализатора экземпляра или инициализатора переменной экземпляра ссылаются на поле класса перечисления, это ошибка компиляции, если поле не является константой (§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.HashMap;
import java.util.Map;

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

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

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

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.ArrayList;
import java.util.List;

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.ArrayList;
import java.util.Collections;
import java.util.List;

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]

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

Если у класса записи нет компонентов записи, то в заголовке объявления записи появляется пустая пара скобок.

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

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

Аннотации компонента записи доступны через рефлексию, если их интерфейсы аннотаций применимы в контексте компонента записи (§9.6.4.1). Независимо от этого, аннотации компонента записи передаются в объявления членов и конструкторов класса записи, если их интерфейсы аннотаций применимы в других контекстах (§8.10.3, §8.10.4).

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

Ошибка времени компиляции, если в объявлении записи есть компонент записи с именем clone, finalize, getClass, hashCode, notify, notifyAll, toString или wait.

Это имена методов public и protected без аргументов в Object. Запрет на использование этих имён в качестве имён компонентов записи предотвращает путаницу в ряде случаев. Во-первых, каждый класс записи предоставляет реализации hashCode и toString, возвращающие представления объекта записи целиком; они не могут служить методами доступа (§8.10.3) к компонентам записей, называемым hashCode или toString, и не было бы способа получить доступ к таким компонентам записей извне класса записи. Аналогичным образом, некоторые классы записей могут предоставлять реализации clone и (к сожалению) finalize, поэтому компонент записи, называемый clone или finalize, не мог бы быть доступен через метод доступа. Наконец, методы getClass, notify, notifyAll и wait в Object являются final, поэтому компоненты записей с такими же именами не могли бы иметь методы доступа. (Методы доступа имели бы такие же сигнатуры, как и методы final, и, следовательно, безуспешно пытались бы переопределить их.)

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

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

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

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

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

Пункт CompactConstructorDeclaration описан в §8.10.4.2.

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

Ошибка компиляции, если тело объявления записи содержит объявление метода, которое является abstract или native (§8.4.3.1, §8.4.3.4).

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