I recently started programming in Java again. When in uni I learned what a constructor was but have to admit I never really understood it. Can anybody explain what a constructor is(in simple terms) and tell me how to know when to use one.

http://en.wikipedia.org/wiki/Constru...ter_science%29

Anytime you want to create a new instance of your class (an object) the constructor will be automaticaly called to initialize the variables used or to allocate some memory. It's basicaly a prototype for classes.

I never took computer science, perhaps thats not technicaly correct, but thats the jist of it.. There's a good definition on that url, but heres a better example from a tutorial I have:

// example: class constructor
#include <iostream>
using namespace std;

class CRectangle {
int width, height;
public:
CRectangle (int,int);
int area () {return (width*height);}
};

CRectangle::CRectangle (int a, int b) {
width = a;
height = b;
}

int main () {
CRectangle rect (3,4);
CRectangle rectb (5,6);
cout << "rect area: " << rect.area() << endl;
cout << "rectb area: " << rectb.area() << endl;
return 0;
}

CRectangle::CRectangle is the constructor there...

DrStoney hit it right on. the only thing i would change is to say is that the constructor is not "automatically" called, you have to explicitly call a constructor to create an instance. just like was showed in the example, you call the two int constructor and it creates a rect of given size.

A good way to think of "an object," in any language, is that it is a chunk of memory which has procedural code magically associated with it. That is, conceptually, how such things are implemented.

So, when we want our language to "create an object," what it actually does is to carve out a new block of memory, set up the magical pointers and stuff which allows that block of memory to "be an object," and then ... well, the object might have various needs of its own for setting things to initial values, initializing other objects that it might need, and so on. So, that's what a "constructor" does. It's an initialization routine. After allocating the memory and doing the magic, each of the constructors are run.

Likewise, when an object is being destroyed, "what the object might have initialized in its constructor, now needs to be dismantled." That's what a "destructor" is for: it's a termination or cleanup routine. So, if (for example) the constructor allocated a few other objects that it needed, then its destructor should dispose of those things. Once the destructor(s) associated with an object have finished executing, the object itself goes away.

Hmm... ok I'll bite.. so when your using an object, you are "constructing" it? I said automaticaly because I figure passing the variables to the object is done with out creating the Classname::Classname bit again... The terminology of this stuff is harder then doing it! Heh

The whole point of constructors is that you cannot use the object until you have successfully constructed it.

The comp sci terminology is "invariant":http://en.wikipedia.org/wiki/Class_(computer_science)

PS:
Although this is most common way you'll see a constructor invoked:it's entirely possible to have a constructor ... and invoke it ... *without* making it look like a function:

> it's entirely possible to have a constructor ... and invoke it ... *without* making it look like a function:

yeh i guess what i said up above could be taken either way. its probably a perception thing, my comment was probably more confusing than helpful.

in my mind though this
is explicitly calling the no arg constructor.. but i guess it could be said to be implicitly calling it as well..

That's true in C++, but not in Java.

very true... i also had forgotten which language we were talking about.

in that case i once again agree with my first post.. ive got to stop arguing with myself like this..