Конструктор по умолчанию java. Конструкторы Java. Вызов перегруженных конструкторов через this()

Метод в Java - это комплекс выражений, совокупность которых позволяет выполнить определенную операцию. Так, например, при вызове метода System.out.println(), система выполняет ряд команд для выведения сообщения на консоль.

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

Создание метода

Ниже рассмотрен пример, иллюстрирующий синтаксис метода, как в Java создать метод.

Синтаксис

• public static - модификатор;
• int - возвращаемый тип;
• methodName - имя метода;
• a, b - формальные параметры;
• int a, int b - перечень параметров.

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

Синтаксис

Приведенный выше синтаксис включает:

• modifier – определяет тип доступа для метода и возможность его использования.
• returnType – метод может возвратить значение.
• nameOfMethod – указывает имя метода. Сигнатура метода включает имя метода и перечень параметров.
• Parameter List – перечень параметров представлен типом, порядком и количеством параметров метода. Данная опция задается произвольно, в методе может присутствовать нулевой параметр.
• method body – тело метода определяет метод работы с командами.

Пример

/* фрагмент кода возвращает минимальное между двумя числами */ public static int minFunction(int n1, int n2) { int min; if (n1 > n2) min = n2; else min = n1; return min; }

Вызов метода

Перед использованием метода его необходимо вызвать. Существует два способа для вызова метода в Java, т.е. метод производит возврат значения либо не производит (отсутствует возвращающее значение).

Алгоритм вызова метода достаточно прост. Когда программа производит в Java вызов метода, программное управление передается вызванному методу. Данный вызванный метод затем возвращает управление вызывающему клиенту в двух случаях, если:

• выполняется оператор возврата;
• достигнута закрывающая фигурная скобка окончания метода.

Метод возврата типа void производит вызов команды. Рассмотрим пример:

System.out.!");

Метод возврата значения может быть проиллюстрирован следующим примером:

Int result = sum(6, 9);

Пример ниже демонстрирует способ определения и вызова метода в Java.

Пример

Минимальное значение = 6

Ключевое слово void

Ключевое слово void в Java позволяет нам создать методы, не производящие возврат значения. В примере, расположенном далее, нами был рассмотрен метод типа void – methodRankPoints. Методы типа void в Java не производят возврат каких-либо значений. Вызов метода типа void выполняется командой, т.е. methodRankPoints(255.7);. Это java-выражение, которое оканчивается точкой с запятой, как показано в примере ниже:

Пример

В итоге будет получен следующий результат:

Ранг A1

Передача параметров по значению в Java

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

В Java передача параметров по значению обозначает вызов метода с параметром. За счет этого производится передача значения аргумента параметру.

Пример

Следующая программа демонстрирует пример передачи параметра по значению. Значения аргументов остаются неизменными даже после вызова метода.

Public class swappingExample { public static void main(String args) { int a = 30; int b = 45; System.out.println("Перед тем как передать, значения аргументов a = " + a + " и b = " + b); // Вызов метода передачи swapFunction(a, b); System.out.println("\nСейчас, до и после передачи значения аргументов "); System.out.println("остались неизменными, a = " + a + " и b = " + b); } public static void swapFunction(int a, int b) { System.out.println("До замены: a = " + a + " b = " + b); // Передача параметров int c = a; a = b; b = c; System.out.println("После замены: a = " + a + " b = " + b); } }

Получим следующий результат:

Перед тем как передать, значения аргументов a = 30 и b = 45 До замены: a = 30 b = 45 После замены: a = 45 b = 30 Сейчас, до и после передачи значения аргументов остались неизменными, a = 30 и b = 45

Перегрузка методов

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

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

Рассмотренный пример поясняет вышесказанное.

Пример

В итоге будет получен следующий результат:

Минимальное значение = 3 Минимальное значение = 5.1

Методы перегрузки делают программу читаемой. Таким образом, представлены два метода с одинаковым именем, но различными параметрами. В результате чего мы получили минимальные int число и число double типа.

Использование аргументов командной строки

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

В Java аргумент командной строки представляет информацию, которая напрямую следует за именем программы в командной строке при ее выполнении. Получение доступа к аргументам командной строки в java-программе не представляет сложности. Они хранятся в виде строки в массиве строк, переданном в main().

Пример

Программа ниже отображает все вызванные аргументы командной строки.

Public class CommandLine { public static void main(String args) { for(int i = 0; i

Попробуйте выполнить данную программу, как показано далее:

$java CommandLine это командная строка 300 -200

В итоге будет получен следующий результат:

Args: это args: командная args: строка args: 300 args: -200

Конструктор в Java

В Java конструктор инициализирует объект при его создании. Его имя аналогично имени класса, а синтаксис сходен с синтаксисом метода. Однако, в отличие от последнего, в конструкторе отсутствует возвращаемое значение.

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

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

Пример

В примере ниже рассмотрено использование конструктора класса без параметров.

// Простой конструктор. class MyClass { int x; // Далее следует конструктор MyClass() { x = 10; } }

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

Public class ConsDemo { public static void main(String args) { MyClass t1 = new MyClass(); MyClass t2 = new MyClass(); System.out.println(t1.x + " " + t2.x); } }

Получим результат:

Параметризованный конструктор

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

Пример

// Простой конструктор. class MyClass { int x; // Ниже конструктор MyClass(int i) { x = i; } }

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

Public class ConsDemo { public static void main(String args) { MyClass t1 = new MyClass(10); MyClass t2 = new MyClass(20); System.out.println(t1.x + " " + t2.x); } }

Получим следующий результат:

Ключевое слово this

Ключевое слово this - используется для ссылки на текущий класс с учетом метода или конструктора экземпляра. Используя this в Java, Вы можете ссылаться на экземпляры класса, такие как конструкторы, переменные и методы.

Примечание: ключевое слово this используется только в составе методов либо конструкторов экземпляра.

Как правило, ключевое слово this в Java используется для:

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

• вызова конструктора одного типа (параметризованного конструктора либо конструктора по умолчанию) из другого в составе класса. Данный процесс также носит название явного вызова конструктора.

Пример

Public class This_Example { // Инициализация переменной num int num = 11; This_Example() { System.out.println("Это пример программы с ключевым словом this"); } This_Example(int num) { // Вызов конструктора по умолчанию this(); // Присвоение локальной переменной num переменной экземпляра num this.num = num; } public void greet() { System.out.println("Привет! Добро пожаловать на ProgLang!"); } public void print() { // Локальная переменная num int num = 20; // Вызов метода класса greet this.greet(); // Вывод локальной переменной. System.out.println("Значение локальной переменной num: " + num); // Вывод переменной экземпляра. System.out.println("Значение переменной экземпляра num: " + this.num); } public static void main(String args) { // Инициализация класса This_Example obj1 = new This_Example(); // Вызов метода print obj1.print(); // Передача нового значения переменной num через параметризованный конструктор This_Example obj2 = new This_Example(30); // Вызов снова метода print obj2.print(); } }

В итоге будет получен следующий результат:

Это пример программы с ключевым словом this Привет! Добро пожаловать на ProgLang! Значение локальной переменной num: 22 Значение переменной экземпляра num: 11 Это пример программы с ключевым словом this Привет! Добро пожаловать на ProgLang! Значение локальной переменной num: 22 Значение переменной экземпляра num: 30

Аргументы переменной (var-args)

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

TypeName... parameterName

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

Пример

В итоге будет получен следующий результат:

Максимальное значение 77.1 Максимальное значение 77.0

Метод finalize()

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

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

Для добавления финализатора в класс, вам просто следует определить метод finalize() в Java. Среда выполнения Java производит вызов данного метода непосредственно перед обработкой объекта данного класса.

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

В общем виде метод finalize() выглядит следующим образом:

Protected void finalize() { // здесь финализация кода }

Здесь ключевое слово protected представляет спецификатор, предотвращающий доступ к finalize() посредством кода, определяемого вне его класса.

Это свидетельствует о том, что вы не можете знать как или даже когда будет производиться выполнение finalize(). К примеру, если ваша программа будет окончена до «сборки мусора», finalize() не будет выполняться.

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

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

Private int Cat(); // так выглядит метод по имени Cat Cat(); // так выглядит конструктор класса Cat

В отличие от метода, конструктор никогда ничего не возвращает.

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

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

Class Box { int width; // ширина коробки int height; // высота коробки int depth; // глубина коробки // Конструктор Box() { width = 10; height = 10; depth = 10; } // вычисляем объём коробки int getVolume() { return width * height * depth; } }

Мы временно удалили метод setDim() и добавили конструктор. Посмотрим, что получится:

Box catBox = new Box(); mInfoTextView.setText("Объём коробки: " + catBox.getVolume());

Программа выведет объём коробки, хотя мы не задавали никаких размеров для неё. Благодаря конструктору любая создаваемая коробка будет иметь какой-то зафиксированный объём.

Естественно, вы можете вернуть обратно метод setDim() (см. статью про классы) и установить свои размеры для коробки:

Box catBox = new Box(); // установим свои размеры для коробки catBox.setDim(10, 20, 30); mInfoTextView.setText("Объём коробки: " + catBox.getVolume());

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

Возникает вопрос - но ведь сначала при создании класса мы не создавали конструктор, однако код new Box() работал. Дело в том, что если конструктор не определён явно, то Java создаст конструктор, который будет использоваться по умолчанию. В этом случае он просто присвоит всем переменным нулевые значения. Если вы создали сами конструктор, то конструктор по умолчанию использоваться не будет.

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

Cat cat = new Cat(8); // коту 8 лет

Если Cat(int) является единственным конструктором класса, то компилятор не позволит создавать объекты Cat каким-либо другим способом.

Однако вернёмся к коробкам для котов. Созданный нами конструктор не особо полезен, так как создаёт одинаковые коробки. Создадим конструктор с параметрами в классе Box и закомментируйте первый конструктор без параметров:

// Второй конструктор Box(int w, int h, int d) { width = w; height = h; depth = d; }

Если класс содержит один конструктор с параметрами, то вам придётся обязательно указать значения при объявлении класса:

// Это конструктор теперь не допустим // Box catBox = new Box(); // В конструкторе нужно указать значения размеров коробки Box catBox = new Box(100, 200, 100); mInfoTextView.setText("Объём коробки: " + catBox.getVolume());

Кстати, с таким конструктором метод setDim() нам уже не нужен. Мы можем задать размеры коробки сразу в конструкторе. Так как скорее всего коробка постоянна и не меняет своих размеров, то метод, пожалуй, лишний. Но если мы будем менять размеры коробки, то метод придётся оставить.

Класс может иметь несколько конструкторов. Снимите комментарий с первого конструктора и создайте две коробки - коробку по умолчанию и большую коробку.

Box defaultBox = new Box(); mInfoTextView.setText("Объём стандартной коробки: " + defaultBox.getVolume()); Box bigBox = new Box(100, 200, 200); mInfoTextView.append("\nОбъём большой коробки: " + bigBox.getVolume());

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

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

// Третий конструктор для куба Box(int len) { width = height = depth = len; }

Вычисляем размер куба:

Box cube = new Box(5); int vol = cube.getVolume(); mInfoTextView.setText("Объём куба: " + vol);

Используем объект в качестве параметров

Мы пока использовали в качестве параметров в конструкторах простые типы. Но можно передать и объект самого класса. Добавим ещё один конструктор:

// Используем объект типа Box Box(Box ob) { width = ob.width; height = ob.height; depth = ob.depth; }

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

Box box1 = new Box(100, 200, 100); Box cloneBox = new Box(box1); int vol = cloneBox.getVolume(); mInfoTextView.setText("Объём коробки: " + vol);

Класс Box (исходник)

Вызов перегруженных конструкторов через this()

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

Для начала создадим класс, который не использует конструктор this() , чтобы понять разницу.

Class Cat { int age; int birthday; // Инициализируем переменные явно Cat(int i, int j) { age = i; birthday = j; } // Инициализируем переменные одним и тем значением Cat(int i) { age = i; birthday = i; } // Присвоим значения по умолчанию 0 Cat() { age = 0; birthday = 0; } }

Мы создали класс с тремя конструкторами. Перепишем класс, используя конструктор this() .

Class Cat{ int age; int birthday; // Инициализируем переменные явно Cat(int i, int j) { age = i; birthday = j; } // Инициализируем переменные одним и тем значением Cat(int i) { this(i, i); // вызывается Cat(i, i); } // Присвоим значения по умолчанию 0 Cat() { this(0); // вызывается Cat(0); } }

У нас теперь только один конструктор, который присваивает значения полям - Cat(int, int). Что происходит при выполнении оператора:

Cat cat = new Cat(8);

Вызов конструктора Cat(8) приводит к выполнению конструктора this(8, 8) , что равнозначно вызову конструктора Cat(8, 8) .

Что происходит при выполнении оператора:

Cat cat2 = new Cat();

В этом случае вызывается конструктор this(0) , что приводит к выполнению конструктора Cat(0) , поскольку именно эта версия конструктора подходит по списку параметров. При этом конструктор Cat(0) по сути вызывает конструктор Cat(0, 0) .

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

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

Закрытый конструктор

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

Public class Utils { private Utils() { throw new AssertionError(); } ... //ваш правильный код // Неправильный код, только для демонстрации! public static void someMethod(){ Utils utils = new Utils(); utils.toString(); } }

Строка throw new AssertionError() не является обязательной, но она поможет выявить ошибку, если вы вызовете конструктор в самом классе. Компилятор пропустит такой вариант, но программа завершится с ошибкой.

Utils.someMethod(); // программа закроется с ошибкой

Подкласс для данного класса вы создать не сможете.

Как известно, объект является экземпляром определенного класса. Для его создания используется ключевое слово new, например:
Person student = new Person(“Mike”)
Этим кодом создается новый объект Person и указывается его имя – Mike . Строка «Mike » передается аргументом соответствующему конструктору Person :

Person(String name) { this.name = name; }

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

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

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

Ниже представлен набор из 7 основных правил работы с конструкторами , позволяющие полностью разобраться в их работе.

1. Конструкторы можно перегружать :

Это означает, что класс может иметь множество различных конструкторов, если их списки параметров различны. Например:

Class Rectangle { int width; int height; Rectangle() { width = 1; height = 1; } Rectangle(int width) { this. width = width; this. height = width; } Rectangle(int width, int height) { this. width = width; this. height = height; } }

Имея три различных конструктора Rectangle можно создавать новый объект тремя различными способами:

Rectangle rect1 = new Rectangle(); Rectangle rect2 = new Rectangle(10); Rectangle rect3 = new Rectangle(10,20);

1. Конструктор по умолчанию :

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

Например, если мы напишем класс Rectangle следующим образом:

Class Rectangle { int widh, height; int area() { } int perimeter() { } }

То компилятор автоматически вставляет конструктор по умолчанию: ectangle() { }

1. Компилятор не будет генерировать конструктор по умолчанию, если в классе уже есть конструктор:

Рассмотрим следующий пример:

Class Rectangle { int width; int height; Rectangle(int width) { this. width = width; this. height = width; } Rectangle(int width, int height) { this. width = width; this. height = height; } }

При попытке создать новый объект: Rectangle rect1 = new Rectangle(); Компилятор выдаст ошибку, потому что не может найти конструктор без аргументов.

1. Конструкторы не наследуются:

В отличие от методов, конструкторы не наследуются. Пример:

Class Rectangle { Rectangle(int width, int height) { } } class Square extends Rectangle { }

Нельзя сделать что-то вроде этого: Square box = new Square(10, 10);

1. Конструкторы могут быть приватными!

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

В шаблоне проектирования, называемом Singleton , приватный конструктор используется, чтобы гарантировать, что всегда существует только один экземпляр класса. Класс Singleton предоставляет статический метод для получения этого уникального экземпляра.

1. Конструктор по умолчанию имеет тот же модификатор доступа, что и класс:

При написании следующего класса: public class Person { }

Компилятор при вставке конструктора по умолчанию, укажет и необходимый модификатор доступа: public Preson();

1. Первой строкой любого конструктора должен вызываться либо перегруженный конструктор того же класса или конструктор его суперкласса:

Если это не так, то компилятор автоматически допишет вызов конструктора суперкласса без аргументов super(); Это может привести к ошибке, поскольку такого конструктора может не быть в суперклассе. Пример:

Class Parent { Parent(int number) { } } class Child extends Parent { Child() { } }

Приведет к ошибке, потому что компилятор вставляет вызов super () в конструкторе класса Child :

Child() { super();// дописал компилятор }

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

Дело в том, что:

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

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

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

Почему? Потому что раз Вы наследуетесь от какого-то класса, Вы хотите повторно использовать его логику. Конструктор приводит экземпляр класса в какое-то начальное целостное состояние. В Вашем случае для инициализации AClass требует аргумент, без которого JVM не знает, как инициализировать экземпляр класса.

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

Public class AClass1 { }

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

Это эквивалентно такому определению:

Public class AClass1 { public AClass1() { } }

Теперь посмотрим на BClass1:

Public class BClass1 extends AClass1 { }

Здесь тоже явно конструкторы не определены, и компилятор пытается создать конструктор по умолчанию. Поскольку в классе AClass1 есть конструктор по умолчанию, он создаст конструктор по умолчанию, который будет вызывать конструктор AClass1. Этот код эквивалентен такому:

Public class BClass1 extends AClass1 { public BClass1() { super(); } }

В Вашем случае создается класс БЕЗ конструктора по умолчанию:

Public AClass { public AClass(int i) { } }

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

AClass a = new AClass(); // не работает

нужно что-то вроде

AClass a = new AClass(1);

Соответственно, любой конструктор BClass будет требовать вызова какого-либо конструктора AClass или BClass. При таком описании компилятор будет ругаться:

Public BClass extends AClass { }

Потому что будет попытка вызова конструкора по умолчанию класса AClass, который не определен:

Public BClass extends AClass { public BClass() { super(); // ошибка; в классе AClass нет такого конструктора } }

Тем не менее, можно создать класс BClass с конструктором по умолчанию, задав какое-то значение для конструктора AClass:

Public class BClass extends AClass { public BClass() { super(1); } }

Это будет компилироваться.

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

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

public long idNUm;

public String name = "<Без имени>";

public Body orbits = null;

private static long nextID = 0;

idNUm = nextID++;

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

Конструктор класса Body объявлен без параметров. Его назначение довольно важно – он обеспечивает уникальность значения поля idNum вновь создаваемого объекта класса. В исходном варианте класса небольшая ошибка программиста-пользователя, связанная, например, с неаккуратно выполненной операцией присваивания значения полю idNum либо с отсутствием инструкций приращения содержимого поля nextID, могла бы привести к тому, что несколько объектов Body получили бы один и тот же порядковый номер. Подобный результат явно Ошибочен, поскольку нарушает ту часть контракта класса, которая гласит:

"Значения idNum различных объектов класса должны быть уникальными".

Передав ответственность за выбор верных значений idNum самому классу, мы раз и навсегда избавимся от подобных ошибок. Теперь конструктор класса Body – это единственный субъект, который изменяет содержимое поля nextID и нуждается в доступе к нему. Поэтому мы можем и должны обозначить переменную nextID модификатором private, чтобы предотвратить возможность обращения к ней за пределами класса. Сделав это, мы исключим один из потенциальных источников ошибок, грозящих будущим пользователям нашего класса.

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

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

Body sun = new Body(); // idNUm = 0

sun. name = "Солнце";

Body earth = new Body(); // idNum = 1

earth.name = "земля";

earth.orbits = sun;

В Процессе создания объекта с помощью оператора new конструктор класса Body Вызывается после присваивания полям name и огbits предусмотренных нами Выражений инициализации.

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

Body(String bodyName, Body orbitsAround) {

name = bodyName; orbits = orbitsAround;

Как нетрудно заметить, один конструктор класса обращается к другому посредством выражения this – первой исполняемой инструкции в теле конструктора-инициатора. Подобное предложение называют явным вызовом конструктора. Если конструктор, к которому вы намереваетесь обратиться явно, предполагает задание аргументов, при вызове они должны быть переданы. Какой из конструкторов будет вызван – это обусловливается количеством аргументов и набором их типов. В данном случае выражение this означает вызов конструктора без параметров, позволяющего установить значение idNum объекта и увеличить текущее содержимое статического поля nextID на единицу. Обращение к this дает возможность избежать повторения кода инициализации idNum и изменения nextID. Теперь код, предусматривающий создание объектов, становится существенно более простым:

Body sun = new Bоdу("солнце", null);

Body earth = new Воdу("земля", sun);

Версия конструктора, вызываемого в процессе выполнения оператора new, определяется структурой списка передаваемых аргументов.

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

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

Body(String bodyName) {

this (bodyName, null);

Здесь вновь используется прием явного вызова конструктора.

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

Ниже перечислено несколько причин, обусловливающих применение специализированных конструкторов.

· Без помощи конструкторов с параметрами некоторые классы не в состоянии обеспечить свои объекты приемлемыми исходными значениями.

· При использовании дополнительных конструкторов задача определения начальных свойств объектов упрощается (наглядный пример – конструктор класса Body с двумя параметрами).

· Создание объекта зачастую связано с большими издержками из-за некорректного выбора инициализаторов. Например, если объект класса содержит таблицу и вычислительные затраты на ее конструирование велики, было бы совершенно неразумно предусматривать инициализатор по умолчанию, заведомо зная, что позже так или иначе придется отбросить результат его работы и повторить инициализацию, чтобы придать таблице свойства, нужные в конкретной ситуации. Целесообразнее сразу применить подходящий конструктор, который способен создать таблицу с требуемыми свойствами.

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

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

будет помечен как publiс.

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

Body(Body other) {

idNum = other.idNum;

name = other.name;

orbits = other.orbits;

Подход к решению задачи копирования объектов, связанный с применением специальных конструкторов, в классах стандартных пакетов Java широкого распространения не нашел, поскольку для достижения подобной цели более предпочтительным считается использование метода Сlone (обратитесь к разделу 3.9 на странице 111). Впрочем, простой конструктор копии предусмотрен, например, в составе класса String, а в классах коллекций (они рассматриваются в главе 16)

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

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

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