1. Methods Liang, Chapter 4

2. What is a method? A method is a way of running an ‘encapsulated’ series of commands. System.out.println(“ Whazzup ”); JOptionPane.showMessageDialog(null, “ Hello !”); Name=JOptionPane.showInputDialog(null,“ Who’re you ?”); int i=Math.pow(3,2); main(String[] args) {....} These methods give us a simple way of getting Java to do complicated things (other programmers have written code in the method which does those things) We’ve already used methods that’re part of java(written by other programmers) Now its time to write our own methods..........

3. When calling a method (we’ve done this before) JOptionPane.showMessageDialog(null,“Hello”); What Class the method belongs to The name of the method we’re calling Arguments to the method (in brackets) Name=JOptionPane.showInputDialog(null,“ who’re you ?”); What Class the method belongs to The name of the method we’re calling Arguments to the method (in brackets) Data returned by the method goes here This method does something: This method does something and returns a value:

4. Writing the code for a method A method needs to be defined (write its code and give it a name) The definition has a header and a body The header specifies: –which pieces of code can use the method ( public /private etc.) –what the return type of the method is (what type of data it returns) –the method’s name –the arguments or parameters passed to the method when it is called

5. Example: max We will create method to return the maximum of two integers Here’s an example of calling this method int i = 5; int j = 3; int k = max(i, j); System.out.println(“k is “ + k); This method max gets the highest of the two arguments passed in, and returns it (in this case, to the int k ). I’ve left out the name of max’s class here for the moment! I’ll explain soon…

6. The method header public static int max(int num1, int num2) modifiers return type method name parameters each parameter has a type and a name. This tells us that method max is public, takes two integers as arguments (within the method these will be called num1 and num2 ), and returns an integer as its answer.

7. The method max public static int max(int num1, int num2) { int result = 0; if(num1 > num2) { result = num1; } else { result = num2; } return result; } This code works out which of num1 or num2 is higher, and puts the answer in the result variable This line returns the contents of the result variable to the user as the answer from this method. The method header says an int must be returned: the result variable is an int.

8. Max in a Class ( a program) public class Fintan { public static int max(int num1, int num2) { int result = 0; if(num1 > num2) { result = num1; } else { result = num2; } return result; } public static void main (String[] args) { int i = 4; int j = 8; int k = Fintan.max(i, j); System.out.println(k); } } The max method is defined inside a class called Fintan This is the main method of the class Fintan. We call max by giving the class it is part of, the method name, and its arguments.

9. Calling a method If a method returns a value, then a call to that method produces a value of the returned type: int larger = Fintan.max(4, 8); We can use a call to the method anywhere that a value of that type is appropriate: System.out.println( Fintan.max(4, 8)); If the method is defined in some other class (program) we wrote, we have to give the name of that class (as in Fintan.max(4, 8) ) If the method is defined in the current class, we don’t need to give the class name; java can guess. In class Fintan we can just say max(4, 8) if we like. (Java knows we mean Fintan.max(4,8) )

10. Methods without a return type Some methods do not return a value. In the method header, the return type is given as void If a method does not have a return value, then presumably it does something else which is of potential use, e.g........ System.out.println(“whoopie”); When a method call is reached, code execution carries on at the start of the method body When the end of the method body (or a return statement) is reached, the flow of control returns to the point at which the method was called.

11. Testing max public class Fintan { public static int max(int num1, int num2) { int result = 0; if(num1 > num2) { result = num1; } else { result = num2; } return result; } public static void main (String[] args) { int i = 4; int j = 8; int k = max(i, j); System.out.println(k); } } I didn’t bother with Fintan. here, just to save typing.

12. // in the main method int i = 4; int j = 8; int k = max(i, j); System.out.print(k); // the max method public static int max(int num1, int num2) { int result = 0; if(num1 > num2) { result = num1; } else { result = num2; } return result; } When max is called, the variable num1 (in the method definition) gets the value 4, and the variable num2 gets the value 8.

13. That main method public static void main(String[] args) modifiers return type name parameter (an array of Strings)

14. Passing parameters public static void nPrintLn(String s, int n) { for(int i=0; i<n; i++) { System.out.println(s); } nPrintLn(“Hi mom”, 4); // ok nPrintLn(“”, 0); // ok, but pointless nPrintLn(3, “Hi”); // not ok Actual parameters must match formal parameters in type, order and number........

15. passing by value When a method call is reached, a copy of the actual parameters is made Within the method body, these copies are used No change in the original values can be made The value of the parameters are used

16. pass-by-value int i = 5; int j = 3; System.out.printLn(“i: “ + i + “ j: “ + j); swap(i, j); // swap tries to swap the contents of i and j System.out.printLn(“i: “ + i + “ j: “ + j); 1.What would swap look like? 2.What will this code print? 3.Will swap work?

17. // in our main method int i = 5; int j = 3; swap(i, j); // our swap method...void swap(int n1, int n2) ij n1: copy of in2: copy of j n1n2 5353 3 5 53 ij

18. Overloading methods Our max method only works with parameters of type int. Its signature consists of the method name (max) and the formal parameters (int num1, int num2) What if we want to find the maximum of two double values?

19. Two versions of max // max for integers public static int max(int n1, int n2)..... // max for doubles public static double max(double n1, double n2)... When we call one of these methods, if is clear from the parameters we pass which one we mean....... Example 4.3, p. 125

20. Tips on overloading methods Methods that do essentially the same thing should have the same name Overloaded methods must differ in their parameter lists You cannot have two methods with the same name, same parameter lists and different return types

21. Method Abstraction input (optional)return value (optional) method signature method body implementation (black box)

22. Signature vs implementation Knowing the method signature (and return type) ought to be enough to allow you to use a method Typically, you should not care about how a method has been defined by someone else Abstraction (separation of the public face from the private implementation) is essential for software design

23. Example: the Math class public static double sin(double radians) public static double cos(double radians) public static double sqrt(double a) // returns e to the power of a public static double exp(double a) // returns log (base e) of a public static double log(double a) // the next 2 have different signatures public static double pow(double a, double b) public static int pow(int a, int b)

24. Math.random() public static double random() Returns a double in the range [0..1) Each value in that range is equally likely to be generated (uniform distribution) How would you generate a number in the range –2..2? How could you generate a random integer in 1..10?

25. Case study 4.4, p. 132.... Study this example carefully Illustrates use of Math.random, Math.round, Math.pow, and Math.sqrt Computes the mean and the standard deviation of a series of random numbers mean = “average” standard deviation: a measure of the amount of variability in the set of numbers