This lesson will look at how to create a method with input parameters. To illustrate this, let’s take a look at the calculateCups() helper method that we created in the previous lesson:
Although this particular solution works, it isn’t intuitively scalable if we ever want to add a new calculation – something greater than cups-to-gallons for example – as it would require a modification within the method internals (the conditional if()…else if() statements, in this case). By doing this, we increase the risk of introducing bugs into the existing code. It would be much easier if we could just pass into each call to calculateCups() the particular measurement ratio required for that calculation, and eliminating the need for the conditional block entirely.
This precise functionality is possible by changing the calculateCups() method so that it allows for an input parameter to be passed into the method:
By doing this, we essentially assign a variable that we can reference throughout the remaining body of this helper method, with the actual value being supplied at the method call. Now we can remove the conditional block and, in its place, incorporate the measureToCupRatio parameter in the following manner:
You may have noticed that when you added the measureToCupRatio input parameter for calculateCups(), it caused all of the previous calls to calculateCups() to become decorated with a red squiggly line, indicating an error. The error simply means that you are not calling the method properly now that it requires a value to be given as an input parameter when it is called. But first, before we fix this, let’s comment out the following call as it will become problematic and require a little more effort to get working properly:
Now, let’s supply all of the calculateCups() calls with values relative to its calling method’s conversion ratio (IE: 1:1 ratio between cups/cups, a 2:1 ratio between cups/pints, a 4:1 ratio between cups/quarts, and a 16:1 ratio between cups/gallons):
Notice how all of this refactoring creates the same results as before when running the application. However what has really been improved has been the maintainability and readability of the code in the backend. Not all code improvements are visible to the end-user!
The main rule of thumb for when and where to incorporate input parameters is to do so wherever you need to separate what remains the same, with what sometimes is different between each call to the helper method. In this case, what’s different each time you call the method is the measure/cup ratio, whereas the calculation details are the same with each method call. In other words, we're adding variability to the method through whatever we choose to pass in via the measureToCupRatio input parameter, while the logic within the code block remains unchanged. To demonstrate this further and to illustrate how you can utilize more than one input parameter, let’s modify the resultLabel to be more descriptive depending on which conversion was selected:
This new variable – measureName – can now be supplied, at method call, as a second input parameter:
We will now have to modify all of the calculateCups() calls with a second input parameter passed in that assumes the place wherever measureName is referenced within the method internals. Note that you could add as many input parameters as needed, separating each input parameter with a comma:
Now you can save and run the project to see the results:
Input parameters – also referred to as “arguments” when supplied at the method’s call – function in much the same way as any other variable you have come to learn about thus far. By creating an input parameter, you are essentially declaring a variable local to the method itself with its assignment being determined by whatever value is copied/passed-in at the method call. That input parameter’s variable name then becomes the identifier that we use throughout the method’s code block wherever that variable needs to be referenced.
Lesson 29 - Creating Methods with Input Parameters