What is a java constructor and write a program?

Answer 1

Constructors have the same name as the class itself and they do not specify a return type, not even void because they return the instance of the class itself.

Because constructors have the same name as the class then they allow method overloading and also save memory and execution time of program.

Program release memory of constructors function after using this function and it reduce program complexity.

Answer 2

A constructor is a piece of code in a Java class that gets executed when an object of the class is instantiated/created. Some of its special properties are:

• It does not return anything explicitly. It only creates an object of the class
• All code related to startup activity of that class goes here
• If you do not code a constructor, the JVM puts a default no arg constructor here
• It can take arguments
• It can be overloaded

Example:

public class Test {

private String name = "";

//No arg constructor

public Test(){

this.name = "Test";

}

//Constructor that has one argument

public Test(String val) {

this.name = val;

}

}

Answer 3

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 4

Constructors are used to create objects of a particular Class.

Overloaded Constructors

Overloading a constructor means typing in multiple versions of the constructor, each having a different argument list, like the following examples:

class Car {

Car() { }

Car(String s) { }

}

The preceding Car class has two overloaded constructors, one that takes a string, and one with no arguments. Because there's no code in the no-arg version, it's actually identical to the default constructor the compiler supplies, but remember-since there's already a constructor in this class (the one that takes a string), the compiler won't supply a default constructor. If you want a no-arg constructor to overload the with-args version you already have, you're going to have to type it yourself, just as in the Car example.

Overloading a constructor is typically used to provide alternate ways for clients to instantiate objects of your class. For example, if a client knows the Car name, they can pass that to a Car constructor that takes a string. But if they don't know the name, the client can call the no-arg constructor and that constructor can supply a default name. Here's what it looks like:

1. public class Car {

2. String name;

3. Car(String name) {

4. this.name = name;

5. }

6.

7. Car() {

8. this(makeRandomName());

9. }

10.

11. static String makeRandomName() {

12. int x = (int) (Math.random() * 5);

13. String name = new String[] {"Ferrari", "Lamborghini",

"Rover", "Spyker",

"Lotus"}[x];

14. return name;

15. }

16.

17. public static void main (String [] args) {

18. Car a = new Car();

19. System.out.println(a.name);

20. Car b = new Car("Proton");

21. System.out.println(b.name);

22. }

23. }

Running the code four times produces this output:

% java Car

Lotus

Proton

% java Car

Ferrari

Proton

% java Car

Rover

Proton

% java Car

Ferrari

Proton

Answer 5

Overloading a constructor means typing in multiple versions of the constructor, each having a different argument list, like the following examples:

class Car {

Car() { }

Car(String s) { }

}

The preceding Car class has two overloaded constructors, one that takes a string, and one with no arguments

Answer 6

Overloading a constructor means typing in multiple versions of the constructor, each having a different argument list, like the following examples:

class Car {

Car() { }

Car(String s) { }

}

The preceding Car class has two overloaded constructors, one that takes a string, and one with no arguments. Because there's no code in the no-arg version, it's actually identical to the default constructor the compiler supplies, but remember-since there's already a constructor in this class (the one that takes a string), the compiler won't supply a default constructor. If you want a no-arg constructor to overload the with-args version you already have, you're going to have to type it yourself, just as in the Car example.

Overloading a constructor is typically used to provide alternate ways for clients to instantiate objects of your class. For example, if a client knows the Car name, they can pass that to a Car constructor that takes a string. But if they don't know the name, the client can call the no-arg constructor and that constructor can supply a default name. Here's what it looks like:

1. public class Car {

2. String name;

3. Car(String name) {

4. this.name = name;

5. }

6.

7. Car() {

8. this(makeRandomName());

9. }

10.

11. static String makeRandomName() {

12. int x = (int) (Math.random() * 5);

13. String name = new String[] {"Ferrari", "Lamborghini",

"Rover", "Spyker",

"Lotus"}[x];

14. return name;

15. }

16.

17. public static void main (String [] args) {

18. Car a = new Car();

19. System.out.println(a.name);

20. Car b = new Car("Proton");

21. System.out.println(b.name);

22. }

23. }

Running the code four times produces this output:

% java Car

Lotus

Proton

% java Car

Ferrari

Proton

% java Car

Rover

Proton

% java Car

Ferrari

Proton