Constructors in Java

by

In Java, a constructor is a special method that is invoked when an object of a class is created. It is used to initialize the object’s instance variables and perform any other necessary setup operations.

Here are some key things to know about constructors in Java:

  1. A constructor has the same name as the class and no return type.
  2. If you don’t explicitly define a constructor for a class, Java provides a default constructor with no arguments that simply initializes all instance variables to their default values.
  3. You can define multiple constructors for a class, as long as they have different parameter lists (i.e. different numbers or types of parameters).
  4. A constructor can call another constructor in the same class using the this() keyword. This is known as constructor chaining.
  5. If a constructor doesn’t explicitly call another constructor using this(), it will automatically call the no-argument constructor of the superclass using super().
  6. Constructors can be used to set the values of instance variables, call other methods, or perform any other necessary initialization tasks.

Here is an example of a constructor in Java:

public class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // getters and setters omitted for brevity
}

In this example, the Person class has a constructor that takes two arguments: a name of type String and an age of type int. The constructor initializes the instance variables name and age with the values passed as arguments.

Rules for creating Java constructor:

To create a Java constructor, you need to follow these rules:

  1. A constructor must have the same name as the class it belongs to.
  2. A constructor does not have a return type, not even void.
  3. A constructor can be overloaded, which means you can create multiple constructors with different parameter lists.
  4. If you do not explicitly create a constructor in a class, Java creates a default constructor with no arguments. However, if you create any constructor, Java does not create the default constructor.
  5. A constructor can have access modifiers such as public, private, or protected.
  6. A constructor can use the this keyword to call another constructor in the same class, which is known as constructor chaining.
  7. A constructor can use the super keyword to call the constructor of the superclass.
  8. A constructor can initialize the instance variables of the class, call other methods, or perform any other necessary initialization tasks.

Here is an example of a Java class with multiple constructors:

public class Person {
    private String name;
    private int age;

    // Constructor with two arguments
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // Constructor with one argument
    public Person(String name) {
        this(name, 0); // calling the constructor with two arguments using 'this' keyword
    }

    // Default constructor
    public Person() {
        this("Unknown", 0); // calling the constructor with two arguments using 'this' keyword
    }

    // Getter and setter methods
    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;
    }
}

In this example, the Person class has three constructors: one with two arguments, one with one argument, and a default constructor with no arguments. The first constructor initializes the name and age instance variables with the values passed as arguments, the second constructor sets the name instance variable to the value passed as an argument and the age instance variable to 0, and the default constructor sets both name and age instance variables to default values.

Types of Java constructors:

There are three types of constructors in Java:

  1. Default constructor
  2. Parameterized constructor
  3. Copy constructor

Let’s discuss each of these constructors in detail.

  1. Default constructor: A default constructor is a constructor that takes no parameters. If you don’t define any constructor in your class, Java will provide a default constructor that takes no parameters. The default constructor initializes all instance variables to their default values, which is null for reference types, 0 for numeric types, and false for boolean types.

Here’s an example of a default constructor:

public class Person {
    private String name;
    private int age;
    
    public Person() {
        // default constructor
    }
}
  1. Parameterized constructor: A parameterized constructor is a constructor that takes one or more parameters. It is used to initialize the instance variables of a class with the values passed as arguments.

Here’s an example of a parameterized constructor:

public class Person {
    private String name;
    private int age;
    
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
  1. Copy constructor: A copy constructor is a constructor that takes an object of the same class as an argument and creates a new object with the same values as the original object. It is used to create a new object with the same state as an existing object.

Here’s an example of a copy constructor:

public class Person {
    private String name;
    private int age;
    
    public Person(Person person) {
        this.name = person.name;
        this.age = person.age;
    }
}

In this example, the copy constructor takes an object of the Person class as an argument and initializes the new Person object with the same name and age values as the original Person object.

Java Default Constructor:

A default constructor in Java is a constructor that takes no arguments. If a class does not have any constructor, Java automatically provides a default constructor for it. The default constructor initializes all instance variables to their default values, which is null for reference types, 0 for numeric types, and false for boolean types.

Here’s an example of a default constructor in Java:

public class Person {
    private String name;
    private int age;

    // Default constructor
    public Person() {
        // Initializing instance variables to default values
        name = null;
        age = 0;
    }
}

In this example, the Person class has a default constructor that initializes the name instance variable to null and the age instance variable to 0. Since we did not define any other constructor, Java will automatically provide this default constructor.

It’s important to note that if a class has any constructor defined (whether it’s a default or a parameterized constructor), Java will not automatically provide a default constructor. So, if you define a constructor with parameters, and you still want to provide a default constructor, you will need to define it explicitly in your class.

Example of default constructor:

Here’s an example of a default constructor in Java:

public class Person {
    private String name;
    private int age;

    // Default constructor
    public Person() {
        // Initializing instance variables to default values
        name = null;
        age = 0;
    }
    
    // Getter and setter methods
    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;
    }
}

In this example, the Person class has a default constructor that initializes the name instance variable to null and the age instance variable to 0. We can create objects of this class using the default constructor as follows:

Person person = new Person();

When we create an object of the Person class using the default constructor, the name and age instance variables will be initialized to their default values. We can then set the values of these variables using the setter methods, like this:

person.setName("John");
person.setAge(30);

We can retrieve the values of these variables using the getter methods, like this:

System.out.println("Name: " + person.getName());
System.out.println("Age: " + person.getAge());

Output:

Name: John
Age: 30

Example of default constructor that displays the default values:

Here’s an example of a default constructor in Java that displays the default values of the instance variables:

public class Person {
    private String name;
    private int age;

    // Default constructor
    public Person() {
        // Initializing instance variables to default values
        name = null;
        age = 0;
        
        // Displaying default values
        System.out.println("Default name: " + name);
        System.out.println("Default age: " + age);
    }
    
    // Getter and setter methods
    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;
    }
}

In this example, the Person class has a default constructor that initializes the name instance variable to null and the age instance variable to 0. In addition to that, the default constructor also displays the default values of the instance variables using System.out.println() statements.

We can create an object of this class using the default constructor as follows:

Person person = new Person();

When we create an object of the Person class using the default constructor, the name and age instance variables will be initialized to their default values, and the default constructor will display these values in the console.

Output:

Default name: null
Default age: 0

Java Parameterized Constructor:

A parameterized constructor in Java is a constructor that takes one or more parameters. It allows you to create objects of a class with specific values for the instance variables, instead of relying on the default values.

Here’s an example of a parameterized constructor in Java:

public class Person {
    private String name;
    private int age;

    // Parameterized constructor
    public Person(String name, int age) {
        // Initializing instance variables to parameter values
        this.name = name;
        this.age = age;
    }
    
    // Getter and setter methods
    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;
    }
}

In this example, the Person class has a parameterized constructor that takes two parameters, name and age. The constructor initializes the name instance variable to the value of the name parameter, and the age instance variable to the value of the age parameter.

We can create objects of this class using the parameterized constructor as follows:

Person person = new Person("John", 30);

When we create an object of the Person class using the parameterized constructor, the name and age instance variables will be initialized to the values passed as arguments to the constructor. We can then retrieve these values using the getter methods, like this:

System.out.println("Name: " + person.getName());
System.out.println("Age: " + person.getAge());

Output:

Name: John
Age: 30

Example of parameterized constructor:

Here’s an example of a parameterized constructor in Java:

public class Book {
    private String title;
    private String author;
    private int year;

    // Parameterized constructor
    public Book(String title, String author, int year) {
        // Initializing instance variables to parameter values
        this.title = title;
        this.author = author;
        this.year = year;
    }
    
    // Getter and setter methods
    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    public int getYear() {
        return year;
    }

    public void setYear(int year) {
        this.year = year;
    }
}

In this example, the Book class has a parameterized constructor that takes three parameters, title, author, and year. The constructor initializes the title instance variable to the value of the title parameter, the author instance variable to the value of the author parameter, and the year instance variable to the value of the year parameter.

We can create objects of this class using the parameterized constructor as follows:

Book book = new Book("The Great Gatsby", "F. Scott Fitzgerald", 1925);

When we create an object of the Book class using the parameterized constructor, the title, author, and year instance variables will be initialized to the values passed as arguments to the constructor. We can then retrieve these values using the getter methods, like this:

System.out.println("Title: " + book.getTitle());
System.out.println("Author: " + book.getAuthor());
System.out.println("Year: " + book.getYear());

Output:

Title: The Great Gatsby
Author: F. Scott Fitzgerald
Year: 1925

Constructor Overloading in Java:

Constructor overloading in Java allows us to create multiple constructors in a class with the same name but different parameters. It enables us to create objects with different initializations without having to write multiple classes.

To overload constructors in Java, we can create multiple constructors with different parameter lists. For example, consider the following code:

public class Person {
    private String name;
    private int age;

    // Default constructor
    public Person() {
        this.name = "Unknown";
        this.age = 0;
    }

    // Parameterized constructor with one parameter
    public Person(String name) {
        this.name = name;
        this.age = 0;
    }

    // Parameterized constructor with two parameters
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    // Getter and setter methods
    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;
    }
}

In this example, we have three constructors:

  1. The default constructor with no parameters, which initializes the name instance variable to “Unknown” and the age instance variable to 0.
  2. The parameterized constructor with one parameter, which initializes the name instance variable to the value of the name parameter and the age instance variable to 0.
  3. The parameterized constructor with two parameters, which initializes the name instance variable to the value of the name parameter and the age instance variable to the value of the age parameter.

We can create objects of this class using any of the constructors, as shown in the following code:

Person person1 = new Person(); // default constructor
Person person2 = new Person("John"); // parameterized constructor with one parameter
Person person3 = new Person("Mary", 30); // parameterized constructor with two parameters

In the first case, person1 is initialized using the default constructor. In the second case, person2 is initialized using the parameterized constructor with one parameter. And in the third case, person3 is initialized using the parameterized constructor with two parameters.

We can then retrieve the values of the instance variables using the getter methods, like this:

System.out.println("Name: " + person1.getName() + ", Age: " + person1.getAge());
System.out.println("Name: " + person2.getName() + ", Age: " + person2.getAge());
System.out.println("Name: " + person3.getName() + ", Age: " + person3.getAge());

Output:

Name: Unknown, Age: 0
Name: John, Age: 0
Name: Mary, Age: 30

Example of Constructor Overloading:

Here’s an example of constructor overloading in Java:

public class Rectangle {
    private int length;
    private int breadth;

    // Default constructor
    public Rectangle() {
        this.length = 0;
        this.breadth = 0;
    }

    // Parameterized constructor with one parameter
    public Rectangle(int side) {
        this.length = side;
        this.breadth = side;
    }

    // Parameterized constructor with two parameters
    public Rectangle(int length, int breadth) {
        this.length = length;
        this.breadth = breadth;
    }
    
    // Getter and setter methods
    public int getLength() {
        return length;
    }

    public void setLength(int length) {
        this.length = length;
    }

    public int getBreadth() {
        return breadth;
    }

    public void setBreadth(int breadth) {
        this.breadth = breadth;
    }

    // Method to calculate area of rectangle
    public int area() {
        return length * breadth;
    }
}

In this example, we have three constructors:

  1. The default constructor with no parameters, which initializes the length and breadth instance variables to 0.
  2. The parameterized constructor with one parameter, which initializes the length and breadth instance variables to the value of the side parameter. This constructor is used to create a square.
  3. The parameterized constructor with two parameters, which initializes the length instance variable to the value of the length parameter and the breadth instance variable to the value of the breadth parameter. This constructor is used to create a rectangle.

We can create objects of this class using any of the constructors, as shown in the following code:

Rectangle square = new Rectangle(5); // parameterized constructor with one parameter
Rectangle rectangle = new Rectangle(3, 4); // parameterized constructor with two parameters
Rectangle defaultRectangle = new Rectangle(); // default constructor

In the first case, square is initialized using the parameterized constructor with one parameter, which creates a square with sides of length 5. In the second case, rectangle is initialized using the parameterized constructor with two parameters, which creates a rectangle with length 3 and breadth 4. And in the third case, defaultRectangle is initialized using the default constructor, which creates a rectangle with length and breadth 0.

We can then calculate the areas of these rectangles using the area() method, like this:

System.out.println("Area of square: " + square.area());
System.out.println("Area of rectangle: " + rectangle.area());
System.out.println("Area of default rectangle: " + defaultRectangle.area());

Output:

Area of square: 25
Area of rectangle: 12
Area of default rectangle: 0

Difference between constructor and method in Java:

In Java, constructors and methods are both used to define behavior of a class, but they serve different purposes and have some key differences:

  1. Naming: Constructors have the same name as the class, while methods can have any valid identifier as their name.
  2. Return type: Constructors don’t have a return type (not even void), while methods must have a return type or be declared as void.
  3. Invocation: Constructors are invoked automatically when an object of the class is created, while methods must be explicitly called by name.
  4. Parameters: Constructors can have parameters or no parameters, while methods can have zero or more parameters.
  5. Purpose: Constructors are used to initialize the instance variables of the class and set up the initial state of the object, while methods are used to define behavior or actions that can be performed on the object.
  6. Accessibility: Constructors can have any access modifier (public, protected, private, or default), while methods can also have any access modifier, but they can additionally be marked as static or abstract.

In summary, constructors are used to initialize the state of an object, while methods define the behavior of an object. Constructors are automatically invoked when an object is created, while methods must be called explicitly.

Java Copy Constructor:

In Java, a copy constructor is a special constructor used to create a new object that is a copy of an existing object of the same class. The copy constructor takes an object of the same class as a parameter and initializes the new object’s instance variables with the values of the corresponding instance variables in the original object.

Here’s an example of a copy constructor for a Person class:

public class Person {
    private String name;
    private int age;

    // Constructor
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // Copy constructor
    public Person(Person other) {
        this.name = other.name;
        this.age = other.age;
    }

    // Getter and setter methods
    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;
    }
}

In this example, the Person class has a regular constructor that takes a name and age parameter and initializes the instance variables with those values. The class also has a copy constructor that takes a Person object as a parameter and initializes the new Person object with the values of the corresponding instance variables in the original object.

We can use the copy constructor to create a new Person object that is a copy of an existing Person object, like this:

Person john = new Person("John", 25);
Person johnCopy = new Person(john);

In this code, we create a new Person object called john with the name “John” and age 25. We then create a new Person object called johnCopy using the copy constructor and pass in the john object as a parameter. The johnCopy object is now a copy of the john object, with the same name and age.

One important thing to note is that the copy constructor creates a shallow copy of the original object, meaning that any reference variables in the original object will be copied as references to the same objects in the new object. If you want to create a deep copy of the object, where all of the referenced objects are also copied, you’ll need to implement a more complex copy constructor or use a cloning mechanism.

Copying values without constructor:

In Java, you can copy values from one object to another without using a constructor by using setters and getters or by using a copy method.

Here’s an example of copying values from one Person object to another without using a constructor:

public class Person {
    private String name;
    private int age;

    // Constructor
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // Getter and setter methods
    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;
    }

    // Copy method
    public void copyValues(Person other) {
        this.name = other.name;
        this.age = other.age;
    }
}

In this example, we have a Person class with a constructor, getters and setters for name and age, and a copyValues() method that takes a Person object as a parameter and copies its name and age values to the current object.

We can use the copyValues() method to copy values from one Person object to another, like this:

Person john = new Person("John", 25);
Person johnCopy = new Person("", 0);
johnCopy.copyValues(john);

In this code, we create a new Person object called john with the name “John” and age 25. We then create a new Person object called johnCopy with an empty name and age 0, and use the copyValues() method to copy the values from the john object to the johnCopy object. The johnCopy object now has the same name and age as the john object.

Copying values using setters and getters works in a similar way, where you call the getters on the original object to get the values, and then call the setters on the new object to set the values. However, this approach can be more verbose and error-prone, especially if you have a lot of instance variables to copy.