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

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

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

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

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

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

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

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

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

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

Это ошибка времени компиляции, если ссылаться на параметр типа обобщённого класса C где-либо в:

Объявления обобщённых классов могут быть вложены внутри других объявлений.

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

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

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

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

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

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

Внутренние классы включают локальные (§14.3), анонимные (§15.9.5) и нестатические классы-члены (§8.5).

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Ошибка времени компиляции возникает, если тип ТипКласса называет класс Enum или любое его обращение.

Если за спецификатором СпецификаторТипа следуют какие-либо аргументы типа, то это должно быть корректное обращение к объявлению типа, обозначаемому СпецификаторТипа, и ни один из аргументов типа не должен быть аргументом типа со звёздочкой, иначе произойдет ошибка времени компиляции.

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

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

Прямым суперклассом типа перечисления E является Enum<E>.

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

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

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

Класс C называется суперклассом класса A, когда A является подклассом C.

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

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

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

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

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

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

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

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

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

Если за ИменемТипа следуют какие-либо типы аргументов, это должна быть корректная вызов объявления типа, обозначаемого ИменемТипа, и ни один из типов аргументов не может быть аргументом типа «подстановка», иначе произойдёт ошибка компиляции.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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, чтобы сделать представление здесь более ясным:

Если аннотация a (§9.7) на формальном параметре соответствует типу аннотации T (§9.6), и T имеет (мета-)аннотацию m, которая соответствует java.lang.annotation.Target, то m должно иметь элемент, значение которого равно java.lang.annotation.ElementType.PARAMETER, в противном случае возникает ошибка компиляции.

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

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

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

Ошибка компиляции возникает при использовании смешанной нотации массивов (§10.2) для параметра с переменным числом аргументов.

Тип формального параметра обозначается типом Type, который появляется в его спецификации параметра, за которым следуют любые пары квадратных скобок, следующие за Идентификатором в деклараторе, за исключением параметра с переменным числом аргументов, чей декларированный тип является типом массива, а тип компонента массива – это Type, который появляется в спецификации параметра.

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

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

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

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

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

Два метода имеют одинаковую подпись, если у них одинаковые имена и типы аргументов.

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

Подпись метода 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).

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

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

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

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

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

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

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

Это ошибка компиляции, если какой-либо ExceptionType, указанный в операторе throws, не является подтипом (§4.10) от Throwable.

Переменные типа допускаются в операторе throws, хотя они не допускаются в операторе catch.

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 */ }
    }
}

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

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

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

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

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

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

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

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

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

Если метод объявлен void, то его тело не должно содержать оператор return (§14.17), имеющий Выражение, иначе произойдёт ошибка компиляции.

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

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

Другими словами, метод с типом возврата должен возвращать значение только с помощью оператора 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).

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

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

Если аннотация a (§9.7) на конструкторе соответствует типу аннотации T (§9.6), и T имеет (мета-)аннотацию m, соответствующую java.lang.annotation.Target, то m должен иметь элемент со значением java.lang.annotation.ElementType.CONSTRUCTOR, в противном случае произойдёт ошибка компиляции.

Модификаторы доступа public, protected и private рассматриваются в §6.6.

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

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

Если для конструктора обычного класса не указан модификатор доступа, конструктор имеет доступ по умолчанию.

Если для конструктора типа перечисления не указан модификатор доступа, конструктор имеет private доступ.

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

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

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

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

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

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

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

Оператор throws для конструктора аналогичен оператору throws для метода (§8.4.6).

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

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

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

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

Ошибка компиляции, если неявно объявлен конструктор по умолчанию, но у суперкласса нет доступного конструктора (§6.6), принимающего ноль аргументов и не имеющего фрагмента throws.

В классе типа, если класс объявлен public, то конструктору по умолчанию неявно присваивается модификатор доступа public (§6.6); если класс объявлен protected, то конструктору по умолчанию неявно присваивается модификатор доступа protected (§6.6); если класс объявлен private, то конструктору по умолчанию неявно присваивается модификатор доступа private (§6.6); в противном случае конструктор по умолчанию имеет доступ по умолчанию, неявно определяемый отсутствием модификатора доступа.

В типе перечисления конструктор по умолчанию неявно private (§8.9.2).

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.

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

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

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

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

Константа перечисления может быть необязательно снабжена модификаторами аннотаций. Если аннотация a (§9.7) на константе перечисления соответствует типу аннотации T (§9.6), и T имеет (мета-)аннотацию m, соответствующую java.lang.annotation.Target, то m должен иметь элемент, значение которого является java.lang.annotation.ElementType.FIELD, в противном случае возникает ошибка компиляции.

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

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

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

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

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

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

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

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

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

import java.util.EnumSet;

public class Test {
    enum Day { MONDAY, TUESDAY, WEDNESDAY,
               THURSDAY, FRIDAY, SATURDAY, SUNDAY }

    public static void main(String[] args) {
        System.out.print("Weekdays: ");
        for (Day d : EnumSet.range(Day.MONDAY, Day.FRIDAY))
            System.out.print(d + " ");
    }
}

Weekdays: MONDAY TUESDAY WEDNESDAY THURSDAY FRIDAY

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

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

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

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

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

В дополнение к членам, которые тип перечисления E наследует от Enum<E>, для каждой объявленной константы перечисления с именем n, тип перечисления имеет неявное объявление public static final поля с именем n типа E. Эти поля считаются объявленными в том же порядке, что и соответствующие константы перечисления, прежде чем любые static поля, явно объявленные в типе перечисления. Каждое такое поле инициализируется соответствующей константой перечисления. Каждое такое поле также считается аннотированным теми же аннотациями, что и соответствующая константа перечисления. Константа перечисления считается созданной, когда соответствующее поле инициализируется.

Кроме того, если E — имя типа перечисления, то этот тип имеет следующие неявные объявленные static методы:

/**
* Returns an array containing the constants of this enum 
* type, in the order they're declared.  This method may be
* used to iterate over the constants as follows:
*
*    for(E c : E.values())
*        System.out.println(c);
*
* @return an array containing the constants of this enum 
* type, in the order they're declared
*/
public static E[] values();

/**
* Returns the enum constant of this type with the specified
* name.
* The string must match exactly an identifier used to declare
* an enum constant in this type.  (Extraneous whitespace 
* characters are not permitted.)
* 
* @return the enum constant with the specified name
* @throws IllegalArgumentException if this enum type has no
* constant with the specified name
*/
public static E valueOf(String name);

Следует, что объявления типов перечисления не могут содержать полей, конфликтующих с константами перечисления, и не могут содержать методов, конфликтующих с автоматически сгенерированными методами (values() и valueOf(String)) или методами, которые переопределяют методы final в перечислении (equals(Object), hashCode(), clone(), compareTo(Object), name(), ordinal() и getDeclaringClass()).

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

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

import java.util.Map;
import java.util.HashMap;
enum Color {
    RED, GREEN, BLUE;

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

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

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

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

    private enum CoinColor { COPPER, NICKEL, SILVER }
    private 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);
        }
    }
}

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

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]

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