Основы программирования на языке Java

Новосибирск, 2004

(С) Всеволод Рылов, все права защищены 1

Основы программирования на языке Java

Средства ООП Java



Ключевые слова – статусКлючевые слова, которые уже известны на текущий момент:abstract defaultif private this boolean doimplements protected throw break double importpublic throws byte else instanceof return transient caseextends int short try catch final interface static void char finally long

strictfpvolatile class float native super while const for new switch continue goto package synchronized



Виды переменных переменные классов (class variable - переменная-член

объявленная static ) переменные экземпляра (instance variable –

переменная-член класса объявленная без static) компоненты массивов: int ia[] = new int[3]; ia[0] параметры методов: void doSome(int i, Object o) {…} параметры конструкторов: MyClass(Object param) {…} параметры перехватчиков исключений:

catch(Exception ex) {…} локальные переменные, объявленные внутри

методов, блоков, и в операторе for



Модификатор final Переменная объявленная final может быть проинициализирована ровно

один раз, после этого ее значение изменить нельзя. Если ссылка объявлена с модификатором final, то это не значит, что

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

void unflow(boolean flag) { final int k; if (flag) { k = 3; System.out.println(k); } else { k = 4; System.out.println(k); } } // all ok

void unflow(boolean flag) { final int k; if (flag) { k = 3; System.out.println(k); } if (!flag) { k = 4; System.out.println(k); } } //compile-time error!



Объекты и значения ссылочного типаОбъекты - экземпляры классов (class instance) и массивы.ClassInstanceCreationExpression:

new ClassOrInterfaceType ( ArgumentListopt ) ClassBodyopt Primary.new Identifier ( ArgumentListopt ) ClassBodyopt

ArgumentList: Expression ArgumentList , Expression

//Создание объектов – экземпляров классов

class MyClass implements MyInterface {…}

MyClass myObj = new MyClass();

MyInterface anotherObj = new MyClass(“parameter”);

MyClass reflObj = (MyClass)Class.forName(“MyClass”).newInstance();



Операции над ссылками доступ к полю: obj.x = 10; super.y = 20; вызов метода: obj.doSome(); super.doAnother(); преобразование типа: (Object)obj строковый оператор + : String s = “one” + obj;

//вызывается метод obj.toString(); оператор проверки типа instanceof:

if (obj instanceof MyClass) {…} //Проверяется тип obj операторы сравнения ссылок == и !=:

if (obj == obj2 && obj != obj3) {…} условный тернарный оператор ? :

obj = ( obj2.size() < obj3.size() ) ? obj2: obj3;



Объекты – массивы: грамматикаArrayCreationExpression:

new PrimitiveType DimExprs Dimsopt

new TypeName DimExprs Dimsopt

new PrimitiveType Dims ArrayInitializer

new TypeName Dims ArrayInitializer DimExprs:

DimExpr DimExprs DimExpr

DimExpr: [ Expression

] Dims: [ ] Dims [ ]

Индексация элементов массива начинается с 0 а не с 1 !!!Диапазон допустимых значений индекса – от 0 до length - 1



Создание и инициализация массивов// Создание массивов примеры:// Создание объекта – массива из трех ссылок на объекты типа MyClassMyClass array[] = new MyClass[3];// Инициализация элемента массива (ссылки):array[0] = new MyClass();// Создание объекта – массива из двух ссылок на объекты-массивы //ссылок на объекты класса MyClassMyClass array2[][] = new MyClass[2][];// Инициализация элементов 0 и 1 массива array2 array2[0] = new MyClass[5]; //объект – массив из 5 ссылокarray2[1] = new MyClass[4]; //объект – массив из 4 ссылок// Объект - массив из трех элементов типа intint array3[] = new int[3]; array3[0] = 0; // Создание и инициализация массива из четырех элементов intint array4 [] = new int [] {1,2,3,4};// Создание и инициализация объекта-массива ссылок на объекты //класса MyClassMyClass array5[] = {new MyClass(“a”), new MyClass(“b”)};



Особенности использования массивовЧлены объектов-массивов: public final int length это поле содержит длину массива public Object clone() – создает копию массива + все методы класса Object. Любой массив можно привести к классу Object или к массиву

совместимого типа.

class Test { public static void main(String[] args) throws Throwable { int ia[][] = { { 1 , 2}, null }; int ja[][] = (int[][]) ia.clone(); System.out.print( (ia == ja) + " "); System.out.println(ia[0] == ja[0] && ia[1] == ja[1]); }} // this program prints: false true



Особенности использования массивовclass Point { int x, y; } class ColoredPoint extends Point { int color; } class Test {

public static void main(String[] args) {

ColoredPoint[] cpa = new ColoredPoint[10]; Point[] pa = cpa; System.out.println(pa[1] == null); try {

pa[0] = new Point(); } catch (ArrayStoreException e) {

System.out.println(e); }

} }



Классы Классы объявляют новый ссылочный тип и определяют

его реализацию Вложенный (nested) класс – это класс объявленный

внутри другого класса или интерфейса (в том числе класс объявленный внутри метода или блока): member class – объявленный внутри класса local class – объявленный внутри метода anonymous class – не имеющий имени

Верхнеуровневый (top-level) класс – это класс, не являющийся вложенным

Именованные (named) классы могут быть абстрактными



Классы Каждый класс кроме Object является наследником

другого класса и может реализовывать (implements) произвольное количество интерфейсов

Тело класса может содержать: члены (members):

поля методы вложенные классы и интерфейсы

инициализаторы экземпляра статические инициализаторы конструкторы

Видимость членов и конструкторов регулируется модификаторами доступа public, private, protected



Классы и наследование Членами класса являются унаследованные и определенные в

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

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

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

Вложенные классы бывают статическими и внутренними (inner), в зависимости от контекста в котором они объявлены (если в точке объявления имеет смысл ссылка this – то вложенный класс будет внутренним)



Методы Методы описывают участки кода, которые могут быть вызваны с

помощью выражения вызова метода Метод класса исполняется в контексте переменных класса (static

context) Метод экземпляра исполняется в контексте конкретного объекта,

доступного по this Методы не имеющие реализации должны быть объявлены abstract Допускается перегрузка методов по списку и типам аргументов Метод может иметь платформенно-зависимую реализацию (native

method)



Статический контекстpublic class MyClass{ private int a,b; private static int s =10; public MyClass(int arg1, int arg2) { a = arg1; b = arg2; } public void changeA(int v) { a = v; } public static void changeS(int v) { s = v; } public static void main(String args[]) { MyClass mc1 = new MyClass(2,3); MyClass mc2 = new MyClass(4,5); mc1.changeA(100); mc2.changeA(200); MyClass.changeS(25) ; mc1.changeS(30); mc2.changeS(40); }}

Static dataMyClass.s == 10

HEAP

:MyClassa == 2b == 3

:MyClassa == 4b == 5

HEAP

:MyClassa == 100

b == 3

:MyClassa == 200

b == 5

Static dataMyClass.s == 40



Конструкторы и инициализаторы Инициализаторы экземпляра – блоки кода {…} выполняемые при

инициализации объекта. Выполняются перед вызовом конструктора. Статические инициализаторы – статические блоки кода static {…}

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

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



Грамматика объявления классаClassDeclaration:

ClassModifiersopt class Identifier Superopt Interfacesopt ClassBody ClassModifiers:

ClassModifier ClassModifiers ClassModifier

ClassModifier: one of public protected private abstract static final strictfp

Super: //Определяет «прямой суперкласс»extends ClassType

Interfaces: //Определяет «прямые суперинтерфейсы»implements InterfaceTypeList

InterfaceTypeList: InterfaceType InterfaceTypeList , InterfaceType



Пример объявления классаpublic abstract class MyClass extends Parent

implements MyInterface, AnotherInterface{

static {//Static initializer

}{

//Non static initializer}public MyClass(){

super(); //Вызов конструктора супер класса}

}



Модификаторы объявления класса public – класс доступен извне пакета. abstract – класс является абстрактным (в нем есть абстрактные

методы) final – класс является конечным в иерархии наследования. От него

нельзя унаследовать другой класс strictfp – для всех методов класса действуют правила строгой

проверки арифметических выражений во время вычислений

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

static – класс является статическим (вложенный класс) protected – к классу имеют доступ только классы наследники

объемлющего класса или классы в том же пакете private – к классу имеет доступ только объемлющий класс



Строгое определение абстрактного классаКласс C является абстрактным, если:

C явно содержит объявление абстрактного метода Какой-либо класс-родитель C содержит объявление

абстрактного метода, который не был реализован в классе C или в его родительских классах

«Прямой суперинтерфейс» C определяет или наследует метод, который не реализован (и поэтому является абстрактным) т.е. ни C ни его родительские классы не определяют реализацию этого метода



Внутренние (inner) классы Внутренний (inner) класс – это класс который ни явно,

ни неявно не является static Внутренний класс не может содержать блоков

статической инициализации или членов-интерфейсов Внутренний класс не может содержать статических

членов за исключением полей-констант времени компиляции

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

Члены-интерфейсы всегда являются static по умолчанию

Вложенные классы могут свободно содержать статические члены как и обычные классы Java



Пример вложенности классовclass HasStatic {

static int j = 100; } class Outer {

class Inner extends HasStatic { static final int x = 3; //ok - compile-time constant static int y = 4; //compile-time error, an inner class

} static class NestedButNotInner{

static int z = 5; // ok, not an inner class } interface NeverInner{} // interfaces are never inner

}



Статический контекст Выражение находится в статическом контексте,

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

Проще говоря, если в точке объявления класса имеет семантику ссылка this на объект объемлющего класса, то контекст объявления является динамическим (non static) и класс будет внутренним.



Immediately enclosing instance Внутренний класс C является непосредственным внутренним

классом (direct inner class of) класса O если O непосредственно лексически включает класс C, и декларация C не находится в статическом контексте. Класс C является внутренним классом (inner class) класса O если это непосредственный внутренний класс класса O либо является внутренним классом внутреннего класса O.

Класс O является лексически объемлющим классом порядка 0 (zeroth enclosing class of itself) для самого себя. Класс O является лексически объемлющим классом порядка n (nth lexically enclosing class) класса C если он является непосредственным объемлющим классом для лексически объемлющего класса порядка n – 1 класса C.

Экземпляр объекта i непосредственного внутреннего класса C класса O всегда связан с объектом класса O, известным как непосредственно объемлющий объект для i (the immediately enclosing instance of i). Непосредственно объемлющий объект, если таковой имеется, связывается с объектом при его создании.

Объект o является лексически объемлющим объектом порядка 0 (zeroth lexically enclosing instance) самого себя. Объект o является лексически объемлющим объектом порядка n для объекта i, если он является непосредственно объемлющим объектом для лексически объемлющего объекта порядка n – 1 объекта i.



Immediately enclosing instance Анологично, если суперкласс S класса C является

непосредственным внутренним классом класса SO, то существует экземпляр SO, связанный с объектом i класса C, известный как непосредственно объемлющий экземпляр по отношению к S (the immediately enclosing instance of i with respect to S). Непосредственно объемлющий экземпляр объекта по отношению к его прямому суперклассу, если таковой имеет место быть, определяется в момент вызова конструктора суперкласса посредством вызова конструктора суперкласса по умолчанию.

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

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



Пример – ограничение доступа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;

} }

} } Каждый экземпляр WithDeepNesting.Nested.DeeplyNested имеет объемлющий объект класса WithDeepNesting.Nested (его непосредственно объемлющий объект) и объемлющий объект – экземпляр класса WithDeepNesting (объемлющий объект ранга 2).



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

следующих утверждений: 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.



Зависимость между классами Классы и интерфейсы зависят по загрузке от других типов

(классов и интерфейсов), приведенных в декларации наследования (extends и implements)

Зависимость типов друг от друга может формировать цепочку: A зависит от B, B зависит от C тогда A зависит от C.

class B implements C {…}class A extends B {…}…A theA = new A(); // Будут загружены интерфейс C и

//классы B и A Циклические зависимости вызывают ошибку времени компиляции:class Point extends ColoredPoint { int x, y; } class ColoredPoint extends Point { int color; } Если цикл обнаружен во время исполнения программы и загрузки

классов в JVM, то выбрасывается ошибка ClassCircularityError



Суперинтерфейсы класса Суперинтерфейсами (родительскими интерфейсами)

для класса являются: Прямые суперинтерфейсы (объявленные implements)

Суперинтерфейсы прямых суперинтерфейсов Суперинтерфесы родительского класса

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

У класса может быть несколько прямых суперинтерфейсов:

interface One { void doIt();}interface Two { void doIt(); void doAnother();}class MyClass implements One, Two {

void doIt() {} //Общая реализация для One и Twovoid doAnother{}

}



Грамматика объявления тела классаClassBody:

{ ClassBodyDeclarationsopt } ClassBodyDeclarations:

ClassBodyDeclaration ClassBodyDeclarations ClassBodyDeclaration

ClassBodyDeclaration: ClassMemberDeclaration InstanceInitializer StaticInitializer ConstructorDeclaration

ClassMemberDeclaration: FieldDeclaration MethodDeclaration ClassDeclaration InterfaceDeclaration ;



Члены класса Областью видимости члена m, объявленного или

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

Если C сам по себе является вложенным классом, то объявления одноименных членов (полей, методов или типов) m в объемлющих областях видимости (блоках, классах или пакете) будут сокрыты данным членом m класса С.

Членами класса являются: Члены, унаследованные от его прямого суперкласса

(исключением является класс Object не имеющий суперклассов)

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

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

наследуются



Пример наследования членов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 – reset() is private

} //error: ColoredPoint() {super();} – default constructorclass Test {

public static void main(String[] args) { ColoredPoint c = new ColoredPoint(0,0);//error –

//ColoredPoint has no such constructor c.reset(); //error – reset() is private

} }



Наследование и доступ по умолчанию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.*; class Point4D extends Point3D {

int w; public void move(int dx, int dy, int dz, int dw) {

x+=dx; y+=dy; z+=dz; //error!

w+=dw; }

}

import points.*; class Point4D extends Point3D {

int w; public void move(int dx, int dy, int dz, int dw) {

super.move(dx,dy,dz); //Good!

w+=dw; }

}



Поля-члены класса (грамматика)FieldDeclaration:

FieldModifiersopt Type VariableDeclarators ; VariableDeclarators:

VariableDeclarator VariableDeclarators , VariableDeclarator

FieldModifiers: FieldModifier FieldModifiers FieldModifier

FieldModifier: one of public protected private static final transient volatile



Статические поля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); }

}



Singleton (объект одиночка) Данный шаблон используется для обеспечение

единственности объекта определенного класса

public class Singleton {private static Singleton instance = null;private Singleton(){} //никто не может вызвать конструктор//все должны использовать данный метод для получения объектаpublic static Singleton getInstance() { if (instance == null) {

instance = new Singleton();}return instance;

}}



Поля-члены, объявленные final Переменные классов(static) и переменные

экземпляров могут быть объявлены final Статическая переменная, объявленная final

должна быть инициализирована непосредственно при объявлении либо в блоке статической инициализации

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



Модификаторы volatile и transientПеременные, объявленные transient не являются частью persistent состояния объекта и не сохраняются во время сериализации.

class Test { static int i = 0, j = 0; static void one() { i++; j++; } static void two() { System.out.println("i=" + i

+ " j=" + j); } // может напечатать j } // большее, чем i

class Test { static volatile int i = 0, j = 0; static void one() { i++; j++; } static void two() { System.out.println("i=" + i

+ " j=" + j); } // i всегда >= j !!!}

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



Инициализация полей Инициализация полей экземпляра происходит каждый раз при

создании нового объекта. Инициализация статических полей класса происходит один раз при

первом использовании класса. При инициализации поля экземпляра могут использовать

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

При инициализации статические поля класса не могут использовать поля экземпляра, а также ключевые слова this и super

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

Стоит избегать зависимости от порядка инициализации полей



Разрешение перекрытия полей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); }

}

Для доступа к полям, перекрытым при наследовании можно использовать super, а также полную квалификацию (super.x или Point.x)



Множественное перекрытие

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

}

При множественном перекрытии необходимо использовать полную квалификацию



Грамматика объявления метода Метод определяет участок исполняемого кода, который

может быть вызван с передачей фиксированного количества параметров определенного типа

MethodDeclaration: MethodHeader MethodBody

MethodHeader: MethodModifiersopt ResultType MethodDeclarator Throwsopt

ResultType: Type void

MethodDeclarator: Identifer ( FormalParameterListopt )

В классе может быть объявлен метод, имя которого совпадает с именем члена-поля, вложенного класса, интерфейса или другого метода (стоит избегать!!!)



Сигнатура метода Методы класса должны различаться по своей

сигнатуре. Сигнатура метода определяется его именем,

количеством параметров и типами этих параметровFormalParameterList:

FormalParameter FormalParameterList , FormalParameter

FormalParameter: finalopt Type VariableDeclaratorId

VariableDeclaratorId: Identifier VariableDeclaratorId [ ]

Имена параметров метода должны быть различны Список формальных параметров метода может быть

пуст



Параметры метода Во время вызова метода вычисленные значения передаваемых

аргументов используются для инициализации переменных-параметров метода

Таким образом всегда имеет место передача «по значению» Область видимости параметра ограничивается методом, в котором

он объявлен. При этом доступ к нему осуществляется с помощью обычного имени.

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

Параметры типов double и float всегда содержат значения из множества double и float соответственно. Они не могут принимать расширенных значений появляющихся во время вычисления выражений не являющихся strictfp



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

MethodModifiers: MethodModifier MethodModifiers MethodModifier

MethodModifier: one of public protected private abstract static final synchronized native strictfp

Запрещенные комбинации: два из public, protected, private abstract с любым из: private, static, final, native, strictfp,

synchronized native strictfp



Абстрактные методы Абстрактный метод определяет сигнатуру и список

выбрасываемых исключений для метода, который должен быть реализован ниже по иерархии наследования

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

class BufferEmpty extends Exception {…} class BufferError extends Exception {…}public interface Buffer {

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

abstract char get() throws BufferError; }



Осторожность при перегрузке

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

}class ColoredPoint extends Point {

int color; public String toString() { //ошибка – вызов абстрактного метода:

return super.toString() + ": color " + color; }

}



Модификаторы метода (продолжение) В статическом методе не может использоваться ссылка this Ссылки super и this могут использоваться только в методах

объекта (т.е. методах, не объявленных static)Метод, объявленный final, не может быть перегружен в классах-

наследниках. Никакой метод класса, объявленного final не может быть

перегружен (так как такой класс не может иметь наследников) и, таким образом, все его методы являются final

По своей сути метод, объявленный private является final Компилятор или оптимизатор могут использовать «inline»

подстановку для final и private методов, тем самым увеличивая скорость исполнения программы



Модификаторы метода (продолжение) native методы используются для реализации их тела в

платформенно-зависимой библиотеке, написанной на языке C, C++, Fortran и т.д.

пример: файл производного доступа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;

}



Модификаторы метода (окончание) synchronized методы используются для реализации синхронных

классов-серверов (Параллелизм: класс-сервер может быть последовательным, защищенным или синхронным)

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



Выбрасываемые исключения Список throws определяет исключения, которые должны

обрабатываться при вызове метода (checked exceptions) Throws:

throws ClassTypeList ClassTypeList:

ClassType ClassTypeList , ClassType

Класс, объявленный в списке throws должен быть наследником класса Throwable или самим классом Throwable

Классы-наследники RuntimeException можно не объявлять в списке throws

Классы-наследники Error используются для сигнализации о сбое машины и не должны использоваться в прикладном коде

Метод, перегружающий метод родительского класса или реализующий метод интерфейса не может «расширять» список throws (may not be declared to throw more checked exceptions)



Тело методаMethodBody:

Block ;

Метод, не объявленный как abstract или native должен иметь тело, являющееся блоком

Метод, объявленный void не может содержать оператор видаreturn Expression;

Метод, объявленный с возвращаемым типом Type должен содержать выражение вида return Expression; на каждой возможной ветви завершения метода. При этом тип результата вычисления выражения Expression должен быть совместимым с типом Type

В случае, если возможная ветвь метода завершается явным выбросом исключения, выражение return Expression; может быть опущено



Перегрузка методов (Overriding) Перегрузка методов экземпляра (не статических методов): Метод m1 класса C перегружает метод m2 класса A с той же

сигнатурой, тогда и только тогда, когда: Класс C является наследником класса A либо

m2 не является private и доступен из C m1 перегружает m3, который перегружает m2 и

отличен от m1 и m2 Если m1 не является abstract, то говорят что он реализует

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

перегруженного метода не обеспечивает вызов этого метода (виртуальный полиморфизм) в отличие от обеспечения доступа к сокрытым переменным

static, private, final методы не могут быть перегружены



Сокрытие методов (Hiding)

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

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

Статический метод не может скрывать метод экземпляра (не являющийся статическим)



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

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

либо более открытый уровень доступа: public -> public protected -> protected, public package(default) -> package(default), protected, public

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



Наследование нескольких методов с одинаковой сигнатурой Наследование нескольких методов с одинаковой сигнатурой не

всегда приводит к ошибке. При этом возможны следующие варианты:

Если один из методов не является абстрактным, то: Если этот метод static то возникает ошибка времени

компиляции Иначе этот метод реализует (implements) или перегружает все

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

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

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



Overloading, Overriding, and Hidingclass Point {

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

} class RealPoint extends Point {

float x = 0.0f, y = 0.0f; // hiding x and y// overriding movevoid move(int dx, int dy) {move((float)dx, (float)dy); }//overloading move 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 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() );

} }produces the output:

Goodnight, Dick



Несоответствие списков исключений

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

}



ИнтерфейсыInterfaceDeclaration:

InterfaceModifiersopt interface Identifier ExtendsInterfacesopt InterfaceBody InterfaceModifiers:

InterfaceModifier InterfaceModifiers InterfaceModifier

InterfaceModifier: one of public protected private abstract static strictfp

Допустимо множественное наследование интерфейсов:ExtendsInterfaces:

extends InterfaceType ExtendsInterfaces , InterfaceType

Все интерфейсы являются abstract protected, static, private относятся только к членам-

интерфейсам Глобальные (не вложенные) интерфейсы являются public



Отношение наследования Интерфейс I напрямую зависит от типа T если T присутствует в

списке extends интерфейса I как родительский интерфейс, либо как квалификатор в имени родительского интерфейса.

Интерфейс I зависит от ссылочного типа T если выполняется одно из условий: I напрямую зависит от T. I напрямую зависит от класса C который зависит от T. I напрямую зависит от интерфейса J который зависит от T

(применяя правило рекурсивно). Интерфейс K является родительским (суперинтерфейсом)

интерфейса I если выполняется одно из условий: K является прямым суперинтерфейсом I. Существует интерфейс J такой что K является

суперинтерфейсом J, и J является суперинтерфейсом I, применяя это правило рекурсивно

Интерфейс I называется подинтерфейсом (subinterface) интерфейса K, если K является суперинтерфейсом I.



Тело и члены интерфейсаInterfaceBody:

{ InterfaceMemberDeclarationsopt }

InterfaceMemberDeclarations: InterfaceMemberDeclaration InterfaceMemberDeclarations InterfaceMemberDeclaration

InterfaceMemberDeclaration: ConstantDeclaration AbstractMethodDeclaration ClassDeclaration InterfaceDeclaration ;



Члены интерфейса Членами интерфейса являются:

Члены, объявленные в интерфейсе Члены унаследованные от прямых суперинтерфейсов

Если у интерфейса нет прямых суперинтерфейсов, то интерфейс по умолчанию (неявно) декларирует public abstract метод m сигнатуры s, возвращаемого типа r, и списка исключенийt для каждого public instance метода m сигнатуры s, возвращаемого типа r, и списка исключений t, объявленного в классе Object, кроме таковых объявленных явно в этом интерфейсе.

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

Интерфейс наследует от интерфейсов, которые расширяет (extends) всех членов этих интерфейсов за исключением полей, классов, интерфейсов которые он скрывает(hides) и методов, которые перегружает(overrides).



Константные поля интерфейсовConstantDeclaration:

ConstantModifiersopt Type VariableDeclarators ConstantModifiers:

ConstantModifier ConstantModifiers ConstantModifer

ConstantModifier: one of public static final

Фактически все поля интерфейса являются public static final константами. Декларация данных спецификаторов является избыточной.

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



Инициализация полей интерфейсов Каждое поле в теле интерфейса должно быть

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

Поля инициализируются в порядке их декларации за исключением полей, явно инициализируемых константами.

В выражениях инициализации нельзя использовать ключевые слова this и super кроме случая если эти слова используются внутри декларации тела анонимного класса реализующего интерфейс.

interface Test { float f = j; //error – j используется до объявленияint j = 1; int k = k+1; //error – k инициализируется с использованием k

}



Неоднозначность при наследованииinterface BaseColors {

int RED = 1, GREEN = 2, BLUE = 4; } interface RainbowColors extends BaseColors {

int YELLOW = 3, ORANGE = 5, INDIGO = 6, VIOLET = 7;

} interface PrintColors extends BaseColors {

int YELLOW = 8, CYAN = 16, MAGENTA = 32; } interface LotsOfColors extends RainbowColors,

PrintColors { int FUCHSIA = 17, VERMILION = 43, CHARTREUSE = RED+90;

}



Декларация абстрактных методов

AbstractMethodDeclaration: AbstractMethodModifiersopt ResultType MethodDeclarator Throwsopt ;

AbstractMethodModifiers: AbstractMethodModifier AbstractMethodModifiers AbstractMethodModifier

AbstractMethodModifier: one of public abstract

Фактически все методы интерфейса являются public abstract, и использование данных спецификаторов является избыточным

Будьте осторожны при наследовании интерфейсом от своих суперинтерфейсов методов с одинаковой сигнатурой но несовместимыми возвращаемыми значениями или throws clauses

Все члены-классы и члены-интерфейсы, объявленные в интерфейсе, являются static public по умолчанию и не могут быть внутренними (inner)



Анонимные классыpublic interface MyInterface { void doIt();}public abstract class MyAbstractClass { int i,j; public MyAbstractClass (int i, int j) { this.i = i; this.j = j;} public abstract void doAnother();}//Использование:…MyInterface impl = new MyInterface() {

void doIt() { System.out.println(“Hello!”); }};impl.doIt();



public class Main { public static void main(String[] args) { MyInterface myInterfaceImpl = new MyInterface () { public void doIt () { System.out.println("Hello!"); } }; myInterfaceImpl.doIt();//prints: Hello! MyAbstractClass myAbstractImpl = new MyAbstractClass() { public void doAnother() { System.out.println("Hello again! "+i+" "+j); } }; MyAbstractClass myAbstractImpl2

= new MyAbstractClass(5,6) { public void doAnother() { System.out.println("Hello again! "+i+" "+j); } }; myAbstractImpl.doAnother(); //prints: Hello again! 0 0 myAbstractImpl2.doAnother(); //prints: Hello again! 5 6 }}



Перечисления (enum), начиная с java 1.5 В отличие от статических констант, предоставляют

типизированный, безопасный способ задания фиксированных наборов значений

Являются классами специального вида, не могут иметь наследников, сами в свою очередь наследуются от java.lang.Enum. Не могут быть абстрактными и содержать абстрактные методы, но могут реализовывать интерфейсы

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

Как и обычные классы могут реализовывать поведение, содержать вложенные и внутренние классы-члены



Примерpublic enum Days {

SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY;public boolean isWeekend() {

switch(this) {case SUNDAY:case SATURDAY:

return true;default:

return false;}

} }…System.out.println( Days.MODAY+” isWeekEnd(): “ +

Days.MONDAY.isWeekend() );



Перечисления (продолжение) Каждый класс перечисления неявно содержит

следующие методы: values() - возвращает массив элементов

перечисления (статический метод) ordinal() - возвращает порядковый номер элемента

перечисления (в порядке декларации) valueOf(String name) – возвращает элемент

перечисления по его строковому имени (статический метод, выбрасывает IllegalArgumentException если нет элемента с указанным именем)

Класс перечисления может иметь конструктор (private либо package), который вызывается для каждого элемента при его декларации

Отдельные элементы перечисления могут реализовывать свое собственное поведение



Пример более сложного перечисленияpublic enum Direction {

FORWARD(1.0) {public Direction opposite() {return BACKWARD;}

}, BACKWARD(2.0) {

public Direction opposite() {return FORWARD;}};private double ratio;Direction(double r) { ratio = r; }public double getRatio() {return ratio;}public static Direction byRatio(double r) {

if (r == 1.0) return FORWARD;else if (r == 2.0) return BACKWARD;else throw new IllegalArgumentException();

}}



Пакеты: организация java программ В типичном случае программа состоит из нескольких пакетов Каждый пакет имеет собственное пространство имен для типов

объявленных в пакете Верхнеуровневый тип доступен извне пакета только если он

объявлен со спецификатором public Пакеты образуют иерархическую структуру имен. Членами пакета являются:

классы и интерфейсы, объявленные в единицах компиляции пакета

подпакеты, которые имеют свои собственные подпакеты и единицы компиляции

Пакеты могут располагаться на файловой системе или в базе данных

Пакеты размещаемые на файловой системе имеют ряд ограничений на их организацию для обеспечения однозначности при поиске и загрузке (а также компиляции) типов (и единиц компиляции) и пакета



Пакеты: организация программ

При отображении (хранении) на файловой системе единица компиляции может содержать тоьлко один тип объявленный public совпадающий по имени с именем файла единицы компиляции

com.somecompany.project

another

Third.java

one subpackage

Second.java

First.java:public classFirst {...}class Cls {...}

Filesystem:/com /somecompany /project /one First.java First.class Cls.class Second.java Second.class /subpackage /another Third.java Third.class



Единицы компиляции Пакет содержит несколько единиц компиляции Типы внутри единицы компиляции имеют доступ ко

всем верхнеуровневым типам, объявленным в других единицах компиляции данного пакета а также к типам пакета java.lang

Для доступа к другим пакетам используется декларация import

CompilationUnit: PackageDeclarationopt ImportDeclarationsopt TypeDeclarationsopt

ImportDeclarations: ImportDeclaration ImportDeclarations ImportDeclaration

TypeDeclarations: TypeDeclaration TypeDeclarations TypeDeclaration



Именованные и безымянные пакетыОбъявление именованного пакета:PackageDeclaration:

package PackageName; В качестве имени пакета выступает полное квалифицированное

имя: например com.somecompany.project.one для First.java

Единицы компиляции безымянного пакета не содержат объявление пакета

Безымянные пакеты следует использовать только в небольших тестовых программах

Переменная окружения CLASSPATH содержит точки привязки иерархий пакетов к точкам в файловой системе (коими могут являться директории и архивные jar или zip файлы)

Классы находящиеся во всех «корневых» директориях точек привязки CLASSPATH принадлежат к единому безымянному пакету



Декларация import Декларация имени пакета распространяется на всю единицу

компиляции Декларации import также распространяются на всю единицу

компиляции Для того чтобы получить доступ к членам подпакета в единице

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

ImportDeclaration: SingleTypeImportDeclaration TypeImportOnDemandDeclaration

import java.io.InputStream; // single type import declarationimport java.net.*; // import on demand declaration

Будучи импортированными типы становятся доступны в единице компиляции с использованием простого (не квалифицированного) имени.



Статический импорт (начиная с java 1.5) Для того чтобы иметь возможность обращаться к

статическим методам, полям класса, а также к элементам перечислений без использования квалифицированного имени, можно воспользоваться статической декларацией импорта:

import static Days.* ;import static java.lang.Math.*;…Day d = MONDAY;Day d2 = valueOf(“SATURDAY”);double v = sin(PI/2); Однако злоупотреблять статическим импортом не стоит



Сокрытие и конфликты importsingle-type-import декларация d в единице компиляции c пакета p

импортирующая тип n, скрывает: любой верхнеуровневый тип n, объявленный в другой единице

компиляции пакета p любой тип n импортированный type-imoprt-on-demand

декларацией в c нельзя импортировать пакет, можно импортировать только типы:import java.util; - ведет к ошибке времени компиляции верхнеуровневые типы объявленные внутри единицы компиляции,

а также вложенные типы скрывают типы, импортируемые type-import-on-demand декларацией, при использовании простого имени.

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



«Странный» примерpackage Vector; public class Mosquito {

int capacity; }package strange.example; import java.util.Vector; import Vector.Mosquito; class Test { public static void main(String[] args){ System.out.println(new Vector().getClass()); System.out.println(new Mosquito().getClass());

} } Вывод:class java.util.Vector class Vector.Mosquito



Двойная декларацияpackage test; import java.util.Vector; class Point {

int x, y; } interface Point { // compile-time error #1

int getR(); int getTheta();

} class Vector { // compile-time error #2

Point[] pts; }---------------------------------------------------package test; import java.util.*; class Vector { Point[] pts; } // not a error



Опережающее использование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 } //all is OK!



Правила именования пакетов Для обеспечения уникальности имени пакета в качестве

основы следует использовать доменное имя организации, например: ru.nsu.fit.mylastname.task1

В случае если доменное имя не может быть использовано в силу наличия специальных символов, запрещенных к использованию в идентификаторах, нужно произвести следующую трансформацию: если имя содержит знак ‘-’, его заменяют на ‘_’: some-ware.com ->

com.some_ware если имя является ключевым словом, то к нему добавляют ‘_’:

do.something.com -> com.something.do_; если имя начинается с цифры, то спереди добавляется ‘_’:

just.4you.com -> com._4you.just Примеры имен:com.sun.java.jag.scrabble com.apple.quicktime.v2 com.novosoft.siberon.someproject



Полное квалифицированное имяПолным квалифицированным именем является: для примитивных типов – ключевое слово типа для именованного пакета первого уровня – простое имя этого

пакета для именованного пакета уровня N – полное квалифицированное

имя объемлющего пакета плюс простое имя пакета: outer1.outer2.outerN-1.packagename

для класса или интерфейса в безымянном пакете – простое имя этого класса или интерфейса

полное квалифицированное имя класса или интерфейса в именованном пакете – это полное квалифицированное имя пакета плюс простое имя класса или интерфейса: outerpackage1...outerpackageN-1.packagename.ClassName



Полное квалифицированное имя класс (интерфейс) – член другого класса имеет полное

квалифицированное имя только если таковое имеется у класса его содержащего: outerpackage1.….outerpackageN.OuterClass1.….OuterClassM.Member

исключение – безымянные классы Полное квалифицированное имя массива – это полное

квалифицированное имя компонентного типа с последующим []

Примеры полностью квалифицированных имен:java.lang.Objectjava.util.Map.Entryintjava.lang.String[]

Documents

Основы программирования на языке Java