Н.А. Вязовик - Программирование на Java

final double PI=3.1415;

Также допускается инициализация final -полей в конце каждого конструктора класса.

Не обязательно использовать для инициализации константы компиляции, возможно обращение к различным функциям, например:

final long creationTime =

System.currentTimeMillis();

Данное поле будет хранить время создания объекта. Существует еще два специальных модификатора - transient и volatile. Они будут рассмотрены в соответствующих лекциях.

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

int a;

int b=3, c=b+5, d;

Point p, p1=null, p2=new Point();

Повторяющиеся имена полей запрещены. Указанный идентификатор при объявлении становится простым именем поля. Составное имя формируется из имени класса или имени переменной объектного типа, и простого имени поля. Областью видимости поля является все объявление тела класса.

Запрещается использовать поле в инициализации других полей до его объявления.

int y=x;

int x=3;

Однако, в остальном поля можно объявлять и ниже их использования:

class Point {

int getX() {return x;}

int y=getX();

int x=3;

}

public static void main (String s[]) {

Point p=new Point();

System.out.println(p.x+", "+p.y);

}

Результатом будет:

3,0

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

* для числовых полей примитивных типов – 0 ;

* для булевского типа – false ;

* для ссылочных – null.

Таким образом, при инициализации переменной y был использован результат метода getX(), который вернул значение по умолчанию переменной x, то есть 0. Затем переменная x получила значение 3.

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

Объявление метода состоит из заголовка и тела метода. Заголовок состоит из:

* модификаторов (доступа в том числе);

* типа возвращаемого значения или ключевого слова void ;

* имени метода ;

* списка аргументов в круглых скобках (аргументов может не быть);

* специального throws -выражения.

Заголовок начинается с перечисления модификаторов. Для методов доступен любой из трех возможных модификаторов доступа. Также допускается использование доступа по умолчанию.

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

Также поддерживается модификатор native. Метод, объявленный с таким модификатором, не имеет реализации на Java. Он должен быть написан на другом языке (C/C++, Fortran и т.д.) и добавлен в систему в виде загружаемой динамической библиотеки (например, DLL для Windows). Существует специальная спецификация JNI (Java Native Interface), описывающая правила создания и использования native - методов.

Такая возможность для Java необходима, поскольку многие компании имеют обширные программные библиотеки, написанные на более старых языках. Их было бы очень трудоемко и неэффективно переписывать на Java, поэтому необходима возможность подключать их в таком виде, в каком они есть. Безусловно, при этом Java-приложения теряют целый ряд своих преимуществ, таких, как переносимость, безопасность и другие. Поэтому применять JNI следует только в случае крайней необходимости.

Эта спецификация накладывает требования на имена процедур во внешних библиотеках (она составляет их из имени пакета, класса и самого native - метода ), а поскольку библиотеки менять, как правило, очень неудобно, часто пишут специальные библиотеки-"обертки", к которым обращаются Java-классы через JNI, а они сами обращаются к целевым модулям.

Наконец, существует еще один специальный модификатор synchronized, который будет рассмотрен в лекции, описывающей потоки выполнения.

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

Затем определяется имя метода. Указанный идентификатор при объявлении становится простым именем метода. Составное имя формируется из имени класса или имени переменной объектного типа и простого имени метода. Областью видимости метода является все объявление тела класса.

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

// void calc (double x, y);

- ошибка! void calc (double x, double y);

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

public void process(int x, final double y) {

x=x*x+Math.sqrt(x);

// y=Math.sin(x); - так писать нельзя,

// т.к. y - final!

}

О том, как происходит изменение значений аргументов метода, рассказано в конце этой лекции.

Важным понятием является сигнатура (signature) метода. Сигнатура определяется именем метода и его аргументами (количеством, типом, порядком следования). Если для полей запрещается совпадение имен, то для методов в классе запрещено создание двух методов с одинаковыми сигнатурами.

Например,

class Point {

void get() {}

void get(int x) {}

void get(int x, double y) {}

void get(double x, int y) {}

}

Такой класс объявлен корректно. Следующие пары методов в одном классе друг с другом несовместимы:

void get() {}

int get() {}

void get(int x) {}

void get(int y) {}

public int get() {}

private int get() {}

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

// пример вызовет ошибку компиляции

class Test {

int get() {

return 5;

}

Point get() {

return new Point(3,5);

}

void print(int x) {

System.out.println("it's int! "+x);

}

void print(Point p) {

System.out.println("it's Point! "+p.x+ ", "+p.y);

}

public static void main (String s[]) {

Test t = new Test();

t.print(t.get());

// Двусмысленность!

}

}

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