Why renaming arguments in constructors?

Question

I am currently learning Java, and I often get stuck in my programming because of this problem. Maybe since my Java vocabulary isn't sufficient yet to find the right answer. If it is already posted or there is a good webpage where I can find an answer, please let me know!

public class Car {

    private int numberOfDoors;
    private int maxSpeed;

public Car(int doors, int speed) {
    numberOfDoors = doors;
    maxSpeed = speed;
}

Why do we need to create a new int doors and int speed, if int numberOfDoors and int maxSpeed are already created?

Answer 1

Why do we need to create a new int doors and int speed, if int numberOfDoors and int maxSpeed are already created?

numberOfDoors & maxSpeed are the current state of your object. int doors & int speed defines what values you want to assign to your object.

---

Just imagine your class as a Cake Making Machine:

• Your machine (your class) requires 2 ingredients (parameter arguments) to make a Cake (make an object).

• The sugar and flour slots are like the constructor parameters list. (the ingedients needed to create an object)

• The actual amount of sugar and flour added to the machine are your attribtes of the class.

In codes, this will look like:

public class CakeMachine{

    private Sugar sugarInMachine;  //attribute
    private Flour flourInMachine;  //attribute

    //constructor
    public CakeMachine(Sugar sugarToBeAdded, Flour flourToBeAdded){
        sugarInMachine = sugarToBeAdded;  //assign argument to your attribute
        flourInMachine = flourToBeAdded;  //assign argument to your attribute
    }
}

---

Answer 2

Constructor ia recieving arguments of two integer types. Whenever an instance of class will be created, it will require two arguments eg.

Car carinstance = new Car(4, 50);

These parameters which are passed here will be recieved in constructor. The constructor variable's scope is local. These variables can only be used within the constructor.

Now these local variables will be assigned to global variables which are declared in the body of class. These variables are private(within a class), hence can be used within the class in any of its methods and constructors.

Please refer any of the java tutorials to get idea of class, constructors, scope of variables, access modifiers and methods in java. You can start with tutorialspoint to get basic idea.

Answer 3

Why do we need to create a new int doors and int speed, if int numberOfDoors and int maxSpeed are already created?

Firstly to say, you really don't need. you can stick with the same names under one condition: You have to use the keyword this in order to differentiate the scope of these variables.

Having this:

public class Car {

    private int numberOfDoors;
    private int maxSpeed;

    public Car(int doors, int speed){
       numberOfDoors = doors;
       maxSpeed = speed;
    }
}

This constructor is exactly the same:

public Car(int numberOfDoors, int maxSpeed) {
   this.numberOfDoors = numberOfDoors;
   this.maxSpeed = maxSpeed;
}

The keyword this always refers to the class variable. If not present and the constructor's parameters don't contain any other same-named variable, it works according to the first snippet in my answer - the class variable is found. If both class and constructor's parameters have the same-named variables, the conflict happens and the scope of the constructor is recognised only - therefore it's needed to distinguish them with this.

Answer 4

In Java, you have three basic "kinds" of fields, class, instance, and local (this is a simplification.)

Class fields have a static modifier. All instances and all methods share these fields.

Instance fields are defined outside of any method. All instance (non-static) methods of the instance share these fields.

Local fields are defined inside a block; a method is a kind of block. These are shared only inside the block.

Parameters are a special form of local fields where the method is the containing block.

In your code, you have two sets of fields with the same names, one set are instance, one set are local (parameter.) This leads to the local fields "hiding" the instance fields.

You have a couple means of dealing with hiding. One is to rename one set of fields or the other. This is the approach I use. The other is to "qualify" the instance fields using "this." This tells the compiler that you want to always look at the instance to find the fields.

The reason you passed values to your constructor as parameters was to initialize the the instance fields. That way, the instance will be able to use those values once the constructor completes and other methods are called.

Answer 5

You want to build a Car, so you have planned your car, is going to have some doors and want to give max speed for that. But You just planned for the car i.e., you created blueprint for your car(which is class) You have come out of the dreams and start constructing your dream car so that you have to made a real object by using "new" keyword. Car car = new Car(); Now you have made a car but it doesn't have doors and max speed as you have planned.

you can add those doors and max speed by using Car reference 

like this
car.numberOfDoors = 4; car.maxSpeed = 200;

but it seems tedious and not space efficient right? so java designers add a tool that is Constructor.

which is 
   public Car(int doors, int speed){
   numberOfDoors = doors;
   maxSpeed = speed;
 }

 the benefit of this is you can directly add numberOfDoors and maxSpeed when you are creating the object.

Here comes your question you have to explicitly tell the JVM to which parameter initialising which variable otherwise JVM would confuse and ended up build a car having 200 doors with max speed 4. I am sure you can not handle it. Computers are really dumb, and Don't forgot that everything you watching on the screen is processed by things which are made of sand. what do you expect form them is what you told them.