Spec-Zone .ru спецификации, руководства, описания, API

ГЛАВА 8

Классы

Объявления класса определяют новые ссылочные типы и описывают, как они реализуются (§8.1).

Имя класса имеет как его контекст все описания типа в пакете, в котором класс объявляется (§8.1.1). Класс может быть объявлен abstract (§8.1.2.1) и должен быть объявлен abstract если это не полностью реализуется; такой класс нельзя инстанцировать, но может быть расширен подклассами. Класс может быть объявлен final (§8.1.2.2), когда у этого не может быть подклассов. Если класс объявляется public, тогда это может быть упомянуто от других пакетов.

Каждый класс кроме Object расширение (то есть, подкласс) единственный существующий класс (§8.1.3) и может реализовать интерфейсы (§8.1.4).

Тело класса объявляет элементы (поля и методы), статические инициализаторы, и конструкторы (§8.1.5). Контекст имени элемента является всем объявлением класса, которому принадлежит элемент. Поле, метод, и объявления конструктора могут включать модификаторы доступа (§6.6) public, protected, или private. Элементы класса включают и объявленный и наследованные элементы (§8.2). Недавно объявленные поля могут скрыть поля, объявленные в суперклассе или суперинтерфейсе. Недавно объявленные методы могут скрыть, реализовать, или переопределить методы, объявленные в суперклассе или суперинтерфейсе.

Полевые объявления (§8.3) описывают переменные класса, которые воплощаются однажды, и переменные экземпляра, которые недавно воплощаются для каждого экземпляра класса. Поле может быть объявлено final (§8.3.1.2), когда это не может быть присвоено за исключением части его объявления. Любое полевое объявление может включать инициализатор; объявление a final поле должно включать инициализатор.

Объявления метода (§8.4) описывают код, который может быть вызван выражениями вызова метода (§15.11). Метод класса вызывается относительно типа класса; метод экземпляра вызывается относительно некоторого определенного объекта, который является экземпляром типа класса. Метод, объявление которого не указывает, как это реализуется, должен быть объявлен abstract. Метод может быть объявлен final (§8.4.3.3), когда это не может быть скрыто или переопределено. Метод может быть реализован зависимым от платформы native код (§8.4.3.4). A synchronized метод (§8.4.3.5) автоматически блокирует объект прежде, чем выполнить его тело и автоматически разблокировал объект по возврату, как будто при помощи a synchronized оператор (§14.17), таким образом позволяя его действия синхронизироваться с таковыми из других потоков (§17).

Имена методов могут быть перегружены (§8.4.7).

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

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

8.1 Объявление класса

ClassDeclaration:

	ClassModifiersopt class Identifier Superopt Interfacesopt ClassBody

class Point { int x, y; }

package vista;
class Point { int x, y; }

Ошибка времени компиляции происходит, если Идентификатор, называя класс появляется как имя какого-либо другого типа класса или интерфейсного типа, объявленного в том же самом пакете (§7.6).

Ошибка времени компиляции происходит, если Идентификатор, называя класс также объявляется как тип объявлением единственного импорта типа (§7.5.1) в единице компиляции (§7.3) содержащий объявление класса.

В примере:

package test;

import java.util.Vector;


class Point {
	int x, y;
}


interface Point {											// compile-time error #1
	int getR();
	int getTheta();
}

class Vector { Point[] pts; }											// compile-time error #2

Отметьте, однако, что это не ошибка для Идентификатора, который называет класс также, чтобы назвать тип, который иначе мог бы быть импортирован объявлением "импорт типа по требованию" (§7.5.2) в единице компиляции (§7.3) содержащий объявление класса. В примере:

package test;

import java.util.*;

class Vector { Point[] pts; }											// not a compile-time error

8.1.1 Контекст Имени Типа класса

package points;

class Point {
	int x, y;									// coordinates
	PointColor color;									// color of this point
	Point next;									// next point with this color

	static int nPoints;
}


class PointColor {
	Point first;									// first point with this color
	PointColor(int color) {
		this.color = color;
	}
	private int color;									// color components
}

8.1.2 Модификаторы класса

ClassModifiers:

	ClassModifier

	ClassModifiers ClassModifier

ClassModifier: one of

	public abstract final

8.1.2.1 абстрактные классы

• Это явно содержит объявление abstract метод (§8.4.3).
• Это наследовалось abstract метод от его прямого суперкласса (§8.1.3).
• Прямой суперинтерфейс (§8.1.4) класса объявляет или наследовал метод (который является поэтому обязательно abstract) и класс ни не объявляет, ни наследовал метод, который реализует его.

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

Ошибка времени компиляции происходит, если попытка предпринимается, чтобы создать экземпляр abstract класс используя выражение создания экземпляра класса (§15.8). Попытка инстанцировать abstract класс используя newInstance метод класса Class (§20.3.6) вызовет InstantiationException (§11.5.1), который будет брошен. Таким образом, продолжая пример, только показанный, оператор:

	Point p = new Point();

	Point p = new SimplePoint();

Подкласс abstract класс, который не является самостоятельно abstract может быть инстанцирован, приводя к выполнению конструктора для abstract класс и, поэтому, выполнение полевых инициализаторов например переменные того класса. Таким образом, в примере, только данном, инстанцирование a SimplePoint вызывает конструктора по умолчанию и полевые инициализаторы для x и y из Point выполняться.

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

interface Colorable { void setColor(int color); }

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

Тип класса должен быть объявлен abstract только если намерение состоит в том, что подклассы могут быть созданы, чтобы завершить реализацию. Если намерение состоит в том, чтобы просто предотвратить инстанцирование класса, надлежащий способ выразить, это должно объявить конструктора (§8.6.8) никаких параметров, сделать это private, никогда не вызывайте это, и не объявляйте никаких других конструкторов. Класс этой формы обычно содержит методы класса и переменные. Класс java.lang.Math пример класса, который нельзя инстанцировать; его объявление похоже на это:

public final class Math {

	private Math() { }							// never instantiate this class


	. . . declarations of class variables and methods . . .

}

8.1.2.2 заключительные Классы

Поскольку a final у класса никогда нет подклассов, методов a final класс никогда не переопределяется (§8.4.6.1).

8.1.3 Суперклассы и Подклассы

Super:

	extends ClassType

ClassType:

	TypeName

В примере:

class Point { int x, y; }


final class ColoredPoint extends Point { int color; }

class Colored3DPoint extends ColoredPoint { int z; } // error

• Класс Point прямой подкласс java.lang.Object.
• Класс java.lang.Object прямой суперкласс класса Point.
• Класс ColoredPoint прямой подкласс класса Point.
• Класс Point прямой суперкласс класса ColoredPoint.

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

• A является прямым подклассом C.
• Там существует, класс B так, что A является подклассом B, и B является подклассом C, применяя это определение рекурсивно.

В примере:

class Point { int x, y; }


class ColoredPoint extends Point { int color; }

final class Colored3dPoint extends ColoredPoint { int z; }

• Класс Point суперкласс класса ColoredPoint.
• Класс Point суперкласс класса Colored3dPoint.
• Класс ColoredPoint подкласс класса Point.
• Класс ColoredPoint суперкласс класса Colored3dPoint.
• Класс Colored3dPoint подкласс класса ColoredPoint.
• Класс Colored3dPoint подкласс класса Point.

class Point extends ColoredPoint { int x, y; }

class ColoredPoint extends Point { int color; }

8.1.4 Суперинтерфейсы

Interfaces:

	implements InterfaceTypeList

InterfaceTypeList:

	InterfaceType

	InterfaceTypeList , InterfaceType

InterfaceType:

	TypeName

Ошибка времени компиляции происходит, если тот же самый интерфейс упоминается два или больше раза в сингле implements пункт, даже если интерфейс называют по-разному; например, код:

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

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

• Я - прямой суперинтерфейс C.
• У C есть некоторый прямой суперинтерфейс J, для которого я - суперинтерфейс, используя определение "суперинтерфейса интерфейса", данного в §9.1.3.
• Я - суперинтерфейс прямого суперкласса C, используя это определение рекурсивно.

В примере:

public interface Colorable {
	void setColor(int color);
	int getColor();
}


public interface Paintable extends Colorable {
	int MATTE = 0, GLOSSY = 1;
	void setFinish(int finish);
	int 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 

{
	int finish;
	public void setFinish(int finish) {
		this.finish = finish;
	}
	public int getFinish() { return finish; }
}

• Интерфейс Paintable суперинтерфейс класса PaintedPoint.
• Интерфейс Colorable суперинтерфейс класса ColoredPoint и класса PaintedPoint.
• Интерфейс Paintable подынтерфейс интерфейса Colorable, и Colorable суперинтерфейс Paintable, as определенный в §9.1.3.

Если объявляемый класс не abstract, объявления методов, определенных в каждом прямом суперинтерфейсе, должны быть реализованы или объявлением в этом классе или существующим объявлением метода, наследованным от прямого суперкласса, потому что класс, который не является abstract не разрешается иметь abstract методы (§8.1.2.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?
	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.1.5 Тело класса и Задействованные Объявления

ClassBody:

	{ ClassBodyDeclarationsopt }

ClassBodyDeclarations:

	ClassBodyDeclaration

	ClassBodyDeclarations ClassBodyDeclaration

ClassBodyDeclaration:

	ClassMemberDeclaration

	StaticInitializer

	ConstructorDeclaration

ClassMemberDeclaration:

	FieldDeclaration

	MethodDeclaration

8.2 Элементы класса

• Элементы, наследованные от его прямого суперкласса (§8.1.3), кроме в классе Object, у которого нет никакого прямого суперкласса
• Элементы, наследованные от любых прямых суперинтерфейсов (§8.1.4)
• Элементы, объявленные в теле класса (§8.1.5)

Конструкторы и статические инициализаторы не являются элементами и поэтому не наследованы.

Пример:

class Point {
	int x, y;
	private Point() { reset(); }
	Point(int x, int y) { this.x = x; this.y = y; }
	private void reset() { this.x = 0; this.y = 0; }
}


class ColoredPoint extends Point {
	int color;
	void clear() { reset(); }														// error
}


class Test {
	public static void main(String[] args) {
		ColoredPoint c = new ColoredPoint(0, 0);													// error
		c.reset();													// error
	}
}

• Ошибка происходит потому что ColoredPoint не имеет никакого конструктора, объявленного с двумя целочисленными параметрами, согласно просьбе использованием в main. Это иллюстрирует факт это ColoredPoint не наследовал конструкторов его суперкласса Point.
• Другая ошибка происходит потому что ColoredPoint не объявляет конструкторов, и поэтому конструктор по умолчанию для этого автоматически создается (§8.6.7), и этот конструктор по умолчанию эквивалентен: ColoredPoint () {супер ();}

который вызывает конструктора, без параметров, для прямого суперкласса класса ColoredPoint. Ошибка состоит в том что конструктор для Point это не берет параметров, private, и поэтому не доступно вне класса Point, даже через вызов конструктора суперкласса (§8.6.5).

• Еще две ошибки происходят потому что метод reset из класса Point private, и поэтому не наследован классом ColoredPoint. Вызовы метода в методе clear из класса ColoredPoint и в методе main из класса Test поэтому не корректны.

8.2.1 Примеры Наследования

8.2.1.1 Пример: Наследование с Доступом По умолчанию

package points;

public class Point {
	int x, y;

	public void move(int dx, int dy) { x += dx; y += dy; }
}

package points;

public class Point3d extends Point {
	int z;
	public void move(int dx, int dy, int dz) {
		x += dx; y += dy; z += dz;
	}
}

import points.Point3d;

class Point4d extends Point3d {
	int w;
	public void move(int dx, int dy, int dz, int dw) {
		x += dx; y += dy; z += dz; w += dw; // compile-time errors
	}
}

Лучший способ записать третью единицу компиляции был бы:

import points.Point3d;

class Point4d extends Point3d {
	int w;
	public void move(int dx, int dy, int dz, int dw) {
		super.move(dx, dy, dz); w += dw;
	}
}

8.2.1.2 Наследование с общественностью и защищенный

package points;

public class Point {

	public int x, y;


	protected int useCount = 0;


	static protected int totalUseCount = 0;


	public void move(int dx, int dy) {
		x += dx; y += dy; useCount++; totalUseCount++;
	}

}

class Test extends points.Point {
	public void moveBack(int dx, int dy) {
		x -= dx; y -= dy; useCount++; totalUseCount++;
	}
}

8.2.1.3 Наследование с частным

class Point {

	int x, y;


	void move(int dx, int dy) {
		x += dx; y += dy; totalMoves++;
	}


	private static int totalMoves;


	void printMoves() { System.out.println(totalMoves); }

}


class Point3d extends Point {

	int z;


	void move(int dx, int dy, int dz) {
		super.move(dx, dy); z += dz; totalMoves++;
	}

}

8.2.1.4 Доступ к Элементам Недоступных Классов

Рассмотрите единицу компиляции:

package points;

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

package morePoints;

class Point3d extends points.Point {
	public int z;
	public void move(int dx, int dy, int dz) {
		super.move(dx, dy); z += dz;
	}
}


public class OnePoint {
	static points.Point getOne() { return new Point3d(); }
}

В то время как поле z из класса Point3d public, не возможно получить доступ к этому полю от кода вне пакета morePoints, учитывая только ссылку на экземпляр класса Point3d в переменной p из типа Point. Это то, потому что выражение p.z не корректно, как p имеет тип Point и класс Point не имеет никакого названного поля z; также, выражение ((Point3d)p).z не корректно, потому что тип класса Point3d не может быть отнесен во внешний пакет morePoints. Объявление поля z как public не бесполезно, как бы то ни было. Если должно было быть в пакете morePoints, a public подкласс Point4d из класса Point3d:

package morePoints;

public class Point4d extends Point3d {
	public int w;
	public void move(int dx, int dy, int dz, int dw) {
		super.move(dx, dy, dz); w += dw;
	}
}

8.3 Полевые Объявления

FieldDeclaration:

	FieldModifiersopt Type VariableDeclarators ;

VariableDeclarators:

	VariableDeclarator

	VariableDeclarators , VariableDeclarator

VariableDeclarator:

	VariableDeclaratorId

	VariableDeclaratorId = VariableInitializer

VariableDeclaratorId:

	Identifier

	VariableDeclaratorId [ ]

VariableInitializer:

	Expression

	ArrayInitializer

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

Если класс объявляет поле с определенным именем, то объявление того поля, как говорят, скрывает (§6.3.1) любого и все доступные объявления полей с тем же самым именем в суперклассах и суперинтерфейсах класса.

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

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

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

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

К скрытому полю можно получить доступ при использовании полностью определенного имени (если это static) или при использовании выражения доступа к полю (§15.10), который содержит ключевое слово super или бросок к супертипу класса. См. §15.10.2 для обсуждения и примера.

8.3.1 Полевые Модификаторы

FieldModifiers:

	FieldModifier

	FieldModifiers FieldModifier

FieldModifier: one of

	public protected private

	final static transient volatile

8.3.1.1 статические Поля

Поле, которое не объявляется static (иногда вызываемый не -static поле), вызывается переменной экземпляра. Всякий раз, когда новый экземпляр класса создается, новая переменная, связанная с тем экземпляром, создается для каждой переменной экземпляра, объявленной в том классе или любом из его суперклассов.

Пример программы:

class Point {
	int x, y, useCount;
	Point(int x, int y) { this.x = x; this.y = y; }
	final static Point origin = new Point(0, 0);
}


class Test {
	public static void main(String[] args) {
		Point p = new Point(1,1);
		Point q = new Point(2,2);
		p.x = 3; p.y = 3; p.useCount++; p.origin.useCount++;
		System.out.println("(" + q.x + "," + q.y + ")");
		System.out.println(q.useCount);
		System.out.println(q.origin == Point.origin);
		System.out.println(q.origin.useCount);
	}
}

(2,2)
0
true
1

q.origin==Point.origin

p.origin.useCount++;

8.3.1.2 заключительные Поля

Любая попытка присвоиться к a final поле приводит к ошибке времени компиляции. Поэтому, однажды a final поле было инициализировано, оно всегда содержит то же самое значение. Если a final поле содержит ссылку на объект, тогда состояние объекта может быть изменено операциями на объекте, но поле будет всегда обращаться к тому же самому объекту. Это применяется также массивам, потому что массивы являются объектами; если a final поле содержит ссылку на массив, тогда компоненты массива могут быть изменены операциями на массиве, но поле будет всегда обращаться к тому же самому массиву.

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

В примере:

class Point {
	int x, y;
	int useCount;
	Point(int x, int y) { this.x = x; this.y = y; }
	final static Point origin = new Point(0, 0);
}

8.3.1.3 переходные Поля

class Point {
	int x, y;
	transient float rho, theta;
}

8.3.1.4 энергозависимые Поля

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

Если в следующем примере один поток неоднократно вызывает метод one (но не больше, чем Integer.MAX_VALUE времена (§20.7.2) всего), и другой поток неоднократно вызывает метод two:

class Test {

	static int i = 0, j = 0;


	static void one() { i++; j++; }

	static void two() {
		System.out.println("i=" + i + " j=" + j);
	}

}

Один способ предотвратить это поведение "или порядок" состоял бы в том, чтобы объявить методы one и two быть synchronized (§8.4.3.5):

class Test {

	static int i = 0, j = 0;


	static synchronized void one() { i++; j++; }

	static synchronized void two() {
		System.out.println("i=" + i + " j=" + j);
	}

}

Другой подход должен был бы объявить i и j быть volatile:

class Test {

	static volatile int i = 0, j = 0;


	static void one() { i++; j++; }

	static void two() {
		System.out.println("i=" + i + " j=" + j);
	}

}

См. §17 для большего количества обсуждения и примеров.

Ошибка времени компиляции происходит если a final переменная также объявляется volatile.

8.3.2 Инициализация Полей

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

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

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

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

8.3.2.1 Инициализаторы для Переменных Класса

class Test {
	static float f = j;							// compile-time error: forward reference
	static int j = 1;
	static int k = k+1;							// compile-time error: forward reference
}

Если ссылка простым именем к какой-либо переменной экземпляра происходит в выражении инициализации для переменной класса, то ошибка времени компиляции происходит.

Если ключевое слово this (§15.7.2) или ключевое слово super (§15.10.2, §15.11), происходит в выражении инициализации для переменной класса, затем ошибка времени компиляции происходит.

(Одна тонкость вот то, что во время выполнения, static переменные, которые являются final и это инициализируется с постоянными величинами времени компиляции, инициализируются сначала. Это также применяется к таким полям в интерфейсах (§9.3.1). Эти переменные являются "константами", у которых, как никогда будут наблюдать, не будет их начальных значений по умолчанию (§4.5.4), даже окольными программами. См. §12.4.2 и §13.4.8 для большего количества обсуждения.)

8.3.2.2 Инициализаторы например Переменные

class Test {
	float f = j;
	int j = 1;
	int k = k+1;
}

Выражения инициализации например переменные могут использовать простое имя любого static переменная, объявленная в или наследованный классом, даже тот, объявление которого происходит дословно позже. Таким образом пример:

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

Выражениям инициализации например переменные разрешают обратиться к текущему объекту this (§15.7.2) и использовать ключевое слово super (§15.10.2, §15.11).

8.3.3 Примеры Полевых Объявлений

8.3.3.1 Пример: Сокрытие Переменных Класса

class Point {
	static int x = 2;
}


class Test extends Point {
	static double x = 4.7;
	public static void main(String[] args) {

		new Test().printX();
	}
	void printX() {
		System.out.println(x + " " + super.x);
	}
}

4.7 2

class Point {
	static int x = 2;
}


class Test extends Point {
	public static void main(String[] args) {
		new Test().printX();
	}
	void printX() {
		System.out.println(x + " " + super.x);
	}
}

2 2

8.3.3.2 Пример: Сокрытие Переменных экземпляра

class Point {
	int x = 2;
}


class Test extends Point {
	double x = 4.7;
	void printBoth() {
		System.out.println(x + " " + super.x);
	}
	public static void main(String[] args) {
		Test sample = new Test();
		sample.printBoth();
		System.out.println(sample.x + " " + 

												((Point)sample).x);
	}
}

4.7 2
4.7 2

Код, который использует выражение доступа к полю, чтобы получить доступ к полю x получит доступ к названному полю x в классе, обозначенном типом ссылочного выражения. Таким образом, выражение sample.x доступы a float значение, переменная экземпляра объявляется в классе Test, потому что тип переменной выборки Test, но выражение ((Point)sample).x получает доступ int значение, переменная экземпляра объявляется в классе Point, из-за броска, чтобы ввести Point.

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

class Point {
	static int x = 2;
}


class Test extends Point {
	void printBoth() {
		System.out.println(x + " " + super.x);
	}
	public static void main(String[] args) {
		Test sample = new Test();
		sample.printBoth();
		System.out.println(sample.x + " " +

												((Point)sample).x);
	}
}

2 2
2 2

8.3.3.3 Пример: Умножьте Наследованные Поля

interface Frob { float v = 2.0f; }


class SuperTest { int v = 3; }

class Test extends SuperTest implements Frob {
	public static void main(String[] args) {
		new Test().printV();
	}
	void printV() { System.out.println(v); }
}

Следующее изменение использует выражение доступа к полю super.v обратиться к названному полю v объявленный в классе SuperTest и использует полностью определенное имя Frob.v обратиться к названному полю v объявленный в интерфейсе Frob:

interface Frob { float v = 2.0f; }


class SuperTest { int v = 3; }

class Test extends SuperTest implements Frob {
	public static void main(String[] args) {
		new Test().printV();
	}
	void printV() {
		System.out.println((super.v + Frob.v)/2);
	}
}

2.5

interface Color { int RED=0, GREEN=1, BLUE=2; }


interface TrafficLight { int RED=0, YELLOW=1, GREEN=2; }

class Test implements Color, TrafficLight {
	public static void main(String[] args) {
		System.out.println(GREEN);										// compile-time error
		System.out.println(RED);										// compile-time error
	}
}

8.3.3.4 Пример: перенаследование Полей

public interface Colorable {
	int RED = 0xff0000, GREEN = 0x00ff00, BLUE = 0x0000ff;
}


public interface Paintable extends Colorable {
	int MATTE = 0, GLOSSY = 1;
}


class Point { int x, y; }


class ColoredPoint extends Point implements Colorable {
	. . .
}


class PaintedPoint extends ColoredPoint implements Paintable 
{
	. . .       RED       . . .
}

8.4 Объявления метода

MethodDeclaration:

	MethodHeader MethodBody

MethodHeader:

	MethodModifiersopt ResultType MethodDeclarator Throwsopt

ResultType:

	Type

	void

MethodDeclarator:

	Identifer ( FormalParameterListopt )

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

Для совместимости с более старыми версиями Java форме объявления для метода, который возвращает массив, позволяют поместить (некоторые или весь из) пустых пар скобки, которые формируют объявление типа массива после списка параметров. Это поддерживается устаревающим производством:

MethodDeclarator:

	MethodDeclarator [ ]

Это - ошибка времени компиляции для тела класса, чтобы иметь как элементы два метода с той же самой подписью (§8.4.2) (имя, число параметров, и типы любых параметров). У методов и полей может быть то же самое имя, так как они используются в различных контекстах и снимаются неоднозначность различными процедурами поиска (§6.5).

8.4.1 Формальные параметры

FormalParameterList:

	FormalParameter

	FormalParameterList , FormalParameter

FormalParameter:

	Type VariableDeclaratorId

VariableDeclaratorId:

	Identifier

	VariableDeclaratorId [ ]

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

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

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

Формальные параметры не упоминаются только использование простых имен, никогда при использовании полностью определенных имен (§6.6).

8.4.2 Сигнатура метода

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

8.4.3 Модификаторы метода

MethodModifiers:

	MethodModifier

	MethodModifiers MethodModifier

MethodModifier: one of

	public protected private

	abstract static final synchronized native

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

8.4.3.1 абстрактные Методы

• B является суперклассом C или является C непосредственно.
• B является подклассом A.
• B обеспечивает объявление метода м., который не является abstract, и это объявление наследовано C, таким образом обеспечивая реализацию метода м., который видим к C.

Это - ошибка времени компиляции для a private метод, который будет объявлен abstract. Для подкласса было бы невозможно реализовать a private abstract метод, потому что private методы не видимы к подклассам; поэтому такой метод никогда не мог использоваться.

Это - ошибка времени компиляции для a static метод, который будет объявлен abstract.

Это - ошибка времени компиляции для a final метод, который будет объявлен abstract.

abstract класс может переопределить abstract метод, предоставляя другому abstract объявление метода. Это может обеспечить место, чтобы поместить комментарий для документации (§18), или объявить, что набор проверенных исключений (§11.2), который может быть брошен тем методом, когда это реализуется его подклассами, должен быть более ограничен. Например, рассмотрите этот код:

class BufferEmpty extends Exception {
	BufferEmpty() { super(); }
	BufferEmpty(String s) { super(s); }
}


class BufferError extends Exception {
	BufferError() { super(); }
	BufferError(String s) { super(s); }
}


public interface Buffer {
	char get() throws BufferEmpty, BufferError;
}


public abstract class InfiniteBuffer implements Buffer {
	abstract char get() throws BufferError;
}

Метод экземпляра, который не является abstract может быть переопределен abstract метод. Например, мы можем объявить abstract класс Point это требует, чтобы его подклассы реализовали toString если они должны быть полными, instantiable классы:

abstract class Point {
	int x, y;
	public abstract String toString();
}

class ColoredPoint extends Point {
	int color;
	public String toString() {
		return super.toString() + ": color " + color; // error
	}
}

abstract class Point {
	int x, y;
	public abstract String toString();
	protected String objString() { return super.toString(); }
}

class ColoredPoint extends Point {
	int color;
	public String toString() {
		return objString() + ": color " + color;														// correct
	}
}

8.4.3.2 статические Методы

Метод, который не объявляется static вызывается методом экземпляра, и иногда вызывается не -static метод). Метод экземпляра всегда вызывается относительно объекта, который становится текущим объектом к который ключевые слова this и super отнеситесь во время выполнения тела метода.

8.4.3.3 заключительные Методы

A private метод и все методы объявляются в a final класс (§8.1.2.2) неявно final, потому что невозможно переопределить их. Это разрешается, но не требуется для объявлений таких методов избыточно включать final ключевое слово.

Это - ошибка времени компиляции для a final метод, который будет объявлен abstract.

Во время выполнения генератор машинного кода или оптимизатор могут легко и безопасно "встроить" тело a final метод, заменяя вызов метода с кодом в его теле, как в примере:

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


class Test {
	public static void main(String[] args) {
		Point[] p = new Point[100];
		for (int i = 0; i < p.length; i++) {
			p[i] = new Point();
			p[i].move(i, p.length-1-i);
		}
	}
}

		for (int i = 0; i < p.length; i++) {
			p[i] = new Point();
			Point pi = p[i];
			pi.x += i;
			pi.y += p.length-1-i;
		}

Такое встраивание не может быть сделано во время компиляции, если ему нельзя гарантировать это Test и Point будет всегда перекомпилирован вместе, так, чтобы всякий раз, когда Point- и определенно move изменения метода, код для Test.main будет также обновлен.

8.4.3.4 собственные Методы

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

Например, класс RandomAccessFile из стандартного пакета java.io мог бы объявить следующий native методы:

package java.io;

public class RandomAccessFile

	implements DataOutput, DataInput
{	. . .
	public native void open(String name, boolean writeable)
		throws IOException;
	public native int readBytes(byte[] b, int off, int len)
		throws IOException;
	public native void writeBytes(byte[] b, int off, int len)
		throws IOException;
	public native long getFilePointer() throws IOException;
	public native void seek(long pos) throws IOException;
	public native long length() throws IOException;
	public native void close() throws IOException;
}

8.4.3.5 синхронизируемые Методы

class Test {
	int count;
	synchronized void bump() { count++; }
	static int classCount;
	static synchronized void classBump() {
		classCount++;
	}
}

class BumpTest {
	int count;
	void bump() {
		synchronized (this) {
			count++;
		}
	}
	static int classCount;
	static void classBump() {
		try {
			synchronized (Class.forName("BumpTest")) {
				classCount++;
			}
		} catch (ClassNotFoundException e) {
				...
		}
	}
}

public class Box {

	private Object boxContents;


	public synchronized Object get() {
		Object contents = boxContents;
		boxContents = null;
		return contents;
	}


	public synchronized boolean put(Object contents) {
		if (boxContents != null)
			return false;
		boxContents = contents;
		return true;
	}

}

Если put и get не были synchronized, и два потока выполняли методы для того же самого экземпляра Box одновременно, тогда код мог неправильно себя вести. Это могло бы, например, потерять след объекта потому что два вызова к put произошедший одновременно.

См. §17 для большего количества обсуждения потоков и блокировок.

8.4.4 Броски метода

Throws:

	throws ClassTypeList

ClassTypeList:

	ClassType

	ClassTypeList , ClassType

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

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

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

• Исключения, которые представляются подклассами класса Error, например OutOfMemoryError, бросаются из-за отказа в или виртуальной машины. Многие из них являются результатом отказов редактирования и могут произойти в непредсказуемых точках в выполнении программы Java. Сложные программы могут все же хотеть поймать и попытаться восстановиться с некоторых из этих условий.
• Исключения, которые представляются подклассами класса RuntimeException, например NullPointerException, следствие проверок целостности времени выполнения и бросается или непосредственно из программы Java или в библиотечных подпрограммах. Это выходит за рамки языка Java, и возможно вне состояния искусства, чтобы включать достаточную информацию в программу, чтобы уменьшить до управляемого числа места, где они, как могут доказывать, не происходят.

Более точно предположите, что B является классом или интерфейсом, и A является суперклассом или суперинтерфейсом B, и объявление метода n в B переопределяет или скрывает объявление метода м. в A. Если у n есть a throws у пункта, который упоминает любые проверенные типы исключения, тогда м., должен быть a throws пункт, и для каждого проверенного типа исключения, перечисленного в throws пункт n, того же самого класса исключений или одного из его суперклассов должен произойти в throws пункт м.; иначе, ошибка времени компиляции происходит.

См. §11 для получения дополнительной информации об исключениях и большом примере.

8.4.5 Тело метода

MethodBody:

	Block 

	;

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

Если метод объявляется void, тогда его тело не должно содержать никого return оператор (§14.15), у которого есть Выражение.

Если у метода, как объявляют, есть тип возврата, то каждый return у оператора (§14.15) в его теле должно быть Выражение. Ошибка времени компиляции происходит, если тело метода может обычно завершаться (§14.1). Другими словами метод с типом возврата должен возвратиться только при использовании оператора возврата, который обеспечивает возврат значения; не позволяется "понизиться конец своего тела."

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

class DizzyDean {

	int pitch() { throw new RuntimeException("90 mph?!"); }

}

8.4.6 Наследование, Переопределение, и Сокрытие

8.4.6.1 Переопределение (Методами экземпляра)

Ошибка времени компиляции происходит, если метод экземпляра переопределяет a static метод. В этом отношении переопределение методов отличается от сокрытия полей (§8.3), поскольку это допустимо для переменной экземпляра, чтобы скрыть a static переменная.

К переопределенному методу можно получить доступ при использовании выражения вызова метода (§15.11), который содержит ключевое слово super. Отметьте, что полностью определенное имя или бросок к супертипу класса не эффективны при попытке получить доступ к переопределенному методу; в этом отношении переопределение методов отличается от сокрытия полей. См. §15.11.4.10 для обсуждения и примеров этой точки.

8.4.6.2 Сокрытие (Методами Класса)

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

8.4.6.3 Требования в Переопределении и Сокрытии

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

• Если переопределенный или скрытый метод public, тогда переопределение или сокрытие метода должны быть public; иначе, ошибка времени компиляции происходит.
• Если переопределенный или скрытый метод protected, тогда переопределение или сокрытие метода должны быть protected или public; иначе, ошибка времени компиляции происходит.
• Если у переопределенного или скрытого метода есть значение по умолчанию (пакет) доступ, то переопределение или сокрытие метода не должны быть private; иначе, ошибка времени компиляции происходит.

8.4.6.4 Наследование Методов с Той же самой Подписью

• Если один из наследованных методов не abstract, тогда есть два подслучая:
  • Если метод, который не является abstract static, ошибка времени компиляции происходит.
  • Иначе, метод, который не является abstract как полагают, переопределяет, и поэтому реализует, все другие методы от имени класса, который наследовал это. Ошибка времени компиляции происходит, если, сравнивая метод, который не является abstract с каждым из других из наследованных методов, для любой такой пары, у или их есть различные типы возврата, или у каждого есть тип возврата, и другой void. Кроме того ошибка времени компиляции происходит, если наследованный метод, который не является abstract имеет a throws пункт, который конфликтует (§8.4.4) с тем из любых других из наследованных методов.
• Если ни один из наследованных методов не abstract, тогда класс обязательно abstract класс и, как полагают, наследовался весь abstract методы. Ошибка времени компиляции происходит, если для каких-либо двух таких наследованных методов у или их есть различные типы возврата, или у каждого есть тип возврата, и другой void. ( throws пункты не вызывают ошибки в этом случае.)

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

8.4.7 Перегрузка

Методы переопределяются на основе подписи подписью. Если, например, класс объявляет два public методы с тем же самым именем, и подкласс переопределяют одного из них, подкласс все еще наследовал другой метод. В этом отношении Java отличается от C++.

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

8.4.8 Примеры Объявлений метода

8.4.8.1 Пример: Переопределение

class Point {

	int x = 0, y = 0;


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

}


class SlowPoint extends Point {

	int xLimit, yLimit;


	void move(int dx, int dy) {
		super.move(limit(dx, xLimit), limit(dy, yLimit));
	}


	static int limit(int d, int limit) {
		return d > limit ? limit : d < -limit ? -limit : d;
	}

}

8.4.8.2 Пример: Перегрузка, Переопределение, и Сокрытие

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

}

В этом примере, элементах класса RealPoint включайте переменную экземпляра color наследованный от класса Point, float переменные экземпляра x и y объявленный в RealPoint, и два move методы, объявленные в RealPoint.

Какой из них перегруженных move методы класса RealPoint будет выбран для любого определенного вызова метода, будет определен во время компиляции перегружающейся процедурой разрешения, описанной в §15.11.

8.4.8.3 Пример: Неправильное Переопределение

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

}

8.4.8.4 Пример: Переопределение против Сокрытия

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)

Вторая строка вывода показывает что доступ к полю rp.x обращается к полю x объявленный в классе RealPoint. Это поле имеет тип float, и эта вторая строка вывода соответственно выводит на экран значения с плавающей точкой. Случайно, это также иллюстрирует факт что имя метода show перегружается; типы параметров в вызове метода диктуют, какое из этих двух определений будет вызвано.

Последние две строки вывода показывают что вызовы метода p.getX() и rp.getX() каждый вызывает getX метод объявляется в классе RealPoint. Действительно, нет никакого способа вызвать getX метод класса Point для экземпляра класса RealPoint снаружи тела RealPoint, независимо от того, что тип переменной мы можем использовать, чтобы содержать ссылку на объект. Таким образом мы видим, что поля и методы ведут себя по-другому: сокрытие отличается от переопределения.

8.4.8.5 Пример: Вызов Скрытых Методов Класса

class Super {
	static String greeting() { return "Goodnight"; }
	String name() { return "Richard"; }
}


class Sub extends Super {
	static String greeting() { return "Hello"; }
	String name() { return "Dick"; }
}


class Test {
	public static void main(String[] args) {
		Super s = new Sub();
		System.out.println(s.greeting() + ", " + s.name());
	}
}

Goodnight, Dick

8.4.8.6 Большой Пример Переопределения

import java.io.OutputStream;


import java.io.IOException;

class BufferOutput {

	private OutputStream o;


	BufferOutput(OutputStream o) { this.o = o; }


	protected byte[] buf = new byte[512];


	protected int pos = 0;


	public void putchar(char c) throws IOException {
		if (pos == buf.length)
			flush();
		buf[pos++] = (byte)c;
	}

	public void putstr(String s) throws IOException {
		for (int i = 0; i < s.length(); i++)
			putchar(s.charAt(i));
	}


	public void flush() throws IOException {
		o.write(buf, 0, pos);
		pos = 0;
	}

}


class LineBufferOutput extends BufferOutput {

	LineBufferOutput(OutputStream o) { super(o); }


	public void putchar(char c) throws IOException {
		super.putchar(c);
		if (c == '\n')
			flush();
	}

}


class Test {
	public static void main(String[] args)

		throws IOException

	{
		LineBufferOutput lbo =

			new LineBufferOutput(System.out);
		lbo.putstr("lbo\nlbo");
		System.out.print("print\n");
		lbo.putstr("\n");
	}
}

lbo
print
lbo

В putchar метод a LineBufferOutput объект, если символьным параметром является новая строка, то это вызывает flush метод. Критическая точка о переопределении в этом примере то, что метод putstr, который объявляется в классе BufferOutput, вызывает putchar метод определяется текущим объектом this, который является не обязательно putchar метод объявляется в классе BufferOutput.

Таким образом, когда putstr вызывается в main использование LineBufferOutput объект lbo, вызов putchar в теле putstr метод является вызовом putchar из объекта lbo, объявление переопределения putchar это проверяет на новую строку. Это позволяет подкласс BufferOutput изменить поведение putstr метод, не пересматривая это.

Документация для класса такой как BufferOutput, то, который разрабатывается, чтобы быть расширенным, должно ясно указать на то, что является контрактом между классом и его подклассами, и должно ясно указать, что подклассы могут переопределить putchar метод таким образом. Конструктор BufferOutput класс, поэтому, не хотел бы изменять реализацию putstr в будущей реализации BufferOutput не использовать метод putchar, потому что это нарушило бы существующие ранее условия контракта с подклассами. См. дальнейшее обсуждение совместимости на уровне двоичных кодов в §13, особенно §13.2.

8.4.8.7 Пример: Неправильное Переопределение из-за Бросков

class BadPointException extends Exception {
	BadPointException() { super(); }
	BadPointException(String s) { super(s); }
}

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


class CheckedPoint extends Point {
	void move(int dx, int dy) throws BadPointException {
		if ((x + dx) < 0 || (y + dy) < 0)
			throw new BadPointException();
		x += dx; y += dy;
	}
}

Удаление throws пункт не помогает:

class CheckedPoint extends Point {
	void move(int dx, int dy) {
		if ((x + dx) < 0 || (y + dy) < 0)
			throw new BadPointException();
		x += dx; y += dy;
	}
}

8.5 Статические Инициализаторы

StaticInitializer:

	static Block

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

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

Если a return оператор (§14.15) появляется где угодно в пределах статического инициализатора, затем ошибка времени компиляции происходит.

Если ключевое слово this (§15.7.2) или ключевое слово super (§15.10, §15.11), появляется где угодно в пределах статического инициализатора, затем ошибка времени компиляции происходит.

8.6 Объявления конструктора

ConstructorDeclaration:

	ConstructorModifiersopt ConstructorDeclarator

		Throwsopt ConstructorBody

ConstructorDeclarator:

	SimpleTypeName ( FormalParameterListopt )

Вот простой пример:

class Point {
	int x, y;
	Point(int x, int y) { this.x = x; this.y = y; }
}

Доступом к конструкторам управляют модификаторы доступа (§6.6). Это полезно, например, в предотвращении инстанцирования, объявляя недоступного конструктора (§8.6.8).

Объявления конструктора не являются элементами. Они никогда не наследованы и поэтому не подвергаются сокрытию или переопределению.

8.6.1 Формальные параметры

8.6.2 Подпись конструктора

8.6.3 Модификаторы конструктора

ConstructorModifiers:

	ConstructorModifier

	ConstructorModifiers ConstructorModifier

ConstructorModifier: one of

	public protected private

В отличие от методов, конструктор не может быть abstract, static, final, native, или synchronized. Конструктор не наследован, таким образом нет никакой потребности объявить это final и abstract конструктор никогда не мог реализовываться. Конструктор всегда вызывается относительно объекта, таким образом, не имеет никакого смысла для конструктора быть static. Нет никакой практической потребности в конструкторе быть synchronized, потому что это заблокировало бы объект, в стадии строительства, который обычно не делается доступным для других потоков, пока все конструкторы для объекта не завершили свою работу. Нехватка native конструкторы являются произвольным проектным решением языка, которое облегчает для реализации виртуальной машины Java проверять, что конструкторы суперкласса всегда должным образом вызываются во время объектного создания.

8.6.4 Броски конструктора

8.6.5 Тело конструктора

ConstructorBody:

	{ ExplicitConstructorInvocationopt BlockStatementsopt }

ExplicitConstructorInvocation:

	this ( ArgumentListopt ) ;

	super ( ArgumentListopt ) ;

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

За исключением возможности явных вызовов конструктора, тело конструктора походит на тело метода (§8.4.5). A return оператор (§14.15) может использоваться в теле конструктора, если это не включает выражение.

В примере:

class Point {

	int x, y;


	Point(int x, int y) { this.x = x; this.y = y; }

}


class ColoredPoint extends Point {

	static final int WHITE = 0, BLACK = 1;


	int color;


	ColoredPoint(int x, int y) {
		this(x, y, WHITE);
	}


	ColoredPoint(int x, int y, int color) {
		super(x, y);

		this.color = color;

	}

}

Явный оператор вызова конструктора, возможно, не обращается ни к каким переменным экземпляра или методам экземпляра, объявленным в этом классе или никаком суперклассе, или использовании this или super в любом выражении; иначе, ошибка времени компиляции происходит. Например, если первый конструктор ColoredPoint в примере выше были изменены на:

	ColoredPoint(int x, int y) {
		this(x, y, color);
	}

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

§12.5 описывает создание и инициализацию новых экземпляров класса.

8.6.6 Конструктор, Перегружающийся

8.6.7 Конструктор по умолчанию

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

Если класс объявляется public, тогда конструктору по умолчанию неявно дают модификатор доступа public (§6.6); иначе, конструктору по умолчанию подразумевал доступ по умолчанию никакой модификатор доступа. Таким образом, пример:

public class Point {
	int x, y;
}

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

8.6.8 Предотвращение Инстанцирования Класса

Таким образом, в примере:

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

package just;

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

Содержание | Предыдущий | Следующий | Индекс

Спецификация языка Java (HTML, сгенерированный Блинчиком "сюзет" Pelouch 24 февраля 1998)
Авторское право © Sun Microsystems, Inc 1996 года. Все права защищены
Пожалуйста, отправьте любые комментарии или исправления к doug.kramer@sun.com