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

Kotlin | Конструкторы

Последнее обновление: 26.05.2021

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

Классы в Kotlin могут иметь один первичный конструктор (primary constructor) и один или несколько вторичных конструкторов (secondary constructor).

Первичный конструктор

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

class Person constructor(_name: String){
   
}

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

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

Если первичный конструктор не имеет никаких аннотаций или модификаторов доступа, как в данном случае, то ключевое слово constructor можно опустить:

class Person(_name: String){
   
}

Инициализатор

Что делать с полученными через конструктор данными? Мы их можем использовать для инициализации свойств класса. Для этого применяются блоки инициализаторов:

class Person(_name: String){
    val name: String
    init{
        name = _name
    }
}

В классе Person определено свойство name, которое хранит имя человека. Чтобы передать эту свойству значение параметра _name из первичного конструктора, применяется блок инициализатора. Блок инициализатора определяется после ключевого слова init.

Цель инициализатора состоит в инициализации объекта при его создании.

Стоит отметить, что здесь свойству name не задается начальное значение, потому это свойство в любом случае будет инициализировано в блоке инициализатора, и при создании объекта оно в любом случае получит значение.

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

fun main() {
    val tom = Person("Tom")
    val bob = Person("Bob")
    val alice = Person("Alice")
	
    println(tom.name)   // Tom
    println(bob.name)   // Bob
    println(alice.name) // Alice
}

class Person(_name: String){
    val name: String
    init{
        name = _name
    }
}

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

Стоит отметить, что в классе может быть определено одновременно несколько блоков инициализатора.

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

class Person(_name: String){
	
    val name: String = _name
}

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

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

fun main() {

    val bob: Person = Person("Bob", 23)

    println("Name: ${bob.name}  Age: ${bob.age}")
}

class Person(val name: String, var age: Int){

}

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

Person("Bob", 23)

Вторичные конструкторы

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

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

class Person(_name: String){
    val name: String = _name
    var age: Int = 0
	
    constructor(_name: String, _age: Int) : this(_name){
        age = _age
    }
}

Здесь в классе Person определен первичный конструктор, который принимает значение для установки свойства name:

class Person(_name: String)

И также добавлен вторичный конструктор. Он принимает два параметра: _name и _age. С помощью ключевого слова this вызывается первичный конструктор, поэтому через этот вызов необходимо передать значения для параметров первичного конструктора. В частности, в первичный конструктор передается значение параметра _name. В самом вторичном конструкторе устанавливается значение свойства age.

constructor(_name: String, _age: Int) : this(_name){
	age = _age
}

Таким образом, при вызове вторичного конструктора вначале вызывается первичный конструктор, срабатывает блок инициализатора, который устанавливает свойство name. Затем выполняются собственно действия вторичного конструктора, который устанавливает свойство age.

Используем данную модификацию класса Person:

fun main() {

    val tom: Person = Person("Tom")
    val bob: Person = Person("Bob", 45)
    
    println("Name: ${tom.name}  Age: ${tom.age}")
    println("Name: ${bob.name}  Age: ${bob.age}")
}

class Person(_name: String){
    val name: String = _name
    var age: Int = 0
	
    constructor(_name: String, _age: Int) : this(_name){
        age = _age
    }
}

В функции main создаются два объекта Person. Для создания объекта tom применяется первичный конструктор, который принимает один параметр. Для создания объекта bob применяется вторичный конструктор с двумя параметрами.

Консольный вывод программы:

Name: Tom  Age: 0
Name: Bob  Age: 45

При необходимости мы можем определять и больше вторичных конструкторов:

fun main() {

    val tom = Person("Tom")
    val bob = Person("Bob", 41)
    val sam = Person("Sam", 32, "JetBtains")

    println("Name: ${tom.name}  Age: ${tom.age}  Company: ${tom.company}")
    println("Name: ${bob.name}  Age: ${bob.age}  Company: ${bob.company}")
    println("Name: ${sam.name}  Age: ${sam.age}  Company: ${sam.company}")
}

class Person(_name: String){
    val name = _name
    var age: Int = 0
    var company: String = "Undefined"

    constructor(_name: String, _age: Int) : this(_name){
        age = _age
    }

    constructor(_name: String, _age: Int, _comp: String) : this(_name, _age){
         company = _comp
    }
}

Здесь в класс Person добавлено новое свойство — company, которое описывает компании, в которой работает человек. И также добавлен еще один конструктор, который принимает три параметра:

constructor(_name: String, _age: Int, _comp: String) : this(_name, _age){
	company = _comp
}

Чтобы не дублировать код установки свойств name и age, этот вторичный конструктор передает установку этих свойств другому вторичному конструктору, который принимает два параметра, через вызов this(_name, _age). То есть данный вызов по сути будет вызывать первый вторичный конструктор с двумя параметрами.

Консольный вывод программы:

Name: Tom  Age: 0  Company: Undefined
Name: Bob  Age: 41  Company: Undefined
Name: Sam  Age: 32  Company: JetBtains

НазадСодержаниеВперед

Зачем нужен конструктор по умолчанию Java?

Прочее › Java › Может ли конструктор быть private Java

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

1. Для чего нужен конструктор по умолчанию?
2. Чем отличается конструктор по умолчанию?
3. Для чего нужен конструктор?
4. Зачем нужен конструктор в программировании?
5. Какие конструкторы создаются по умолчанию?
6. Как выглядит конструктор по умолчанию?
7. Что делает деструктор по умолчанию?
8. Для чего нужен конструктор рабочих программ?
9. Зачем нужен конструктор рабочих программ?
10. Для чего полезен конструктор?
11. Что такое конструктор в Java простыми словами?
12. Чем отличаются конструкторы по умолчанию копирования и конструктор с параметрами?
13. Что развивает конструктор?
14. Что должен делать конструктор?
15. В каком случае компилятор сам создает конструктор по умолчанию?
16. Что возвращает конструктор в Java?
17. Когда нужен конструктор копирования?
18. Для чего нужен деструктор?
19. Зачем нужен конструктор и деструктор?
20. Для чего нужен виртуальный конструктор?

Для чего нужен конструктор по умолчанию?

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

Чем отличается конструктор по умолчанию?

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

Для чего нужен конструктор?

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

Зачем нужен конструктор в программировании?

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

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

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

Как выглядит конструктор по умолчанию?

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

В наиболее общем случае, для класса ClassName, конструктор по умолчанию имеет следующий вид: class ClassName { // объявление конструктора ClassName() { // тело конструктора // } }

Что делает деструктор по умолчанию?

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

Для чего нужен конструктор рабочих программ?

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

Зачем нужен конструктор рабочих программ?

«Конструктор рабочих программ» — программа, которая помогает сделать рабочую программу коррекционным специалистам при работе с дошкольниками. С Конструктором вы сэкономите много времени: программу, которую вы обычно делаете целый день или дольше, в Конструкторе можно сделать за 2-3 часа.

Для чего полезен конструктор?

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

Что такое конструктор в Java простыми словами?

Конструктор — это специальный метод, который имеет имя, совпадающее с именем класса, и вызывается при создании экземпляра объекта совместно с оператором new. Результатом работы этого метода всегда является экземпляр класса. Следовательно, конструктор класса Cat называется Cat().

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

Чем отличаются конструкторы по умолчанию, копирования и конструктор с параметрами? Конструктор по умолчанию не принимает никаких параметров. Конструктор копирования принимает в качестве параметра объект класса. Конструктор с параметрами принимает на вход параметры (обычно необходимые для инициализации полей класса).

Что развивает конструктор?

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

Что должен делать конструктор?

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

В каком случае компилятор сам создает конструктор по умолчанию?

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

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

Что возвращает конструктор в Java?

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

Когда нужен конструктор копирования?

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

Для чего нужен деструктор?

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

Зачем нужен конструктор и деструктор?

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

Для чего нужен виртуальный конструктор?

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

Почему конструктор по умолчанию или без аргументов важен в классе Java? Ответ

Уведомление: Эта статья может содержать партнерские ссылки. Когда вы покупаете, мы можем заработать небольшую комиссию.

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

он делает это только тогда, когда вы не предоставляете никакого другого конструктора . Это означает, что это становится ответственностью разработчиков , чтобы добавить конструктор без аргументов, если он добавляет явный конструктор. Теперь . Почему важно предоставить конструктор по умолчанию в Java . Что произойдет, если в вашем классе нет конструктора без аргументов? Вот как об этом спрашивают во многих интервью по Java, чаще всего в рамках интервью по Spring и Hibernate.

Не обязательно определять конструктор по умолчанию, но если вы пишете постоянный класс Hibernate, объекты JPA или используете среду Spring для управления созданием объектов и связыванием зависимостей, вам нужно быть немного осторожным. Многие платформы с открытым исходным кодом используют отражение для создания экземпляра или объекта во время выполнения на основе имени класса.

Например, когда Hibernate создает экземпляр сущностей с помощью отражения, он использует метод Class.newInstance(), для которого требуется конструктор без аргументов для создания экземпляра. Фактически он эквивалентен новой Entity().

Этот метод выдает InstantiationException, если он не нашел конструктора без аргументов в классе Entity, поэтому рекомендуется предоставить конструктор без аргументов.

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

Кстати, не только Hibernate использует Reflection для создания экземпляра класса. Если вы знакомы с Spring и внедрением зависимостей, вы, возможно, знаете, что Spring также создает экземпляр класса с использованием отражения, но он более сложный и позволяет вам выбирать, какой конструктор вызывать, указывая различные аргументы конструктора, используя значение  и  теги.

Как насчет этого кода, как вы думаете, он будет работать, если класс Order не имеет конструктора без аргументов?

<бин >

name=»symbolValidator» ref=»someSymbolValidator» />

Нет, это не сработает, если ваш класс OrderManager имеет явный конструктор, потому что приведенная выше конфигурация создаст экземпляр OrderManager, вызвав конструктор без аргументов , а затем применив Setter Injection для предоставленной зависимости. Если вы определили свой класс, как показано ниже, вам лучше использовать внедрение конструктора для создания экземпляра этого компонента.

общедоступный класс OrderManager {

private SymbolValidator symbolValidator;

public OrderManager (валидатор SymbolValidator){

символ Валидатор = валидатор;

…..

Приведенная выше конфигурация покажет следующую ошибку:

Исключение в потоке «основной» org.springframework.beans.factory.BeanCreationException : Ошибка при создании компонента с именем «OrderManager», определенным в ресурсе пути к классу [app-config.xml]: создание экземпляра компонента не удалось; вложенным исключением является org.springframework.beans.BeanInstantiationException: Не удалось создать экземпляр класса bean [com. exchange.OrderManager]: Конструктор по умолчанию не найден ;

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

Тем не менее, в случае постоянных классов или сущностей Hibernate необходимо предоставить конструктор без аргументов, чтобы Hibernate мог создавать экземпляры классов Persistence, когда вы загружаете их из базы данных в спящем режиме. Он также использует метод newInstance() для создания экземпляров постоянных классов.

Новое сообщение Старый пост Дом

Подписаться на: Опубликовать комментарии ( Атом )

Явный конструктор без аргументов против.

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

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

Сохраните свое место

Нравится (5)

Твитнуть

Делиться

22.12К просмотров

Большинство разработчиков, плохо знакомых с Java, быстро узнают, что «конструктор по умолчанию» — это неявно созданный (с помощью javac) для их классов Java, когда они не указывают хотя бы один явный конструктор . В разделе 8.8.9 Спецификации языка Java кратко говорится: «Если класс не содержит объявлений конструктора, конструктор по умолчанию объявляется неявно». В этом разделе далее описываются характеристики неявно созданного конструктора по умолчанию, в том числе без параметров, без выдает предложение и вызывает конструктор своего суперкласса, который также не принимает аргументов. Разработчик Java может выбрать явную реализацию конструктора без аргументов, аналогичного конструктору по умолчанию (например, не принимающего аргументов и не имеющего предложения ). В этом посте я рассмотрю некоторые причины, по которым разработчик может решить реализовать явный конструктор без аргументов вместо того, чтобы полагаться на неявный конструктор по умолчанию .

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

Препятствие созданию экземпляра класса . Это ненужный шаг, если у класса есть другие явные конструкторы (которые принимают параметры), потому что наличие любого явного конструктора предотвратит создание неявного конструктора по умолчанию. Однако, если нет другого явного конструктора (например, в «утилитарном» классе со всеми статические методы), неявный конструктор по умолчанию можно исключить, реализуя явный конструктор без аргументов с закрытым доступом. Раздел 8.8.10 Спецификации языка Java описывает использование всех частных явных конструкторов для предотвращения создания экземпляра класса.

Принудительное создание экземпляра класса с помощью конструктора или статической фабрики инициализации

Еще одна причина явно реализовать закрытый конструктор без аргументов — принудительное создание экземпляра объекта этого класса с помощью статических методов фабрики инициализации или конструкторов вместо конструкторов. В первых двух пунктах «Эффективной Java» (третье издание) описываются преимущества использования статических фабричных методов инициализации и конструкторов по сравнению с прямым использованием конструкторов.

Требуется несколько конструкторов, включая конструктор без аргументов

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

Создание объекта документа с помощью Javadoc

Еще одна причина для явной реализации конструктора без аргументов вместо того, чтобы полагаться на неявно созданный конструктор по умолчанию, заключается в выражении комментариев Javadoc к конструктору. Это заявленное обоснование для JDK-8224174 («java. lang.Number имеет конструктор по умолчанию»), который теперь является частью JDK 13, а также выражен в неразрешенном в настоящее время JDK-8071961 («Добавить предупреждение javac lint, когда конструктор по умолчанию созданный»). Недавно написанный CSR JDK-8224232 («java.lang.Number имеет конструктор по умолчанию») уточняет этот момент: «Конструкторы по умолчанию не подходят для хорошо документированных API».

Предпочтение явной спецификации неявной

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

Замена конструкторов по умолчанию явными конструкторами без аргументов в JDK

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

• JDK-8071959 («java.lang.Object использует неявный конструктор по умолчанию»), который был рассмотрен в JDK 9, заменил «конструктор по умолчанию» java.lang.Object явным конструктором без аргументов. Чтение «Описания» этой проблемы заставило меня улыбнуться: «При пересмотре некоторой документации по java.lang.Object (JDK-8071434) было отмечено, что класс * не * имеет явный конструктор и вместо этого полагался на javac для создания неявный конструктор по умолчанию. Как неловко!»
• JDK-8177153 («LambdaMetafactory имеет конструктор по умолчанию»), который был рассмотрен в JDK 9, заменил неявный конструктор по умолчанию явным (и private ) конструктором без аргументов.
• JDK-8224174 («java.lang.Number имеет конструктор по умолчанию»), запланированный для JDK 13, заменит неявный конструктор по умолчанию java.lang.Number явным конструктором без аргументов.

Потенциальное предупреждение javac lint относительно конструкторов по умолчанию

Вполне возможно, что однажды javac будет иметь доступное предупреждение lint, указывающее на классы с конструкторами по умолчанию. JDK-8071961 («Добавить предупреждение javac lint при создании конструктора по умолчанию»), который в настоящее время не предназначен для какой-либо конкретной версии JDK, гласит: «Раздел 8.8.9 JLS документирует, что если класс не объявляет хотя бы один конструктор, компилятор будет генерировать конструктор по умолчанию.Хотя эта политика может быть удобной, для формальных классов это плохая практика программирования, хотя бы по той причине, что конструктор по умолчанию не будет иметь javadoc.Использование конструктора по умолчанию может быть разумным предупреждение javac lint.»

Заключение

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

Java (язык программирования)

Опубликовано в DZone с разрешения Дастина Маркса, DZone MVB. Смотрите оригинальную статью здесь.