Глава 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 {}

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

Если класс C sealed связан с безымянным модулем (§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) типа 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.

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

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

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

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

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

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

enum Color {
    RED, GREEN, BLUE;

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

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

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

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

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

WINTER
SPRING
SUMMER
FALL

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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