Explain the concepts of constructor and destructor Do you have to declare a constructor every time you create a class?

Answer 1

we cover constructors and destructors for C++ objects. Constructors give a means to initializing newly created objects and can be overloaded. Destructors offer a way to perform clean up on an object just before it is destroyed; a class can have at most one destructor. Together constructors and destructors provide a method of encapsulating the lifespan of an object. Although we have not done anything useful with destructors so far, we will see that they are extremely useful as our programs get more complex.

In mathematics, an ordered list numbers is called a sequence. Sequences come in many types, but we can model a generic sequence with a class. Sequences can be of any length, but we will put a limit of 100 terms on our sequences for this first example:

The code above describes a sequence class with two constructors, a member function, and two data members. The first constructor is a default constructor, which creates a sequence with no terms in it. The second constructor takes an array of terms and a length; the terms are copied from the array to the sequence via a for-loop. The member function outputs the length of the sequence and then all of the terms-a check is made internally to assure that sequence has at least one term before outputting them. The data members are the length and an array of doubles to hold the terms.

In this main function, we create two instances of our sequence object and call Print() to output the sequences to the console window.

Answer 2

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 3

A constructor is used to build a new instance of a class. This is done to ensure that your newly created class has all of its data properly initialized to specific values. Java automatically initializes most values to 0 or null automatically, but if your class would like a different default value, then a constructor is the ideal place for this logic. You can also use constructors to open socket connections, database files, initialize event handlers, or almost any other conceivable action (although, you should take care not to call functions that might expose your class to other instances as a side effect before the constructor completes).

If you do not provide any constructors in your class, it is automatically given a "default constructor". This is basically a function that calls the parent's default constructor, if it extends an object, then initializes all member variables to false, null, or zero, depending on the type of data. If you do provide a constructor, then only the provided constructors can be used, and the default constructor will simply disappear. So, if you wish to provide any constructors, you must normally provide a default constructor as well.

Java does not have destructors. You cannot guarantee when your object will cease to live, and therefore you cannot capture the moment of its death. In other languages, a destructor is called when an object goes out of scope and therefore "dies", or when it is explicitly destroyed. Java's garbage collector does not do this, and so it does not permit destructors. However, there is a "finalize" function you may override from Object that does a similar function, but it is not guaranteed to be called (unlike a destructor), nor will it be called at the moment of death, but sometime thereafter.