Глава 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) значения выражений фактического аргумента инициализируют вновь созданные переменные параметров, каждый из объявленного типа, перед выполнением тела метода или конструктора. Идентификатор, который появляется в FormalParameter, может использоваться в качестве простого имени в теле метода или конструктора для ссылки на формальный параметр.

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

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

Если в объявлении класса перечисления из конструктора, инициализатора экземпляра или инициализатора переменной экземпляра ссылаться на поле 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.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).