What is use of constructor in object oriented programming?

Answer 1

A constructor creates an Object of the class that it is in by initializing all the instance variables and creating a place in memory to hold the Object. It is always used with the keyword new and then the Class name. For instance, new String(); constructs a new String object. Sometimes in a few classes you may have to initialize a few of the variables to values apart from their predefined data type specific values. If java initializes variables it would default them to their variable type specific values. For example you may want to initialize an integer variable to 10 or 20 based on a certain condition, when your class is created. In such a case you cannot hard code the value during variable declaration. such kind of code can be placed inside the constructor so that the initialization would happen when the class is instantiated.

Answer 2

A constructor, in object oriented programming concept is a method which has the same name of the class where it is defined. It will be called when an object is created for that class. The job of the constructor is the initialization of the members of the class.

Answer 3

A constructor is a special class method that is invoked whenever an object of the class is instantiated. The constructor is used to initialise the object such that when construction is complete, a valid object exists. Constructors cannot be called directly since they are not functions (they have no return value, not even void), however constructors can accept arguments in the same way functions can. Constructors are invoked, rather than called.

Answer 4

A constructor is a special class member that is invoked every time an object is instantiated from a class. Constructors are specifically used to initialise the non-static data members of the class and to establish the class invariant.

A class may define as many constructors as required, however "ordinary" classes will define at least three constructors:

class X {

public:

X (int value=0): data {value} {} // default constructor

X (const X& other): data {other.data} {} // copy constructor

X (X&&): data {std::move {other.data} {} // move constructor

private:

int data;

// ...

};

Note that constructors differ from functions in that there is no return value (not even void) and they include a comma-separated list of list of member initialisers between the argument list and the constructor body. In most cases, the constructor body is empty, but we can use the body to perform additional initialisations that cannot easily be performed via member initialisers. For efficiency, we perform as much initialisation as possible before entering the constructor body.

A default constructor is a constructor that accepts no arguments or where all arguments have default values. Default constructors are useful for objects that have a natural default value or state. For instance, a container object will typically default to an empty container, a string object to an empty string and a numeric object to zero.

A copy constructor is a constructor that accepts an existing object of the same class and constructs a logical copy of that object. Given that the existing object's members will not be changed by making a copy, the argument is declared const. Copy constructors are invoked automatically whenever we pass an object to a function by value.

A move constructor is a constructor that accepts a modifiable rvalue. Unlike copy constructors, move constructors take ownership of the argument's resources and leave the moved-from object in an unspecified but valid state, the assumption being that the moved-from object will subsequently be destroyed. Move constructors are invoked automatically when returning an object by value.

Constructors are always invoked at the point an object of the class is declared (the point of instantiation). Unlike C where all variables are, by convention, explicitly declared at the top of the function, objects should only be instantiated when we have a suitable value to assign to them. The difference is best explained by example:

X x; // default constructed

// ...

x = 42; // assumes X::operator= (int) is defined

This is known as two-stage initialisation. Ideally, we would re-order the statements as follows:

// ...

X x {42};

This is more efficient. The more complex the object, the more efficient it becomes.

Answer 5

Every class, including abstract classes, MUST have a constructor. Hard Code that into your brain. But just because a class must have one, doesn't mean the programmer has to type it. A constructor looks like this:

class Car {

Car() { } // The constructor for the Car class

}

You notice anything missing in the declaration above? There's no return type! Two key points to remember about constructors are that they have no return type and their names must exactly match the class name. Typically, constructors are used to initialize instance variable state, as follows:

class Car {

int size;

String name;

Car(String name, int size) {

this.name = name;

this.size = size;

}

}

In the preceding code example, the Car class does not have a no-arg constructor. That means the following will fail to compile:

Car f = new Car(); // Won't compile, no matching constructor

but the following will compile:

Car f = new Car("Ford", 43); // No problem. Arguments match

// the Car constructor.

So it's very common for a class to have a no-arg constructor, regardless of how many other overloaded constructors are in the class (constructors can be overloaded just like methods). You can't always make that work for your classes; occasionally you have a class where it makes no sense to create an instance without supplying information to the constructor. A java.awt.Color object, for example, can't be created by calling a no-arg constructor, because that would be like saying to the JVM, "Make me a new Color object, and I really don't care what color it is...." Do you seriously want the JVM making your color choices?

Answer 6

It is a method called when the runtime constructs an instance of a Java class. You can either create your own constructor (or constructors, if you want to allow for parameterized construction) or, if you don't need any customized construction, you can use the default no-argument constructor which is inserted automatically thanks to the implicit extension of the Object-class.

Answer 7

Constructor is usually the first piece of code in a class that gets executed when you try to instantiate a class. As its name suggests, it constructs the object for the class.

In Java, objects are constructed. Every time you make a new object, at least one constructor is invoked. Every class has a constructor, although if you don't create one explicitly, the compiler will build one for you.

Ex:

class Test {

public Test() { } // this is Test's constructor

}

Answer 8

initialises the object and allocate memory space

Answer 9

It is the way to create the instances of class. in java. to know how constructor works first you should be clear with the concept of class.