Java Tutorial
.
Constructors in Java are blocks of code that can be seen whenever an instance of a class is created. In function, constructors are similar to methods, but there are two key differences. Unlike methods, constructors in Java do not have a return type, and it carries the same name as the class.
In programming, a constructor can be used to create an instance of a class. The function of a constructor is to return the object to a class; thus, it does not have a return type. Constructors are a type of special method that is used to initialize the object in a class.
There are two main types of constructors in Java: parameterized and default constructors. A default constructor in Java is the constructor implemented by Java if a constructor is not explicitly defined.
This tutorial will discuss the default constructor in Java with examples.
In Java, programmers are not always required to implement a constructor in class codes. But if we don’t, the compiler will automatically create and implement a constructor. This is the default constructor in Java, and it has no parameters.
There are a few ways to identify a default constructor. Firstly, default constructors have no arguments in them. Their only function is initializing objects and returning them to the calling codes. The online Java compiler only creates a default constructor if the programmer does not provide any constructors in the entire program.
Another important detail to remember is that no-arg or no-argument constructors are also very similar to default constructors because none have arguments in them. However, a no-arg constructor is built by a programmer, while the default constructor in Java is not.
public class Car {
private String brand;
private String color;
// Default constructor
public Car() {
brand = "Unknown";
color = "Unspecified";
}
public String getBrand() {
return brand;
}
public String getColor() {
return color;
}
public static void main(String[] args) {
// Create an instance of Car using the default constructor
Car car = new Car();
// Access and print the brand and color
System.out.println("Brand: " + car.getBrand());
System.out.println("Color: " + car.getColor());
}
}In this example, the Car class has a default constructor defined with no parameters. Inside the constructor, the brand variable is set to "Unknown" and the color variable to "Unspecified". When a new Car object is created using the new Car() statement in the main method, the default constructor is invoked, and the brand and color variables are initialized with the default values.
The main method then accesses the brand and color variables using the appropriate getter methods and prints their values.
So what exactly is the purpose of a default constructor? It is important to provide a constructor while defining a class. However, if a programmer chooses not to do that, then Java provides a no-argument constructor on their behalf. As we mentioned before, the constructor's name always matches the class, making it easier to understand and identify.
If a programmer forgets to add a constructor in object-oriented programming, Java provides a default constructor. It only assigns the default values while initializing the objects. It provides:
An integer with a value of 0
Double variables and floats with 0.0
Boolean with false
Null for string
Any integer variable is assigned with the value of 0 by a default constructor. That is why, if you run a code with the aforementioned values, your output will always be 0.
When creating constructors in Java, there are certain rules and guidelines that we need to follow. Here are the rules for creating Java constructors:
Constructor Name: The constructor name must be the same as the class name. It should be written in PascalCase, starting with an uppercase letter.
No Return Type: Constructors do not have a return type, not even void. They are responsible for initializing the object and cannot be used to return a value.
Access Modifiers: Constructors can have different access modifiers such as public, private, protected, or no modifier (package-private). The choice of access modifier depends on the desired visibility of the constructor.
Parameter List: Constructors can have parameters, allowing you to pass values during object creation. The parameter list is optional, and you can have multiple constructors with different parameter lists (constructor overloading).
Overloading: You can create multiple constructors with different parameter lists in a class. This is known as constructor overloading and allows for different ways of creating objects with varying initializations.
Default Constructor: The compiler automatically generates a default constructor with no parameters if you don't provide any constructors in your class. However, if you define at least one constructor, the default constructor is not created unless you explicitly define it.
Chaining Constructors (Constructor Overloading): Constructors can call other constructors within the same class using this keyword. This allows for constructor chaining and helps to reuse code.
Initialization: Constructors are responsible for initializing the object's state and assigning values to instance variables. You can perform any necessary initialization tasks inside the constructor.
Inheritance: Constructors are not inherited by subclasses. However, the subclass constructor can call the superclass constructor using the super keyword to initialize the inherited members.
Exception Handling: Constructors can throw exceptions, just like any other method. You can use throws clause to specify the exceptions the constructor might throw.
There are three types of constructors in Java:
Default Constructor: The compiler automatically generates a default constructor if no constructor is explicitly defined in a class. It has no parameters and initializes the object with default values.
Syntax:
Parameterized Constructor: A parameterized constructor is defined with one or more parameters. It allows you to pass values during object creation and initialize the object's state accordingly. This constructor provides flexibility in setting initial values based on the provided arguments.
Syntax:
Copy Constructor: A copy constructor in Java creates a new object by copying the values from an existing object of the same class. It is helpful when you want to create a duplicate or clone of an object. The copy constructor takes an object of the same class as a parameter and initializes the new object's state by copying the values from the passed object.
Syntax:
public class Person {
private String name;
private int age;
// Parameterized constructor
public Person(String name, int age) {
this.name = name;
this.age = age;
}
// Getters and setters
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public static void main(String[] args) {
// Create Person objects using the parameterized constructor
Person person1 = new Person("Aritra Bandyopadhyay", 26);
System.out.println(person1.getName()); // Output: Aritra Bandyopadhyay
System.out.println(person1.getAge()); // Output: 26
Person person2 = new Person("Manisha Pal", 27);
System.out.println(person2.getName()); // Output: Manisha Pal
System.out.println(person2.getAge()); // Output: 27
}
}
In the above example, the Person class has a parameterized constructor that takes two parameters: name of type String and age of type int. Inside the constructor, the values of these parameters are assigned to the corresponding instance variables this.name and this.age. With this parameterized constructor, you can create Person objects by providing values for name and age during object creation.
Constructor overloading in Java allows a class to have multiple constructors with different parameter lists. Each constructor can initialize the object differently, providing flexibility and convenience when creating objects.
public class Rectangle {
private int length;
private int width;
// Default constructor
public Rectangle() {
length = 0;
width = 0;
}
// Constructor with length and width parameters
public Rectangle(int length, int width) {
this.length = length;
this.width = width;
}
// Constructor with only length parameter (assuming square)
public Rectangle(int length) {
this.length = length;
this.width = length;
}
// Getters and setters
public int getLength() {
return length;
}
public void setLength(int length) {
this.length = length;
}
public int getWidth() {
return width;
}
public void setWidth(int width) {
this.width = width;
}
public static void main(String[] args) {
// Create objects using different constructors
Rectangle rectangle1 = new Rectangle(); // Default constructor
Rectangle rectangle2 = new Rectangle(5, 10); // Constructor with length and width
Rectangle rectangle3 = new Rectangle(7); // Constructor with only length (square)
// Print the dimensions of the rectangles
System.out.println("Rectangle 1: Length = " + rectangle1.getLength() + ", Width = " + rectangle1.getWidth());
System.out.println("Rectangle 2: Length = " + rectangle2.getLength() + ", Width = " + rectangle2.getWidth());
System.out.println("Rectangle 3: Length = " + rectangle3.getLength() + ", Width = " + rectangle3.getWidth());
}
}In the main method, we create three Rectangle objects using different constructors and print their dimensions for this program.
(Car.java file)
Code for Car.java file:
public class Car {
private String brand;
private String model;
private int year;
// Copy constructor
public Car(Car other) {
this.brand = other.brand;
this.model = other.model;
this.year = other.year;
}
// Constructor
public Car(String brand, String model, int year) {
this.brand = brand;
this.model = model;
this.year = year;
}
// Getters and setters
public String getBrand() {
return brand;
}
public void setBrand(String brand) {
this.brand = brand;
}
public String getModel() {
return model;
}
public void setModel(String model) {
this.model = model;
}
public int getYear() {
return year;
}
public void setYear(int year) {
this.year = year;
}
@Override
public String toString() {
return "Car [brand=" + brand + ", model=" + model + ", year=" + year + "]";
}
}
Code for Main.java file:
public class Main {
public static void main(String[] args) {
Car car1 = new Car("Toyota", "Camry", 2022);
// Create a new car object using the copy constructor
Car car2 = new Car(car1);
// Modify the brand of car2
car2.setBrand("Honda");
// Print the details of both cars
System.out.println(car1); // Output: Car [brand=Toyota, model=Camry, year=2022]
System.out.println(car2); // Output: Car [brand=Honda, model=Camry, year=2022]
}
}
In the above example, we have a Car class with three instance variables: brand, model, and year. The class has two constructors - a parameterized constructor and a copy constructor.The copy constructor takes an object of the same class (Car) as a parameter and initializes the new object with the values of the passed object. This ensures that the new object is a separate copy with its own memory space.
We then create car1 using the parameterized constructor and car2 using the copy constructor, passing car1 as the argument. Modifying the brand of car2 does not affect car1, as they are separate objects with their own memory space.
Constructors are very important when it comes to object-oriented programming. Not only does a constructor help initialize an object when it’s being created, but it also sets the values of the data members of an object.
A constructor is usually created by the programmer while writing the code, but if the programmer skips it or forgets it, Java adds a default constructor. The default constructor in Java initializes the object by assigning a default value to an object before initializing it.
1. What is parameterized constructor in Java?
When a programmer creates a constructor in Java with a few specific parameters and arguments, it is known as parameterized constructor. Unlike a default constructor, a parameterized constructor assigns different values to different objects in a class before initializing it.
2 Why are constructors used in Java?
Initializing instance variables of classes is the main job of constructors in Java. It also informs us about the dependencies in a class.
3. What is constructor overloading in Java?
If a programmer uses more than one constructor with different parameters, it is called a constructor overload. It can help all of the different constructors perform different tasks. But always remember to put different signatures to these different overloaded constructors.
Leave a Reply
Your email address will not be published. Required fields are marked *