Basic question about constructors

[Janeice DelVecchio]

Alright, so constructors are just fancy setter methods, right?

Here's my question... I need to create "all required public constructors" for this project. I have the following instance variables:

String companyName
double amountDue
String dateCharged    

I guess I neeed to make the following constructors....

Invoice(companyName, amountDue, dateCharged)
Invoice()    

or do I need constructors for each individual instance variable AND for each combonation of orders the variables could go in?

[Lee Kian Giap]

No, constructor is totally different things from setter method. Constructor normally is used to initialize instance variable, but it is not a must, it can be use to perform any operation that you like which execute when you create a new object (i.e instantiation).

Firstly, what did you means by "all required public constructors" ? there is nothing so called "required" in Java for constructor. If you did not create one, compiler will add in a no-args constructor.

Another thing is constuctor have nothing to do with instance variable although it can be use to initialize instance variable, whether to have a non-arg constructor or/and numerous args constructor depends on what you want to achieve when carry out instantiation (i.e create new object).

From your code, proven that you did not compile and test it out before asking the question. In the code provided by you above, all the arguments without its type will cause compile error.


Here, provided you with an example which demonstrate the above statements:

    
public class Invoice {
    String companyName ;
    double amountDue;
    String dateCharged;

    Invoice() { }

    Invoice(String name, String date, double amount, double deduction) {
        companyName = name;
        amountDue = amount - deduction;
        dateCharged = date;
    }

    public static void main (String [] args){
        String comName = "ABC Ltd.";
        String dateInvoice = "20091111";
        double amtPay = 3190.50;
        double discount = 319.05;
        Invoice invc = new Invoice(comName, dateInvoice, amtPay, discount);
    }

}

[Janeice DelVecchio]

I did compile and run before I asked. I'm just trying to figure out if the 2 constructors I made is enough to satisfy the requirements of the project spec.

My app is fully functional and working.

The specification specifically states "creates all required public constructors, including one that uses all setters to initialize all private attributes"

My constructors are as follows:

	public Invoice() {
	}
	public Invoice(String coName, double amount, String dateCharged) {
		companyName = coName;
		amountDue = amount;
		chargeDate = dateCharged;
		
	}    

I'm just not sure if I need more constructors or not to satisfy the requirement of "all required public constructors"

[Hunter McMillen]

I'm going to disagree with Lee and say that instance variables have a lot to do with constructors. The constructor is what you should be using to initialize the instance variables of your class. Constructors can be called with no parameters as Lee demonstrated above to create blank objects. But in the real world Most objects you create are going to have values.

Example:
You need to create a rectangle class.

  
    public class rectangle
   {
      private double length;
      private double width;
   
       public rectangle() {}; //constructor with no parameters
		 
       public rectangle(double length, double width) //constructor with two parameters
      {
         this.length = length;
         this.width  = width;
      }  
   
		//these setter methods are for setting the value of a rectangle
		//object that does initially get a value (one that is called with
		//the blank constructor)
		public void setLength(double length)
		{
			this.length = length;
		}
		
		public void setWidth(double width)
		{
			this.width = width;
		}
       public double getLength()
      {
         return length;
      }
   
       public double getWidth()
      {	
         return width;
      }
		
		public double getArea()
		{
			return length * width; //A = lw
		}
		
		public String toString()
		{
			String out = "";
			if (length != 0 || width != 0)
			{
				out = "This rectangle has a length of " + length + ", a width of " + width +
					 ", and an area of " + getArea();
			}
			else
			{
				out = "This rectangle does not have values yet";
			}
			
			return out;
		}
   }

    
public class testRectangle
{
	public static void main(String[] args)
	{
		//rectangle with two parameters
		rectangle rect1 = new rectangle(5.0,5.0);
		System.out.println("Rectangle 1: " + rect1.toString());
		
		//rectangle with blank constructor
		rectangle rect2 = new rectangle();
		System.out.println("Rectangle 2: " + rect2.toString());
		
		//we can set the length and width of rect2 then reprint its values
		rect2.setLength(12.0);
		rect2.setWidth(17.0);
		System.out.println("Rectangle 2: " + rect2.toString());
		
	}
}

-Hunter

[Indrasish Ghosh]

I completly agree. Let me explain it in different way. If I have something to initialize and those are mandetory instance variables then we usually put those in constructors and do not keep any default (blank) construtor. This is a way we restrict the comsumer of that class to go ahead without required fields being initialized.

[Charles Bradley]

This comment is about the application, rather than about Java. You only need one constructor, the one with all three variables. There is no reason to create an invoice until all three are known. It is an invitation to error if any have to be filled in later. There are no reasonable default values for any of the fields. When you actually write it, there is no reason to use any setters.

[Janeice DelVecchio]

Thanks for all the replies.

I agree I only NEED one constructor and any more would be silly. I also agree that if I have the proper constructor, I wouldn't need setter methods.

I have decided to leave the class with the 2 constructors, the blank one and the one with all three. My reasoning for this is the spec asks for constructorS (plural)... and I can't think of any other ways to make a reasonable constructor with the three instance variables given. I am also leaving the setters because the spec asks for them, and it seems it is requiring me to use the setter inside the constructor. Seems backwards to me.

Any feedback is welcome.

[Embla Tingeling]

Janeice DelVecchio wrote:Thanks for all the replies.

I agree I only NEED one constructor and any more would be silly. I also agree that if I have the proper constructor, I wouldn't need setter methods.

I have decided to leave the class with the 2 constructors, the blank one and the one with all three. My reasoning for this is the spec asks for constructorS (plural)... and I can't think of any other ways to make a reasonable constructor with the three instance variables given. I am also leaving the setters because the spec asks for them, and it seems it is requiring me to use the setter inside the constructor. Seems backwards to me.

I would say that having a number of constructors that just call different combinations of setters makes these constructors a question of user convenience only, they're in no way required. A user could as well create an object using the default contructor (the blank one) and then call setters to his hearts desire.

Now if you want a class to have a default constructor only, then you don't need to supply one because it's supplied automatically by Java. But if you supply non-default constructors and you want the defaullt constructor to be available too, then you must supply the default constructor yourself, Java won't do it for you. So in that case an explicit default constructor has become required. If it's not supplied by you it won't be available.

[Lee Kian Giap]

Hunter McMillen wrote:I'm going to disagree with Lee and say that instance variables have a lot to do with constructors. The constructor is what you should be using to initialize the instance variables of your class.

First, I will say thanks for disagreement ! because this encourage discussion.
Yes, as I said "constructor is normally is used to initialize instance variable", may I know which statement you disagreed with ? since I didn't mention that constructor have little or nothing to do with instance variable, so I feel a bit confuse on your disagreement.

To provide a more precise explanation on the relationship between constructor and initialization of instance variable, I will say using constructor to initialize instance variable the way to have guarantee initialization. First, using args constructor, the object of this class is created base on value that provided at runtime, which value pass into the constructor instance variable initialization. Second, using non-args constructor, simply assign value (literal value, or method return value) to the instance variable inside constructor.

However, the constructor is still not just for you to do initialization, and as I said it is not a must for initialization purpose. To be more clear in explanation, constructor is for you to carry out operations that is needed when creating new object, these operations includes initialization of instance variable. Example for operations other than initialization when you go deeper into java programming, such as call a base class method which control the concurrency (but one must not call the method in its class or subclass because instantiation haven't complete).

Hunter McMillen wrote: Constructors can be called with no parameters as Lee demonstrated above to create blank objects. But in the real world Most objects you create are going to have values.

Now, don't forget that there is object that created from class to be use without changing its state. Thus, you simply assign the value at the point you define the instance variable in the class, and therefore, you will use a args/non-args constructor just to create a new object without initialization of instance variable. So, even as you mentioned that in real world Most objects you create are going to have values, this doesn't justify that the value have to be assigned in constructor.

So, please don't mess two concept into one.

Janeice DelVecchio wrote: I did compile and run before I asked. I'm just trying to figure out if the 2 constructors I made is enough to satisfy the requirements of the project spec.

Sorry for saying that you didn't compile and test it, well please post a complete code next time to avoid misunderstanding.

Janeice DelVecchio wrote: The specification specifically states "creates all required public constructors, including one that uses all setters to initialize all private attributes"

After you post the full sentence of the requirements (bold portion), it get very clear what the project really need ! Please do post full sentence next time, thanks !

    
public class Invoice {  
    private String companyName ;  
    private double amountDue;  
    private String dateCharged;  
  
    // Why you need a no-args constructor ?
    // Since you have defined one/more args constructor, compiler will not create no-args constructor,
    // so in the future when create a subclass of Invoice, if without this no-args constructor, 
    // you must remember to call super(args).
    // Why you do not need a no-args constructor ?
    // it have no meanings , which means you don need operations when instantiate new object
    // and you want to force subclass creator to explicitly call super(args) constructor
    public Invoice() {
       // carry out operation that needed when instantiate new object
       // code here can be reuse by other constructor using this()
    }  

    public Invoice(String companyName, double amountDue, String dateCharged) {  
        //this.companyName = companyName;
		//this.amountDue = amountDue;
		//this.dateCharged = dateCharged;
		
		// why the above is not encourage ? and why should you use setter here ?
		// As the requirement stated , constructor that uses setter to initialize all private attribute.
		// The main reason is there will be a change of requirment in the future , for example
		// adding validation code in the setter method to avoid client programmer to simply 
		// pass in invalid value through constructor to create the new object.
		
		setCompanyName(companyName);
        setAmountDue(amountDue);
        setDateCharged(dateCharged);		
    } 

    // all setter and getter, as the requirement stated that you need a setter
	public void setCompanyName(String companyName){ // use private if you don't want client programmer to change the object state
	                                                // so that the value can only be initialize when instantiate.
                                                    // (make sure you don have other public method that call this setter 
                                                    // which open "backdoor" that destroy the purpose of "private")
													// But why you still need setter if using private ?
													// there might be a requirement changes in the future, for example
													// adding some validation code, or change the name of "Ltd" to "Limited", etc.
	    this.companyName = companyName;
    }

	public void setAmountDue(double amountDue){ // use private ? explanation as above
	    this.amountDue = amountDue;
    }

	public void setDateCharged(String dateCharged){ // use private ? explanation as above
	    this.dateCharged = dateCharged;
    }	
	
    public String getCompanyName() {  // use other access modifier ? you decide yourself
        return companyName;  
    }  
	
    public double getAmountDue() {  // use other access modifier ? you decide yourself
        return amountDue;  
    }  
	
    public String getDateCharged() {  // use other access modifier ? you decide yourself
        return dateCharged;  
    }  	
	
	public static void main (String [] args){
	    Invoice inv = new Invoice("Company ABC", 3190.50, "20091111");
		System.out.println("Company Name : " + inv.getCompanyName());
		System.out.println("Amount Due : " + inv.getAmountDue());
		System.out.println("Date Charged : " + inv.getDateCharged());
	}	
} 

I think the above code will help, cheers ! ~