В объявлении класса могут быть модификаторы класса.

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

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

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

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

Если одно и то же ключевое слово встречается более одного раза в качестве модификатора для объявления класса, это синтаксическая ошибка.

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

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

Point p = new Point();

Point p = new SimplePoint();

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Для объявления класса (возможно, обобщённого) C<F₁,...,F_n> (n ≥ 0, C ≠ Object), прямой родительский класс типа класса C<F₁,...,F_n> — это тип, указанный в extends фразе объявления C, если такая фраза присутствует, или 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].

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Для объявления класса (возможно, обобщенного) C<F₁,...,F_n> (n ≥ 0, C ≠ Object), непосредственные суперинтерфейсы типа класса C<F₁,...,F_n> — это типы, указанные в implements части объявления C, если такая 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].

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Проверка исключений для инициализатора переменной в объявлении поля описана в §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;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Переменные типов допускаются в операторе throws, хотя они не допускаются в операторе catch (§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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

public class Point {
    int x, y;
}

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

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

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

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

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

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

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

Ниже приводится фрагмент из §15.12 для удобства:

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

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

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

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

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

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

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

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

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

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

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

Если в объявлении перечисления объявлен конструктор, он должен иметь доступность или public, или protected (§6.6).

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

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

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

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

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

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

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

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

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

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

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

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

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

enum Color {
    RED, GREEN, BLUE;

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

Члены типа перечисления E состоят из следующего:

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

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

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

WINTER
SPRING
SUMMER
FALL

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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