Methods and Formatted Output

Chapter 4

Overview

• Breaking down a big program into small methods.

• Formatting output– using printf– using DecimalFormat

Methods

• Methods are similar to friends. • You can ask them to do you a favor.• You can send some data to them (or you can call them

without sending data).• You can get back at most one piece of data (or no data). • For example, the println method is like a friend that does

some printing. You send the method the data and he does the printing. The method does not return any information.

• Conversely, the nextInt method takes no input. However, it returns back an integer.

Example Program

import java.util.*;public class Remodel { public static void main(String[] args) { callBob(); callPeter(); }

public static void callBob() { System.out.println("Paint room"); }

public static void callPeter() { System.out.println("Install hardwood floor"); }}

Notes

• For now, all methods are public and static.• Calling a method transfers the flow of control to the method.

Once the method is executed, control goes back to the calling method (main in our case).

• Method names start with a lowercase letter.• We must always use parenthesis, i.e. method_name( ... )

when calling a method. This tells Java that we are calling a method and not referencing to a variable.

• A method must have a return type. Use void when it does not return anything.

Method Signature

import java.util.*;public class Remodel { public static void main(String[] args) { double bobPrice = callBob(8, 12); double peterPrice = callPeter(8, 12); double totalPrice = bobPrice + peterPrice; System.out.println("Total price for the project: $"

+ totalPrice); }

public static double callBob(int width, int length) { System.out.println("Paint room"); double pricePSF = 0.80; return pricePSF * width * length; }

public static double callPeter(int width, int length) { System.out.println("Install hardwood floor"); double pricePSF = 3.20; return pricePSF * width * length; }}

Notes

• Two ways to call a method:– m(...) <- use when method does not return anything (void

method) and– a = m( ...) <- use when method returns a value.

• When a method returns a value, we must save the value (or use it directly, e.g., print it).

• A common mistake is to call a method that computes something, but don't save the result. Then all the work that is done by the method will go to waste.

Atomic Variables

• Instance (i.e. non-static) variables in Java are atomic (i.e., memory for them is automatically allocated and freed).

• The memory for a variable is allocated when the variable is defined.

• The memory is freed when the block in which the variable is defined finishes.

• Note that the variable is NOT valid outside the block in which it is defined.

• When a method is called, the variables of the first method will not be valid inside the method that is called.

Formal vs. Actual Parameters

• The formal parameters are defined in the signature of the method:

• public static double callPeter(int width, int length) {...}

• Formal parameters are basically local variable for the method. They are only defined inside the method.

• Actual parameters are the parameters that are sent to the method:– double bobPrice = callBob(8, 12);

• These could be literals, variables, or expressions.• The formal parameters are initialize by the value of the actual

parameters.• Changing the value of a formal parameter variable does not

change the value of an actual parameter variable.

Example Codeint x = 3;int y = 5;callBob(x,y);

• Note that the method call can not change the value of the variables x and y. Any change to these variables inside the callBob method will only change the formal (i.e., local for the method variables) and not the actual parameters.

The return Statement

• Performs two tasks:– always exits the method (including a void method) and– returns back exactly one piece of information (or nothing

for void methods).• Use the following syntax when a method returns a value.– a= m( ...) or– System.out.println(m(...))

• Never use just m(...) when a method returns a value. All the work to compute the result will be wasted.

Formatting Output Using printf

• Example:

System.out.printf(" $%.2f on painting and"+ " $%.2f on hardwood for total of $%.2f,", bobPrice, peterPrice, totalPrice);

• Method has variable number of arguments.• The first parameter is the string that is printed.• Whenever a %... is found in the first parameter, it is replaced

with the next parameter in the list.• %.2f means display a float (or a double) with 2 digits after the

decimal dot.

Examples Using printf

Remember that %d stands for decimal, not float!

Formatting Real Numbers Using printf

• %.3f -> 3 digits after the decimal dot. Result is rounded.– For example: printf("%.3f",2.998) will print 3.000

• %6.2f -> 2 digits after the decimal dot and at least 6 total characters– For example, printf("7.3f",2.998) will print " 3.000", where

there are 2 spaces at front.• %-7.2f will justify it to the right.• For example, printf("7.3f",2.998) will print "3.000 ", where

there are 2 spaces at the back.

Formatting Output Using DecimalFormat

public class Test { public static void main(String[] args){ DecimalFormat myFormatter = new DecimalFormat("$###,###.00"); System.out.println(myFormatter.format(32536.34)); }} // will print $32,536.34

• Used when we want to format output using special characters, e.g. $32,536.34 is the output of the program.

• # means there may or may not be a number there• 0 means there must be a number. If there is no number, put 0.public class Test { public static void main(String[] args){ DecimalFormat myFormatter = new DecimalFormat("$000,000.00"); System.out.println(myFormatter.format(32536.34)); }}// will print $032,536.34

Code Refactoring

• Refactoring meaning rewriting code without changing what it does.

• We want the code to be very clean and self-explanatory.• Want to use methods.• Every method must perform a single task. If a method performs

multiple tasks, break it down into several methods. • Try to make methods reusable. A method that makes a stickman

jump and scratch their ear will not be reusable. Instead, create jump method and scratch ear methods.

• If you have code that repeats multiple times, then try to move it to a method. This will make the code more compact and easy to understand.

• Always give methods meaningful names.

Previous Code to Print Diamondfor (int numStars =1, numSpaces = size-1; numSpaces >=0 ;

numSpaces-=2, numStars+=2){ for (int i = 0; i < numSpaces; i++) { System.out.print(" "); } for (int i = 0; i < numStars; i++) { System.out.print("* "); } System.out.println();}for (int numStars=size-2, numSpaces = 2; numStars >=0 ;

numSpaces+=2, numStars-=2 ) { for (int i = 0; i < numSpaces; i++) { System.out.print(" "); } for (int i = 0; i < numStars; i++) { System.out.print("* "); } System.out.println();}

import java.util.*;public class Diamond { public static void printStrings(String s, int n){ for(int i=0; i < n; i++){ System.out.print(s); } } public static void main(String[] args) { Scanner keyboard = new Scanner(System.in); System.out.print("Enter size of diamond: "); int size = keyboard.nextInt(); for (int numStars =1, numSpaces = size-1; numSpaces >=0 ;

numSpaces-=2, numStars+=2) { printStrings(" ",numSpaces); printStrings("* ",numStars); System.out.println(); } for (int numStars=size-2, numSpaces = 2; numStars >=0 ;

numSpaces+=2, numStars-=2 ) { printStrings(" ",numSpaces); printStrings("* ",numStars); System.out.println(); } }}

import java.util.*;public class Diamond { public static void printStrings(String s, int n) { ... } public static void printLine(int numSpaces, int numStars) { printStrings(" ", numSpaces); printStrings("* ", numStars); System.out.println(""); } public static void main(String[] args) { Scanner keyboard = new Scanner(System.in); System.out.print("Enter size of diamond: "); int size = keyboard.nextInt(); for (int numStars = 1, numSpaces = size - 1; numSpaces >= 0;

numSpaces -= 2, numStars += 2) { printLine(numSpaces,numStars); } for (int numStars = size - 2, numSpaces = 2; numStars >= 0;

numSpaces += 2, numStars -= 2) { printLine(numSpaces, numStars); } }}

Self-Documenting Code

• Always choose proper names for methods and variables (starting with small letter).

• The name of a method should explain what the method does.• For example, the code on the last slide is self-explanatory, we

do not need any documentation. The method printLine prints a line of the diamond, for example.

• Create a method for every task and name the method appropriately (describing what is the task). For big tasks, a method can call other methods to execute sub-tasks. For example, the printLine method calls the printStrings method.

Documenting Methods using JavaDoc

• In NetBeans, Type /**• A template magically appears.• Can be typed before a method or a class.• Fill in the missing pieces.• For methods, describe method purpose and parameters.• For classes, describe class purpose.• Can be used to generate HTML JavaDoc file.• Just go to Run: Generate JavaDoc

JavaDoc Example

/*** Prints a string multiple times on the same line.* @param s The string to be printed.* @param n The frequency.*/ public static void printStrings(String s, int n) { for (int i = 0; i < n; i++) { System.out.print(s); } }

Pass by Value

• Primitive types, e.g., int, double, etc., are passed by value.• This means that a method cannot modify input parameters of

these types.• The variables for the formal parameters are local variables

and they can change in a method.• However, the calling method will not see the changes.

What will be printed?

import java.util.*;

public class Example{ public static void inc(int i){ i++; } public static void main(String[] args) { int i = 3; inc(i); System.out.println(i); }}

What About Now?

import java.util.*;

public class Example{ public static int inc(int i){ i++; return i; } public static void main(String[] args) { int i = 3; i = inc(i); System.out.println(i); }}

Third Example

import java.util.*;

public class Example{ static int i; public static void inc(){ i++; } public static void main(String[] args) { i = 3; inc(); System.out.println(i); }}

Method return type

• A method can return only one piece of data.• If a method needs to return multiple pieces of data, there are

several options:– Define the data global. The method can have void return

type and will have access to the data.– Break the method into several methods. Each method can

return one piece of the data.

The Trading Game

• We can trade apples and pears.• The game has 10 days.• Every day the price changes randomly.• The goal is to make the most $$$.• Every day we can buy or sell apples or pears. • We start with $100.• There are restrictions:– We can't buy more than what we can afford.– We can't sell if we don't have the inventory.

• We can use a top-down approach to implement the game.• We can write the main method that calls methods. The

methods can be written later.

import java.text.*;import java.util.*;public class TradingGame { static final int NUMBER_OF_DAYS=10; static final double BASE_PRICE = 10; static final double VARIATION = 5; static final double INITIAL_CASH=100; static double cash = INITIAL_CASH; static int appleInventory = 0; static int pearInventory = 0; static double applePrice, pearPrice;

public static void main(String[] args) { for (int day = 1; day <= NUMBER_OF_DAYS; day++) { applePrice = computePrice(BASE_PRICE, VARIATION); pearPrice = computePrice(BASE_PRICE, VARIATION); System.out.println("Day: " + day + " out of 10"); int choice; do{ printMenu(); choice = getChoice();

switch (choice) { case 1: // Print cash balance and inventory System.out.println("Cash: " + currencyFormatter(cash)); System.out.println("Apple inventory: "+appleInventory); System.out.println("Pear inventory: "+pearInventory); break; case 2: //Print today's prices System.out.println("Price of apples is: "+

currencyFormatter(applePrice)); System.out.println("Price of pears is: "+

currencyFormatter(pearPrice)); break; case 3: { //Buy apples int amount = getQuantity("apples", "buy"); if (!buyApples(amount)) { System.out.println("You don't have enough money"); } break; } case 4: { // Sell apples int amount = getQuantity("apples", "sell"); if (!sellApples(amount)) { System.out.println("You don't have enough apples"); } break;}

case 5: { // Buy Pears int amount = getQuantity("pears", "buy"); if (!buyPears(amount)) { System.out.println("You don't have enough money"); } break; } case 6: { // Sell Pears int amount = getQuantity("pears", "sell"); if (!sellPears(amount)) { System.out.println("You don't have enough pears"); } break; } } } while (choice != 7); } System.out.println("You finished with:"+

currencyFormatter(cash)); } ...}

Notes• Constants are defined as static final. All constants are defined at the

beginning of the code. Constants use all capital letters.• Lots of global variables. The reason is that most methods need to return

several piece of data. For example, buyApples updates cash and appleInventory. In addition, it returns a Boolean value: was the operation successful.

• Price of apples and pairs ranges in the interval:(BASE_PRICE -VARIATION, BASE_PRICE+VARIATION)

• getQuality method is used to get amount for buy/sell of apples/pairs.

public static void printMenu() { System.out.println("1.Print cash balance and inventory"); System.out.println("2.Print today's prices"); System.out.println("3.Buy apples"); System.out.println("4.Sell apples"); System.out.println("5.Buy pears"); System.out.println("6.Sell pears"); System.out.println("7.I am done for today");}public static int getChoice() { Scanner keyboard = new Scanner(System.in); int choice; do { System.out.print("Your choice: "); choice = keyboard.nextInt(); } while (choice > 7 || choice < 1); return choice;}public static String currencyFormatter(double amount) {DecimalFormat myFormatter = new DecimalFormat("$#,###.00"); return myFormatter.format(amount);}

public static double computePrice(double basePrice, double variation) { double result = basePrice; if (Math.random() > 0.5) { result += Math.random() * variation; } else { result -= Math.random() * variation; } return ((int)(result*100))/100.0;}public static int getQuantity(String product, String action) { System.out.print("How many " + product + " do you want to " + action + "? "); Scanner keyboard = new Scanner(System.in); return keyboard.nextInt();}public static boolean sellApples(int amount) { if (amount > appleInventory) { return false; } cash += amount * applePrice; appleInventory -= amount; return true;}

public static boolean sellPears(int amount) { if (amount > pearInventory) { return false; } cash += amount * pearPrice; pearInventory -= amount; return true;}public static boolean buyApples(int amount) { if (amount * applePrice < cash) { cash -= amount * applePrice; appleInventory += amount; return true; } return false;}public static boolean buyPears(int amount) { if (amount * pearPrice < cash) { cash -= amount * pearPrice; pearInventory += amount; return true; } return false;}

Notes

• The buy/sell methods check to see if the operation is possible. If it is not, they return false.

• The methods modify global variables.• Every method performs one task. Can't easily combine buy/sell

methods.• We used DecimalFormat to format output.• The following code is possible, but not preferred (too cryptic).public static double computePrice(double basePrice, double variation) { return ((int)((basePrice + (Math.random() > 0.5 ? 1 : -1) * variation)*100))/100.0;}• ((int)(result*100))/100.0; //Saves 2 digits after the dot.

Conclusion

• Use methods to break a big problem into smaller problems.• Methods can be used to avoid repeating the same code

multiple times.• Methods should be short and perform a single task.• Avoid writing methods that do one of several things based on

input parameter.• Methods cannot modify input data of primitive type.• Methods can return back only a single piece of data.• Use printf and DecimalFormat for formatted printing.