# Constructor
## 👷♂️ What is a Constructor?
A **constructor** in Java is a special method that is used to initialize objects. The constructor is called when an object of a class is instantiated.
> It runs automatically whenever we create a new Person object using the new keyword.
>
> Inside the constructor we can put code to set initial values for object attributes. For example:
>
> public Person(String name) {
>
> this.name = name;\
> }
>
> Now when we do:
>
> Person p = new Person("Adam");
>
> The constructor assigns "Adam" to the name attribute.
For example:
```java
public class Person {
// Constructor
public Person() {
// Initialization code goes here
}
}
```
The constructor always has the same name as the class and no return type.
## 🏗️ Rules for Constructors in Java 🏗️
Constructors are special methods used to initialize objects in Java. There are some important rules around defining and using constructors.
### 🏠 Rules for Default Constructors 🏠
A default constructor has the following rules:
* It has the same name as the class
* It has no parameters
* It is generated automatically if no constructors are defined
* The default constructor initializes all member variables to default values
For example:
```java
public class Person {
private String name;
// Default constructor generated automatically
public Person() {
name = "";
}
}
```
The default constructor sets `name` to an empty string.
### 🛠️ Rules for Parameterized Constructors 🛠️
Some rules for parameterized constructors are:
* Can have any number of parameters, with any types
* Must have the same name as the class
* Are defined by the programmer
* Initialize fields using values passed as parameters
For example:
```java
public class Person {
private String name;
// Parameterized constructor
public Person(String name) {
this.name = name;
}
}
```
This constructor initializes the `name` field using a passed parameter.
So following the rules for default and parameterized constructors allows proper initialization of objects in Java.
## 🔨 Key Notes
* A constructor is a special method with the class name
* It is called automatically when an object is created
* It is used to initialize the object's state
* If no constructor is defined, Java provides a default one
So constructors allow objects to be initialized right after instantiation.
## 🛠️ In Simple Terms
The constructor is the initialization method of a class which sets up the new object when it is created. It runs automatically when a new object is made to get the object ready for use.
So in Java, constructors setup new objects!
## Two Types of Constructors 🏗
Constructors initialize an object when it is created. They have the same name as the class and differs by the parameter list.
There are two types of constructors in Java:
### **Default Constructor 🏗️**
* Created automatically if no constructor is defined
* Has no parameters
* Can be defined explicitly
```java
class Person {
String name;
Person() {
// Default constructor
}
}
Person p = new Person();
```
### **Parameterized Constructor ⚙️**
* Created by the programmer
* Has parameters to initialize the object
```java
class Person {
String name;
Person(String name) {
this.name = name;
}
}
Person p = new Person("John");
```
Here `name` parameter is used to initialize the `name` field.
**this** keyword refers to the current object.
## Constructor Chaining ⛓
When one constructor calls another, it is known as constructor chaining. This allows reusing code and improving maintainability.
```java
class Person {
String name;
int age;
Person() {
this("John Doe"); // Invoking another constructor
}
Person(String name) {
this(name, 0);
}
Person(String name, int age) {
this.name = name;
this.age = age;
}
}
```
Here `this()` is used to invoke another constructor of the same class.
The constructor chain finally invokes the most specific constructor which initializes all fields.
---
# Agent Instructions: Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter:
```
GET https://qatesting.gitbook.io/qa/java/oops/constructor.md?ask=
```
The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
