Question 1

Question 1What is a constructor? Why do you need a constructor?

Accepted Answer

A constructor is a member method of a class that is used to initialise the instance variables. It has the same name as that of its defining class and does not have a return type.A constructor is needed as it instructs the computer to perform the start-up tasks of a new object. These can be like assigning default values to instance variables, aligning all the buttons on a screen when a new window object is created, or moving the cursor to a specific data entry field for the user input.

Question 2

Question 2If the constructor is automatically generated by the compiler, why do you need to define your own constructor?

Accepted Answer

A default constructor does not have any statement inside it. It initializes default values to the instance variables.If we define our own constructor in a class, we can initialise the instance variables according to our requirements. A parameterised constructor allows the programmer to initialise objects with different values. This is achieved by passing the required values as arguments to the constructor method.

Question 3

Question 3Explain the statement, "you cannot invoke constructors as normal method calls".

Accepted Answer

A constructor cannot be explicitly invoked like a method. It is automatically invoked via the new operator at the time of object creation. On the other hand, a method can be called directly by an object that has already been created. Normal method calls are specified by the programmer.The below program highlights the difference in the way the constructor is invoked versus a normal method call:class Test  {
    int a, b;
    public Test(int x, int y)   {
        a = x;
        b = y;
    }
    void add()  {
        System.out.println(a + b);
    }
}

class invokeConst   {
    public static void main(String args[])  {
        Test obj1 = new Test(10, 20);   // constructor invoked
        obj1.add();    // calling add() method
    }
}

Question 4

Question 4Describe the importance of parameterised constructors.

Accepted Answer

Parameterized constructors are important because they provide a way to initialize objects with different values. For example, if we have a class representing a bank account, we could use a parameterized constructor to initialize a bank account with a specific balance, rather than always starting with a balance of zero. This makes the class more flexible and reusable, as it can be used to create objects with a variety of different initial states.

Question 5

Question 5Write a class specifier (along with its constructor) that creates a class student having two private data members : rollno and grade and two public functions init( ) and display( ).(Do not write full definitions of member functions except for constructor).

Accepted Answer

class student
{
    private int rollno;
    private char grade;

public student()    {
        rollno = 0;
        grade = '\0';
    }

public student(int roll, char g)
    {
        rollno = roll;
        grade = g;
    }

public void init()  {}
    
    public void display()   {}
}

Question 6

Question 6Explain the concept of constructor overloading with an example.

Accepted Answer

The process of creating more than one constructor with the same name but with different parameter declarations is called constructor overloading.The below example shows constructor overloading being used to create a class having three constructors:public class Rectangle
{
    int length;
    int width;

//Constructor without any parameters
    public Rectangle()   {
        System.out.println("Invoking constructor with no parameters"); 
        length = 20;
        width = 15;
    }

// Constructor with one parameter
    public Rectangle(int len)   {
        System.out.println("Invoking constructor with one parameter"); 
        length = len;
        width = 20;
    }

// Constructor with two parameters
    public Rectangle(int  len, int  wd)    {
        System.out.println("Invoking constructor with two parameters"); 
        length = len;
        width = wd;
    }

public void Area()    {
        int area = length * width;
        System.out.println("Length = " + length);
        System.out.println("Width = " + width);
        System.out.println("Area = " + area);
    }

public static void main(String args[])  {
        Rectangle rect1 = new Rectangle();
        rect1.Area();

Rectangle rect2 = new Rectangle(30);
        rect2.Area();

Rectangle rect3 = new Rectangle(30, 10);
        rect3.Area();
    }
}

Question 7

Question 7What is the use of the keyword this?

Accepted Answer

Within a constructor or a method, this is a reference to the current object — the object whose constructor or method is being invoked. The keyword this stores the address of the currently-calling object.For example, the below program makes use of the this keyword to resolve the conflict between method parameters and instance variables.class  Area
{
    int  length,  breadth;

public Area(int length, int breadth) {
        this.length = length;
        this.breadth =  breadth;
    }
    
    public void Display() {
    int	area = length * breadth;
    System.out.println("Area is " + area);
    }

public static void main(String args[J) {
    Area area = new Area(2, 3);
    area.Display();
    }
}

Question 8

Question 8Define a constructor function for a Date class that initializes the Date objects with given initial values. In case initial values are not provided, it should initialize the object with default values.

Accepted Answer

public Date()
{
    day = 1;
    month = 1;
    year = 1970;
}
public Date(int d, int m, int y)
{
    day = d;
    month = m;
    year = y;
}

Question 9

Question 9What condition(s) a function must specify in order to create objects of a class ?

Accepted Answer

Every time an object is created, the constructor is automatically invoked. If the function creating the object, does not have access privilege for the constructor, it cannot be invoked for that function. Thus, the object cannot be created by such function.Therefore, it is essential for a function to have access privilege for the constructor in order to create objects of a class.

Question 10

Question 10Constructor functions obey the usual access rules. What does this statement mean ?

Accepted Answer

Constructor functions obey the usual access rules. It means that a private or protected constructor is not available to the non-member functions.With a private or protected constructor, one cannot create an object of the same class in a non-member function. Only the member functions of that class can create an object of the same class and invoke the constructor.

Question 11

Question 11How are parameterized constructors different from non-parameterized constructors?

Accepted Answer

Parameterised constructorNon-parameterised constructorParameterised constructor receives parameters and uses them to initialise the object's member variables.Non-parameterised constructor does not accept parameters and initialises the object's member variables with default values.Parameterised constructors need to be explicitly defined for the class. They are never created automatically by the compiler.Non-parameterised constructors are considered default constructors. If no constructor is explicitly defined, then the compiler automatically creates a non-parameterized constructor.For example,Test(int x, int y){a = x;b = y;}For example,Test(){a = 10;b = 5;}

Question 12

Question 12What are benefits/drawbacks of temporary instances ?

Accepted Answer

The benefit of temporary instances is that they live in the memory as long as they are being used or referenced in an expression and after this, they are deleted by the compiler. The memory is freed as soon as they are deleted rather than staying in the memory till the program completes execution.The drawback of temporary instances is that they are anonymous i.e., they do not bear a name. Thus, they cannot be reused in a program.

Question 13

Question 13How do we invoke a constructor ?

Accepted Answer

A constructor is invoked automatically when an object of a class is created. The constructor is called using the new keyword followed by the name of the class and a set of parentheses. If the constructor requires arguments, the arguments are passed inside the parentheses.For example, suppose we have a class named Person with a parameterized constructor that takes two arguments name and age. To create an object of this class and invoke the constructor, we would use the following code:Person personObj = new Person("John", 30);

Question 14

Question 14How can objects be initialized with desired values at the time of object creation ?

Accepted Answer

Objects can be initialized with desired values at the time of object creation by using parameterized constructor and passing the desired values as arguments at the time of creation of object.

Question 15

Question 15When a compiler can automatically generate a constructor if it is not defined then why is it considered that writing constructors for a class is a good practice ?

Accepted Answer

Writing constructors for a class is considered a good practice for the following reasons:Control over object creation — By writing our own constructors, we can control how objects of our class are created and initialised. It ensures initialising member variables to specific values and executing certain initialisation logic before the object is used.Parameter validation — We can prevent runtime errors and bugs by validating input parameters and ensuring only valid objects are created.Flexibility — Multiple constructors allows users of the class to create objects in different ways, depending on their needs. This makes the class more flexible and easier to use.

Question 16

Question 16'Accessibility of a constructor greatly affects the scope and visibility of their class.' Elaborate this statement.

Accepted Answer

Every time an object is created, it is automatically initialised by the constructor of the class. Therefore, it is very much necessary for the constructor of a class to be accessible by the function in which the object is created. If the constructor of a class is declared 'private' or 'protected', then the scope and visibility of the constructor (and the class) is defined by the rules of the access specifier.In such a case, a function not having access to constructor of a class cannot declare and use objects of that class. Hence, accessibility of a constructor greatly affects the scope and visibility of their class.

Question 17

Question 17List some of the special properties of the constructor functions.

Accepted Answer

Some of the special properties of the constructor functions are as follows:It has the same name as that of its class.It doesn't have any return type, not even void.It adheres to the rules of access specifiers.It can be parameterized or non-parameterized.It is used to create and initialize objects from a class.It can be overloaded to provide multiple ways of creating objects with different initialisation parametersIt is always called implicitly when an object is created using the new keyword.

Question 18

Question 18What is a parameterized constructor ? How is it useful ?

Accepted Answer

Parameterized constructors are the constructors that receive parameters and initialize objects with received values. For example:class XYZ
{
    private int i; 
    private float j;

XYZ(int a, float b)     //parameterized constructor
    {	
        i = a ;
        j = b;
    }
    :
    //other  members
    :
}Parameterized constructors are useful in the following ways:Control over object creation — By writing our own constructors, we can control how objects of our class are created and initialised. It ensures initialising member variables to specific values and executing certain initialisation logic before the object is used.Parameter validation — We can prevent runtime errors and bugs by validating input parameters and ensuring only valid objects are created.

Question 19

Question 19Design a class to represent a bank account. Include the following members:Data membersName of the depositorAccount numberType of accountBalance amount in the accountMethodsTo assign initial valuesTo deposit an amountTo withdraw an amount after checking balanceTo display the name and balanceDo write proper constructor functions

Accepted Answer

class BankAccount
{
    private String name; 
    private long accno;
    private char type;
    private double bal;

BankAccount()   {
        name = "";
        accno = 0;
        type = '\0';
        bal = 0.0d;
    }
    BankAccount(String n, long accnumber, char t, double b)   {
        name = n;
        accno = accnumber;
        type = t;
        bal = b;
    }

public void deposit(double amt)   {
        bal = bal + amt;
        System.out.println("Amount deposited: Rs. " + amt);
        System.out.println("Balance: Rs. " + bal);
    }

public void withdraw(double amt)    {
        if(amt <= bal)  {
            bal = bal - amt;
            System.out.println("Amount withdrawn: Rs. " + amt);
            System.out.println("Balance: Rs. " + bal);
        }
        else {
            System.out.println("Insufficient Balance");
        }
    }
    
    public void display()
    {
        System.out.println("Name: " + name);
        System.out.println("Balance: Rs. " + bal);
    }
}

Constructors