Конструкторы. Конструкторы по умолчанию. Вызов конструкторов класса из других конструкторов. Конструкторы Java

Конструктор – это схожая c методом структура, назначение которой состоит в создании экземпляра класса. Характеристики конструктора:

• Имя конструктора должно совпадать с именем класса (по договоренности, первая буква - заглавная, обычно имя существительное);
• Конструктор имеется в любом классе. Даже если вы его не написали, компилятор Java сам создаст конструктор по умолчанию (default constructor), который будет пустым и не делает ничего, кроме вызова конструктора суперкласса.
• Конструктор похож на метод, но не является методом, он даже не считается членом класса. Поэтому его нельзя наследовать или переопределить в подклассе;
• Конструкторы не наследуются;
• Конструкторов может быть несколько в классе. В этом случае конструкторы называют перегруженными;
• Если в классе не описан конструктор, компилятор автоматически добавляет в код конструктор без параметров;
• Конструктор не имеет возвращаемого типа, им не может быть даже тип void , если возвращается тип void , то это уже не конструктор а метод, несмотря на совпадение с именем класса.
• В конструкторе допускается оператор return , но только пустой, без всякого возвращаемого значения;
• В конструкторе допускается применение модификаторов доступа, можно задать один из модификаторов: public , protected , private или без модификатора.
• Конструктор не может иметь модификаторов abstract , final , native , static или synchronized ;
• Ключевое слово this cсылается на другой конструктор в этом же классе. Если используется, то обращение должно к нему быть первой строкой конструктора;
• Ключевое слово super вызывает конструктор родительского класса. Если используется, должно обращение к нему быть первой строкой конструктора;
• Если конструктор не делает вызов конструктора super класса-предка (с аргументами или без аргументов), компилятор автоматически добавляет код вызова конструктора класса-предка без аргументов;

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

Конструктор имеется в любом классе. Даже если вы его не написали, компилятор Java сам создаст конструктор по умолчанию (default constructor). Этот конструктор пустой и не делает ничего, кроме вызова конструктора суперкласса. Т.е. если написать: public class Example { } то это эквивалентно написанию: public class Example { Example () { super ; } } В данном случае явно класса предка не указано, а по умолчанию все классы Java наследуют класс Object поэтому вызывается конструктор класса Object . Если в классе определен конструктор с параметрами, а перегруженного конструктора без параметров нет, то вызов конструктора без параметров является ошибкой. Тем не менее, в Java, начиная с версии 1.5, можно использовать конструкторы с аргументами переменной длины. И если есть конструктор, имеющий аргумент переменной длины, то вызов конструктора по умолчанию ошибкой не будет. Не будет потому, что аргумент переменной длины может быть пустым. Например, следующий пример не будет компилироваться, однако если раскомментарить конструктор с аргументом переменной длины, то компиляция и запуск пройдут успешно и в результате работы строки кода DefaultDemo dd = new DefaultDemo() ; вызовется конструктор DefaultDemo(int ... v) . Естественно, что в данном случае необходимо пользоваться JSDK 1.5. Файл DefaultDemo.java class DefaultDemo { DefaultDemo (String s) { System. out. print ("DefaultDemo(String)" ) ; } /* DefaultDemo(int ... v) { System.out.println("DefaultDemo(int ...)"); } */ public static void main (String args ) { DefaultDemo dd = new DefaultDemo () ; } } Результат вывода программы при раскомментаренном конструкторе: DefaultDemo (int . . . ) Однако, в распространенном случае, когда в классе вообще не определено ни одного конструктора, вызов конструктора по умолчанию (без параметров) будет обязательным явлением, поскольку подстановка конструктора по умолчанию происходит автоматически.

При создании объекта последовательно выполняются следующие действия:

• Ищется класс объекта среди уже используемых в программе классов. Если его нет, то он ищется во всех доступных программе каталогах и библиотеках. После обнаружения класса в каталоге или библиотеке выполняется создание, и инициализация статических полей класса. Т.е. для каждого класса статические поля инициализируются только один раз.
• Выделяется память под объект.
• Выполняется инициализация полей класса.
• Отрабатывает конструктор класса.
• Формируется ссылка на созданный и инициализированный объект. Эта ссылка и является значением выражения, создающего объект. Объект может быть создан и с помощью вызова метода newInstance() класса java.lang.Class . В этом случае используется конструктор без списка параметров.

Перегрузка конструкторов

Конструкторы одного класса могут иметь одинаковое имя и различную сигнатуру. Такое свойство называется совмещением или перегрузкой(overloading). Если класс имеет несколько конструкторов, то присутствует перегрузка конструкторов.

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

Сигнатура конструктора – это количество и типы параметров, а также последовательность их типов в списке параметров конструктора. Тип возвращаемого результата не учитывается. Конструктор не возвращает никаких параметров. Это положение объясняет в некотором смысле, как Java различает перегруженные конструкторы или методы. Java различает перегруженные методы не по возвращаемому типу, а по числу, типам и последовательности типов входных параметров. Конструктор не может возвращать даже тип void , иначе он превратится в обычный метод, даже не смотря на сходство с именем класса. Следующий пример демонстрирует это. Файл VoidDemo.java class VoidDemo { /** * Это конструктор */ VoidDemo () { System. out. println ("Constructor" ) ; } void VoidDemo () { System. out. println ("Method" ) ; } public static void main (String s ) { VoidDemo m = new VoidDemo () ; } } В результате программа выведет: Constructor Это лишний раз доказывает, что конструктором является метод без возвращаемых параметров. Тем не менее, для конструктора можно задать один из трех модификаторов public , private или protected . И пример теперь будет выглядеть следующим образом: Файл VoidDemo2.java class VoidDemo2 { /** * Это конструктор */ public VoidDemo2 () { System. out. println ("Constructor" ) ; } /** * А это уже обычный метод, даже не смотря на сходство с * именем класса, поскольку имеется возвращаемый тип void */ private void VoidDemo2 () { System. out. println ("Method" ) ; } public static void main (String s ) { VoidDemo2 m = new VoidDemo2 () ; } } В конструкторе разрешается записывать оператор return , но только пустой, без всякого возвращаемого значения. Файл ReturnDemo.java class ReturnDemo { /** * В конструкторе допускается использование оператора * return без параметров. */ public ReturnDemo () { System. out. println ("Constructor" ) ; return ; } public static void main (String s ) { ReturnDemo r = new ReturnDemo () ; } }

Конструкторы, параметризированные аргументами переменной длины

В Java SDK 1.5 появился долгожданный инструмент – аргументы переменной длины для конструкторов и методов(variable-length arguments). До этого переменное количество документов обрабатывалось двумя неудобными способами. Первый из них был рассчитан на то, что максимальное число аргументов ограничено небольшим количеством и заранее известно. В таком случае можно было создавать перегружаемые версии метода, по одной на каждый вариант списка передаваемых в метод аргументов. Второй способ рассчитан на неизвестное заранее и большое количество аргументов. В этом случае аргументы помещались в массив, и этот массив передавался методу. Аргументы переменной длины чаще всего задействованы в последующих манипуляциях с инициализациями переменных. Отсутствие некоторых из ожидаемых аргументов конструктора или метода удобно заменять значениями по умолчанию. Аргумент переменной длины есть массив, и обрабатывается как массив. Например, конструктор для класса Checking с переменным числом аргументов будет выглядеть так: class Checking { public Checking (int . . . n) { } } Символьная комбинация... сообщает компилятору о том, что будет использоваться переменное число аргументов, и что эти аргументы будут храниться в массиве, значение ссылки на который содержится в переменной n. Конструктор может вызываться с разным числом аргументов, включая их полное отсутствие. Аргументы автоматически помещаются в массив и передаются через n. В случае отсутствия аргументов длина массива равна 0. В список параметров наряду с аргументами переменной длины могут быть включены и обязательные параметры. В этом случае параметр, содержащий переменное число аргументов должен обязательно быть последним в списке параметров. Например: class Checking { public Checking (String s, int . . . n) { } } Вполне очевидное ограничение касается количества параметров с переменной длиной. В списке параметров должен быть только один параметр переменной длины. При наличии двух параметров переменной длины компилятору невозможно определить, где заканчивается один параметр и начинается другой. Например: class Checking { public Checking (String s, int . . . n, double . . . d) //ОШИБКА! { } } Файл Checking.java Например, есть аппаратура, способная распознавать номера автомобилей и запоминать номера квадратов местности, где побывал каждый из автомобилей за день. Необходимо из общей массы зафиксированных автомобилей отобрать те, которые в течение дня побывали в двух заданных квадратах, скажем 22 и 15, согласно карте местности. Вполне естественно, что автомобиль может в течение дня побывать во многих квадратах, а может только в одном. Очевидно, что количество посещенных квадратов ограничено физической скоростью автомобиля. Составим небольшую программу, где конструктор класса будет принимать в качестве аргументов номер автомобиля как обязательный параметр и номера посещенных квадратов местности, число которых может быть переменным. Конструктор будет проверять, не появился ли автомобиль в двух квадратах, если появился, то вывести его номер на экран.

Передача параметров в конструктор

В языках программирования существует в основном два вида параметров:

• основные типы (примитивы);
• ссылки на объекты.

Термин вызов по значению (call by value) означает, что конструктор получает значение, переданное ему вызывающим модулем. В противоположность этому, вызов по ссылке (call by reference) означает, что конструктор получает от вызывающего модуля адрес переменной. В языке Java используется только вызов по значению. По значению параметра и по значению ссылки параметра. Java не использует вызов по ссылке для объектов (хотя многие программисты и авторы некоторых книг это утверждают). Параметры при передаче объектов в Java осуществляются не по ссылке , а по значению ссылки на объекты ! В любом случае конструктор получает копии значений всех параметров. Конструктор не может делать со своими входными параметрами:

• конструктор не может менять значения входных параметров основных (примитивных) типов;
• конструктор не может изменять ссылки входных параметров;
• конструктор не может переназначать ссылки входных параметров на новые объекты.

Конструктор может делать со своими входными параметрами:

• изменять состояние объекта, передаваемого в качестве входного параметра.

Следующий пример доказывает, что в Java входные параметры для конструктора передаются по значению ссылки на объект. Так же в этом примере отражено то, что конструктор не может изменять ссылки входных параметров, а фактически изменяет ссылки копий входных параметров. Файл Empoyee.java class Employee { Employee (String x, String y) { String temp = x; x = y; y = temp; } public static void main (String args ) { String name1 = new String ("Alice" ) ; String name2 = new String ("Mary" ) ; Employee a = new Employee (name1, name2) ; System. out. println ("name1=" + name1) ; System. out. println ("name2=" + name2) ; } } Результат вывода программы: name1= Alice name2= Mary Если бы в языке Java для передачи объектов в качестве параметров использовался вызов по ссылке, то конструктор поменял бы в этом примере местами name1 и name2 . На самом деле конструктор не поменяет местами объектные ссылки, хранящиеся в переменных name1 и name2 . Это говорит о том, что параметры конструктора инициализируются копиями этих ссылок. Затем конструктор меняет местами уже копии. По завершении работы конструктора переменные x и y уничтожаются, а исходные переменные name1 и name2 продолжают ссылаться на прежние объекты.

Изменение параметров, передаваемых конструктору.

Конструктор не может модифицировать передаваемые параметры основных типов. Однако, конструктор может модифицировать состояние объекта, передаваемого как параметр. Например, рассмотрим следующую программу: Файл Salary1.java class Salary1 { Salary1 (int x) { x = x * 3 ; System. out. println ("x=" + x) ; } public static void main (String args ) { int value = 1000 ; Salary1 s1 = new Salary1 (value) ; System. out. println ("value=" + value) ; } } Результат вывода программы: x= 3000 value= 1000 Очевидно, что такой способ не изменит параметр основного типа. Поэтому после вызова конструктора значение переменной value остается равным 1000 . По сути, происходит три действия:

1. Переменная x инициализируется копией значения параметра value (т.е. числом 1000).
2. Значение переменной x утраивается – теперь оно равно 3000 . Однако значение переменной value остается равным 1000 .
3. Конструктор завершает свою работу, и переменная x больше не используется.

В следующем примере зарплата сотрудника успешно утраивается, так как в качестве параметра методу передается значение ссылки объекта. Файл Salary2.java class Salary2 { int value = 1000 ; Salary2 () { } Salary2 (Salary2 x) { x. value = x. value * 3 ; } public static void main (String args ) { Salary2 s1 = new Salary2 () ; Salary2 s2 = new Salary2 (s1) ; System. out. println ("s1.value=" + s1. value) ; System. out. println ("s2.value=" + s2. value) ; } } Результат вывода программы: s1. value= 3000 s2. value= 1000 В качестве параметра используется значение ссылки на объект. При выполнении строки Salary2 s2 = new Salary2(s1) ; конструктору Salary2(Salary x) передастся значение ссылки на объект переменной s1 , и конструктор фактически утроит зарплату для s1.value , поскольку даже копия (Salary x) , создаваемая внутри конструктора указывает на объект переменной s1 .

Конструкторы, параметризированные примитивами.

В случае, если в параметрах перегруженного конструктора используется примитив, который может быть сужен (например int <- double), то вызов метода со суженным значением возможен, несмотря на то, что метода, перегруженного с таким параметром нет. Например: Файл Primitive.java class Primitive { Primitive (double d) { d = d + 10 ; System. out. println ("d=" + d) ; } public static void main (String args ) { int i = 20 ; Primitive s1 = new Primitive (i) ; } } Результат вывода программы: d= 30.0 Несмотря на то, что в классе Primitive отсутствует конструктор, у которого есть параметр типа int , отработает конструктор с входным параметром double . Перед вызовом конструктора переменная i будет расширена от типа int до типа double . Обратный вариант, когда переменная i была бы типа double , а конструктор был бы только с параметром int , в данной ситуации привел бы к ошибке компиляции.

Вызов конструктора и оператор new

Конструктор всегда вызывается оператором new . При вызове конструктора оператором new , конструктор всегда формирует ссылку на новый объект. Заставить конструктор сформировать вместо ссылки на новый объект ссылку на уже существующий объект нельзя, кроме подстановки десериализируемого объекта. А с оператором new сформировать вместо ссылки на новый объект ссылку на уже существующий объект нельзя. Например: Файл Salary3.java class Salary3 { int value = 1000 ; Salary3 () { } Salary3 (Salary3 x) { x. value = x. value * 3 ; } public static void main (String args ) { Salary3 s1 = new Salary3 () ; System. out. println ("First object creation: " + s1. value) ; Salary3 s2 = new Salary3 (s1) ; System. out. println ("Second object creation: " + s2. value) ; System. out. println (+ s1. value) ; Salary3 s3 = new Salary3 (s1) ; System. out. println ("Third object creation: " + s3. value) ; System. out. println ("What"s happend with first object?:" + s1. value) ; } } Результат вывода программы: First object creation: 1000 Second object creation: 1000 What"s happend with first object? : 3000 Third object creation: 1000 What"s happend with first object? : 9000 Сначала с помощью строчки Salary3 s1 = new Salary3() ; создается новый объект. Далее, если бы с помощью строки Salary3 s2 = new Salary3(s1) ; или строки Salary3 s3 = new Salary3(s1) ; можно было бы создать ссылку на уже существующий объект, то s1.value s2.value и s3.value хранили бы одинаковое значение 1000 . На самом деле в строке Salary3 s2 = new Salary3(s1) ; создастся новый объект для переменной s2 и изменится состояние объекта для переменной s1 , через передачу своего значения ссылки на объект, в параметре конструктора. В этом можно убедиться по результатам вывода. А при выполнении строки Salary3 s3 = new Salary3(s1) ; создастся НОВЫЙ объект для переменной s3 и снова изменится состояние объекта для переменной s1 .

Конструкторы и блоки инициализации, последовательность действий при вызове конструктора

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

1. Все поля данных инициализируются своими значениями, предусмотренными по умолчанию (0, false или null).
2. Инициализаторы всех полей и блоки инициализации выполняются в порядке их перечисления в объявлении класса.
3. Если в первой строке конструктора вызывается другой конструктор, то выполняется вызванный конструктор.
4. Выполняется тело конструктора.

Конструктор имеет отношение к инициализации, поскольку в Java существует три способа инициализации поля в классе:

• присвоить значение в объявлении;
• присвоить значения в блоке инициализации;
• задать его значение в конструкторе.

Естественно, нужно организовать код инициализации так, чтобы в нем было легко разобраться. В качестве примера приведен следующий класс: class Initialization { int i; short z = 10 ; static int x; static float y; static { x = 2000 ; y = 3.141 ; } Initialization () { System. out. println ("i=" + i) ; System. out. println ("z=" + z) ; z = 20 ; System. out. println ("z=" + z) ; } } В приведенном примере, переменные инициализируются в следующем порядке: сначала инициализируются статические переменные x и y значениями по умолчанию. Далее выполняется статический блок инициализации. Затем производится инициализация переменной i значением по умолчанию и инициализируется переменная z . Далее в работу вступает конструктор. Вызов конструкторов класса не должен зависеть от порядка объявления полей. Это может привести к ошибкам.

Конструкторы и наследование

Конструкторы не наследуются. Например: public class Example { Example () { } public void sayHi () { system. out. println ("Hi" ) ; } } public class SubClass extends Example { } Класс SubClass автоматически наследует метод sayHi() определенный в родительском классе. В тоже время, конструктор Example() родительского класса не наследуется его потомком SubClass .

Ключевое слово this в конструкторах

Конструкторы используют this чтобы сослаться на другой конструктор в этом же классе, но с другим списком параметров. Если конструктор использует ключевое слово this , то оно должно быть в первой строке, игнорирование этого правила приведет к ошибке компилятора. Например: Файл ThisDemo.java public class ThisDemo { String name; ThisDemo (String s) { name = s; System. out. println (name) ; } ThisDemo () { this ("John" ) ; } public static void main (String args ) { ThisDemo td1 = new ThisDemo ("Mary" ) ; ThisDemo td2 = new ThisDemo () ; } } Результат вывода программы: Mary John В данном примере имеется два конструктора. Первый получает строку-аргумент. Второй не получает никаких аргументов, он просто вызывает первый конструктор используя имя "John" по-умолчанию. Таким образом, можно с помощью конструкторов инициализировать значения полей явно и по умолчанию, что часто необходимо в программах.

Ключевое слово super в конструкторах

Конструкторы используют super , чтобы вызвать конструктор суперкласса. Если конструктор использует super , то этот вызов должен быть в первой строке, иначе компилятор выдаст ошибку. Ниже приведен пример: Файл SuperClassDemo.java public class SuperClassDemo { SuperClassDemo () { } } class Child extends SuperClassDemo { Child () { super () ; } } В этом простом примере конструктор Child() содержит вызов super() , который создает экземпляр класса SuperClassDemo , в дополнение к классу Child . Так как super должен быть первым оператором, выполняемым в конструкторе подкласса, этот порядок всегда одинаков и не зависит от того, используется ли super() . Если он не используется, то сначала будет выполнен конструктор по умолчанию (без параметров) каждого суперкласса, начиная с базового класса. Следующая программа демонстрирует, когда выполняются конструкторы. Файл Call.java //Создать суперкласс A class A { A () { System. out. println ("Inside A constructor." ) ; } } //Создать подкласс B, расширяющий класс A class B extends A { B () { System. out. println ("Inside B constructor." ) ; } } //Создать класс (C), расширяющий класс В class C extends B { C () { System. out. println ("Inside C constructor." ) ; } } class Call { public static void main (String args ) { C c = new C () ; } } Вывод этой программы: Inside A constructor. Inside B constructor. Inside C constructor. Конструкторы вызываются в порядке подчиненности классов. В этом есть определенный смысл. Поскольку суперкласс не имеет никакого знания о каком-либо подклассе, то любая инициализация, которую ему нужно выполнить, является отдельной. По возможности она должна предшествовать любой инициализации, выполняемой подклассом. Поэтому-то она и должна выполняться первой.

Настраиваемые конструкторы

Механизм идентификации типа во время выполнения является одним из мощных базовых принципов языка Java, который реализует полиморфизм. Однако такой механизм не страхует разработчика от несовместимого приведения типов в ряде случаев. Самый частый случай – манипулирование группой объектов, различные типы которых заранее неизвестны и определяются во время выполнения. Поскольку ошибки, связанные с несовместимостью типов могут проявиться только на этапе выполнения, то это затрудняет их поиск и ликвидацию. Введение настраиваемых типов в Java 2 5.0 частично отодвигает возникновение подобных ошибок с этапа выполнения на этап компиляции и обеспечивает недостающую типовую безопасность. Отпадает необходимость в явном приведении типов при переходе от типа Object к конкретному типу. Следует иметь ввиду, что средства настройки типов работают только с объектами и не распространяются на примитивные типы данных, которые лежат вне дерева наследования классов. Благодаря настраиваемым типам все приведения выполняются автоматически и скрыто. Это позволяет обезопасить от несоответствия типов и гораздо чаще повторно использовать код. Настраиваемые типы можно использовать в конструкторах. Конструкторы могут быть настраиваемыми, даже если их класс не является настраиваемым типом. Например: class GenConstructor { private double val; < T extends Number > GenConstructor (T arg) { val = arg. doubleValue () ; } void printValue () { System. out. println ("val: " + val) ; } } class GenConstructorDemo { public static void main (String args ) { GenConstructor gc1 = new GenConstructor (100 ) ; GenConstructor gc2 = new GenConstructor (123.5F ) ; gc1. printValue () ; gc2. printValue () ; } } Поскольку конструктор GenConstructor задает параметр настраиваемого типа, который должен быть производным классом от класса Number , его можно вызвать с любы

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

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

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

What is Constructor in Java?

A constructor is a special method that is used to initialize a newly created object and is called just after the memory is allocated for the object. It can be used to initialize the objects to desired values or default values at the time of object creation. It is not mandatory for the coder to write a constructor for a class.

If no user-defined constructor is provided for a class, compiler initializes member variables to its default values.

• numeric data types are set to 0
• char data types are set to null character(‘\0’)
• reference variables are set to null

In this tutorial, you will learn-

Rules for creating a Java Constructor

1. It has the same name as the class
2. It should not return a value not even void

Example 1 : Create your First Constructor Java

Step 1) Type following code in your editor.

Class Demo{ int value1; int value2; Demo(){ value1 = 10; value2 = 20; System.out.println("Inside Constructor"); } public void display(){ System.out.println("Value1 === "+value1); System.out.println("Value2 === "+value2); } public static void main(String args){ Demo d1 = new Demo(); d1.display(); } }

Step 2) Save , Run & Compile the code. Observe the output.

Inside Constructor Value1 === 10 Value2 === 20

Constructor Overloading

Constructor overloading is a technique in Java in which a class can have any number of constructors that differ in parameter list. The compiler differentiates these constructors by taking into account the number of parameters in the list and their type.

Examples of valid constructors for class Account are

Account(int a); Account (int a,int b); Account (String a,int b);

Example 2 : To understand Constructor Overloading

Step 1) Type the code in the editor.

Class Demo{ int value1; int value2; /*Demo(){ value1 = 10; value2 = 20; System.out.println("Inside 1st Constructor"); }*/ Demo(int a){ value1 = a; System.out.println("Inside 2nd Constructor"); } Demo(int a,int b){ value1 = a; value2 = b; System.out.println("Inside 3rd Constructor"); } public void display(){ System.out.println("Value1 === "+value1); System.out.println("Value2 === "+value2); } public static void main(String args){ Demo d1 = new Demo(); Demo d2 = new Demo(30); Demo d3 = new Demo(30,40); d1.display(); d2.display(); d3.display(); } }

Step 2) Save, Compile & Run the Code.

Step 3) Error = ?. Try and debug the error before proceeding to next step.

Step 4) Every class has a default Constructor. Default Constructor for class Demo is Demo() . In case you do not provide this constructor the compiler creates it for you and initializes the variables to default values. You may choose to override this default constructor and initialize variables to your desired values as shown in Example 1.

But if you specify a parametrized constructor like Demo(int a), and want to use the default constructor Demo(), it is mandatory for you to specify it.

In other words, in case your Constructor is overridden, and you want to use the default constructor, its need to be specified.

Step 5) Uncomment line # 4-8. Save, Compile & Run the code.

Constructor Chaining

Consider a scenario where a base class is extended by a child. Whenever an object of the child class is created, the constructor of the parent class is invoked first. This is called Constructor chaining.

Example 3: To understand constructor chaining

Step 1) Copy the following code into the editor.

Class Demo{ int value1; int value2; Demo(){ value1 = 1; value2 = 2; System.out.println("Inside 1st Parent Constructor"); } Demo(int a){ value1 = a; System.out.println("Inside 2nd Parent Constructor"); } public void display(){ System.out.println("Value1 === "+value1); System.out.println("Value2 === "+value2); } public static void main(String args){ DemoChild d1 = new DemoChild(); d1.display(); } } class DemoChild extends Demo{ int value3; int value4; DemoChild(){ //super(5); value3 = 3; value4 = 4; System.out.println("Inside the Constructor of Child"); } public void display(){ System.out.println("Value1 === "+value1); System.out.println("Value2 === "+value2); System.out.println("Value1 === "+value3); System.out.println("Value2 === "+value4); } }

Step 2) Run the Code. Owing to constructor chaining, when the object of child class DemoChild is created, constructor Demo() of the parent class is invoked first and later constructor DemoChild() of the child is created. Expected Output =

Inside 1st Parent Constructor Inside the Constructor of Child Value1 === 1 Value2 === 2 Value1 === 3 Value2 === 4

Step 3) You may observe the constructor of the parent class Demo is overridden. What if you want to call the overridden constructor Demo(int a) instead of the default constructor Demo() when your child object is created?

In such cases, you can use the keyword "super" to call overridden constructors of the parent class.

Syntax:-

Super(); --or-- super(parameter list);

Example: If your constructor is like Demo(String Name,int a) you will specify super("Java",5) If used, the keyword super needs to be the first line of code in the constructor of the child class.

Step 4) Uncomment Line # 26 and run the code. Observe the Output.

Inside 2nd Parent Constructor Inside the Constructor of Child Value1 === 5 Value2 === 0 Value1 === 3 Value2 === 4

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

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

/* пример # 2: перегрузка конструктора: Quest .java */

package chapt03;

public class Quest {

private int id;

private String text;

// конструктор без параметров (по умолчанию)

public Quest() {

super ();/* если класс будет объявлен без конструктора, то

компилятор предоставит его именно в таком виде*/

// конструктор с параметрами

public Quest(int idc, String txt) {

super ();/ *вызов конструктора суперкласса явным образом

необязателен, компилятор вставит его автоматически*/

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

Quest a = new Quest (); //инициализация полей значениями по умолчанию

Quest b = new Quest (71, "Сколько бит занимает boolean ?");

Оператор new вызывает конструктор, поэтому в круглых скобках могут стоять аргументы, передаваемые конструктору.

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

super (параметры);

В следующем примере объявлен класс Point c двумя полями (атрибутами), конструктором и методами для инициализации и извлечения значений атрибутов.

/* пример # 3: вычисление расстояния между точками: Point .java: Loca te Logic .java: Runner .java */

package chapt03;

public class Point {

/* объект инициализируется при создании и не изменяется */

private final double x;

private final double y;

public Point(final double xx, final double yy) {

super ();

public double getX() {

return x;

public double getY() {

return y;

package chapt03;

public class LocateLogic {

public double calculateDistance(

Point t1, Point t2) {

/* вычисление расстояния */

double dx = t1.getX() – t2.getX();

double dy = t1.getY() – t2.getY();

return Math.hypot (dx, dy);

package chapt03;

public class Runner {

public static void main(String args) {

// локальные переменные не являются членами класса

Point t1 = new Point(5, 10);

Point t2 = new Point(2, 6);

System.out .print("расстояние равно: "

+ new LocateLogic().calculateDistance(t1, t2));

В результате будет выведено:

расстояние равно: 5.0

Конструктор объявляется со спецификатором public , чтобы была возможность вызывать его при создании объекта в любом пакете приложения. Спецификатор private не позволяет создавать объекты вне класса, а спецификатор «по умолчанию» – вне пакета. Спецификатор protected позволяет создавать объекты в текущем пакете и для подклассов в других пакетах.

1. Понятие конструктора по умолчанию

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

В наиболее общем случае, для класса ClassName , конструктор по умолчанию имеет следующий вид:

class ClassName { ... // объявление конструктора ClassName() { // тело конструктора // ... } ... }

2. В каких случаях конструктор по умолчанию генерируется в классе автоматически а в каких нет? Пример

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

Например. В следующем объявлении класса конструктор по умолчанию генерируется автоматически

class CMyClass { int d ; int GetD() { return d ; } void SetD(int nd) { d = nd; } }

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

// работает, так как в классе больше не реализовано ни одного конструктора CMyClass mc = new CMyClass();

Если в тело класса CMyClass добавить хотя бы один другой конструктор (например, конструктор с одним параметром), то конструктор по умолчанию автоматически генерироваться не будет

class CMyClass { int d ; // конструктор по умолчанию уже не генерируется автоматически CMyClass(int nd) { d = nd; } int GetD() { return d ; } void Set(int nd) { d = nd; } }

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

// ошибка компиляции, так как в классе уже объявлен другой конструктор // CMyClass mc = new CMyClass(); CMyClass mc2 = new CMyClass(7); // а этот код работает

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

The constructor CMyClass() is undefined

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

class CMyClass { int d ; // явное объявление конструктора по умолчанию CMyClass() { d = 0; } // объявление конструктора с 1 параметром, CMyClass(int nd) { d = nd; } int GetD() { return d ; } void Set(int nd) { d = nd; } }

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

CMyClass mc = new CMyClass(); // вызывается конструктор по умолчанию mc.d = 25; CMyClass mc2 = new CMyClass(5); // вызывается конструктор с 1 параметром

3. Вызов конструкторов из других конструкторов. Пример

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

Пример. В примере демонстрируется использование класса CPixel , который реализует пиксел на экране монитора.

// Класс, который реализует пиксел на экране монитора public class CPixel { // внутренние переменные класса private int x , y ; // координаты пиксела private int color ; // цвет пиксела // конструктор без параметров (конструктор по умолчанию) CPixel() { x = y = color = 0; } // конструктор с 2 параметрами, которые инициализируют только координаты CPixel(int _x, int _y) { x = _x; y = _y; color = 0; } // конструктор с 1 параметром, который инициализирует только цвет CPixel(int _color) { color = _color; x = y = 0; } // конструктор с 3 параметрами, который вызывает конструктор с 2 параметрами CPixel (int _x, int _y, int _color) { // вызов конструктора с 2 параметрами: обязательно первая операция и только один раз this (_x, _y); //this(_color); // повторный вызов конструктора запрещен this .color = _color; // так можно } // методы доступа int GetX() { return x ; } int GetY() { return y ; } int GetColor() { return color ; } }

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

CPixel cp1 = new CPixel(2,8); // вызов конструктора с 2 параметрами CPixel cp2 = new CPixel(3,5,8); // вызов конструктора, который вызовет другой конструктор int d; d = cp1.GetX(); // d = 2 d = cp2.GetColor(); // d = 8 d = cp2.GetY(); // d = 5 ...

4. Какие ограничения (требования) накладываются на вызов других конструкторов из конструктора класса?

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

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