Chapter 6 Methods

Chapter 6: Methods • String concatenation – Using the + operator with two Strings, concatenates them into a new String – Example: System.out.println("Advanced" + "Java")  prints: AdvancedJava – Using the + operator with a String and a value of another data type, concatenates the String with a String representation of the other value – Example: System.out.println("Example" + 2)  prints: Example2 – Confusing the + operator used for string concatenation with the + operator used for addition can lead to strange results. Java evaluates the operands of an operator from left to right. – Example: if integer variable y has the value 5, the expression "y + 2 = " + y + 2 results in the string "y + 2 = 52", not "y + 2 = 7", because first the value of y (5) is concatenated with the string "y + 2 = ", then the value 2 is concatenated with the new larger string "y + 2 = 5". The expression "y + 2 = " + (y + 2) produces the desired result "y + 2 = 7". • Methods • – Called functions or procedures in other languages. – Modularize programs by separating its tasks into self-contained units – Are reusable in later programs – Prevent repeating code Methods types:  static (class methods)Methods – Applies to the class as a whole instead of a specific object of the class – To declare a method as static, place the keyword static before the return type in the method’s declaration. 53  Nonstatic Methods • – Methods execute in response to method calls on specific objects – A Nonstatic method header has no static keyword static fields (or class variables)   Are fields where one copy of the variable is shared among all objects of the class Ways to Call a method: • Between Different Classes If a method in (Class1) calls a public member (method or field) in a different class (Class2) then :  If the called member is non static, then you have to create an object of class2 then use that object to call the member. Class2 objectName = new Class2( ); ObjectName.memberName  If the called member is static, then you have two ways to call the member: 1- Class2.memberName 2- Or create an object of class2 then use that object to call the member Class2 objectName = new Class2( ); ObjectName.memberName • In the Same Class Any method in the class can call other member (method or field) using only their names memberName 54 Exception: If the calling method is static and the called member (method or field) is non static then you must first: Create an object of the class then use that object to call the member ClassName objectName = new ClassName( ); ObjectName.memberName Note: Java does not allow a static method to access non-static members (methods or fields) of the same class directly. Example: 1 public class TestingMethods{ 2 private static int z; 3 private int w; 4 public static void main(String args[]) { 5 printx(4); 6 TestingMethods 7 obj1.printy(); 8 System.out.printf("z = %d\n",z); 9 System.out.printf("w = %d\n",obj1.w); obj1 = new TestingMethods(); 10 } 11 public static void printx(int x){ 12 System.out.printf("x = %d\n",x); 13 } 14 public void printy() { 15 System.out.printf("w = %d\n",w); 16 System.out.printf("z = %d\n",z); 17 }} 55  Math class – Class Math is part of the java.lang package – All methods of the Math class are static methods – static methods can be called using the class name in which the method is defined Example: Math.sqrt( 900.0 ) – Math.PI and Math.E are final static fields of the Math class where final is a keyword that represents a constant variable – Method arguments may be constants, variables or expressions. If c = 13.0, d=3.0 and f = 4.0, then the statement System.out.println( Math.sqrt( c + d * f ) ); calculates and prints the square root of 13.0 + 3.0 * 4.0 = 25.0—namely, 5.0. • The following table summarizes several Math class methods. Where, x and y are of type double. Method Description Example abs( x ) absolute value of x ceil( x ) rounds x to the smallest integer not less than x abs( 0.0 ) is 0.0 abs( -23.7 ) is 23.7 ceil( 9.2 ) is 10.0 ceil( -9.8 ) is -9.0 cos( x ) trigonometric cosine of x (x in radians) cos( 0.0 ) is 1.0 exp( x ) exponential method ex floor( x ) rounds x to the largest integer not greater Floor( 9.2 ) is 9.0 than x floor( -9.8 ) is -10.0 log( x ) natural logarithm of x (base e) abs( 23.7 ) is 23.7 exp( 1.0 ) is 2.71828 exp( 2.0 ) is 7.38906 log( Math.E ) is 1.0 log( Math.E * Math.E ) is 2.0 max( 2.3, 12.7 ) is 12.7 max( x, y ) larger value of x and y max( -2.3, -12.7 ) is -2.3 min( 2.3, 12.7 ) is 2.3 min( x, y ) smaller value of x and y min( -2.3, -12.7 ) is -12.7 pow( x, y ) x raised to the power y (i.e., xy) pow( 2.0, 7.0 ) is 128.0 pow( 9.0, 0.5 ) is 3.0 sin( x ) trigonometric sine of x (x in radians) sin( 0.0 ) is 0.0 sqrt( x ) square root of x sqrt( 900.0 ) is 30.0 tan( x ) trigonometric tangent of x (x in radians) tan( 0.0 ) is 0.0 56  Declaring Methods with Multiple Parameters • Multiple parameters can be declared by specifying a comma-separated list. – • Arguments passed in a method call must be consistent with the number, types and order of the parameters Example: 1 import java.util.Scanner; 2 public class MaximumFinder { 3 public void determineMaximum(){ 4 Scanner input = new Scanner( System.in ); 5 System.out.print( 6 "Enter three floating-point values separated by spaces: "); 7 double number1 = input.nextDouble(); // read first double 8 double number2 = input.nextDouble(); // read second double 9 double number3 = input.nextDouble(); // read third double 10 double result = maximum( number1, number2, number3 ); 11 System.out.println( "Maximum is: " + result ); 12 } // end method determineMaximum 13 public double maximum( double x, double y, double z ) { 14 double maximumValue = x;//assume x is the largest 15 if ( y > maximumValue ) 16 17 18 19 20 21 1 2 maximumValue = y; if ( z > maximumValue ) maximumValue = z; return maximumValue; } // end method maximum } // end class MaximumFinder public class MaximumFinderTest { public static void main( String args[] ) { 3 MaximumFinder maximumFinder = new MaximumFinder(); 4 maximumFinder.determineMaximum(); 5 6 } // end main } // end class MaximumFinderTest 57  Notes: – The variables declared in the method header are called parameters while the variables in the method call are called arguments. – Declaring method parameters of the same type as float x, y instead of float x, float y is a syntax error—a type is required for each parameter in the parameter list. – Each argument must be consistent with the type of the corresponding parameter. For example, a parameter of type double can receive values like 7.35, 22 or –0.03456, but not Strings like "hello" nor the boolean values true or false. – A type is required for each parameter in the parameter list. – Redeclaring a method parameter as a local variable in the method’s body is a compilation error. – Forgetting to return a value from a method that should return a value is a compilation error. – If a return-value-type other than void is specified, the method must contain a return statement that returns a value consistent with the method’s return-value-type. – Returning a value from a method whose return type has been declared void is a compilation error. – There are three ways to return control to the statement that calls a method. o If the method does not return a result, control returns when the program flow reaches the method-ending right brace or when the statement return; is executed. o If the method returns a result, the statement return expression; evaluates the expression, then returns the result to the caller. • Omitting the return-value-type in a method declaration is a syntax error. 6.5 – A compilation error occurs when a local variable is declared more than once in a method. – In the previous example: the entire body of our maximum method could also be implemented with two calls to Math.max, as follows (Reusing method Math.max): return Math.max( x, Math.max( y, z ) ); 58  Scope of Declarations • • Basic scope rules – Scope of a parameter declaration is the body of the method in which appears. – Scope of a local-variable declaration is from the point of declaration to the end of that block. – Scope of a local-variable declaration in the initialization section of a for header is the rest of the for header and the body of the for statement. – Scope of a method or field of a class is the entire body of the class. Shadowing – A field is shadowed (or hidden) if a local variable or parameter has the same name as the field • • This lasts until the local variable or parameter goes out of scope Example: 59 1 public class Scope{ 2 // field that is accessible to all methods of this class 3 private int x = 1; 4 public void begin() { 5 int x = 5; // method's local variable x shadows field x 6 System.out.printf( "local x in method begin is %d\n", x); 7 useLocalVariable(); 8 useField(); 9 useLocalVariable(); 10 useField(); 11 System.out.printf("\nlocal x in method begin is %d\n", x); 12 } // end method begin 13 public void useLocalVariable() { 14 int x = 25; 15 System.out.printf("\nlocal x on method useLocalVariable is %d\n",x); 16 ++x; 17 System.out.printf( "local x before exiting method is %d\n", x ); 18 } // end method useLocalVariable 19 public void useField(){ 20 System.out.printf( "\nfield x on method useField is %d\n", x ); 21 x *= 10; 22 System.out.printf( "field x before exiting method is %d\n",x ); 23 } // end method useField 24 } // end class Scope 1 public class ScopeTest { 2 public static void main( String args[] ){ 3 Scope testScope = new Scope(); 4 testScope.begin(); 5 6 } // end main } // end class ScopeTest 60  Random-Number Generation – static method random from class Math • – Returns doubles in the range 0.0 <= x < 1.0 class Random from package java.util – • Can produce pseudorandom boolean, byte, float, double, int, long • Is seeded with the current time of day to generate different sequences of numbers each time the program executes To generate a random number in certain sequence or range • Use the expression: shiftingValue + differenceBetweenValues * randomNumbers.nextInt( scalingFactor) where: – • shiftingValue is the first number in the desired range of values • differenceBetweenValues represents the difference between consecutive numbers in the sequence • scalingFactor specifies how many numbers are in the range Example: 1 // Fig. 6.7: RandomIntegers.java 2 // Shifted and scaled random integers. Example1: import java.util.Random; 3 // program uses class Random 4 5 public class RandomIntegers 6 { 7 public static void main( String args[] ) 8 { 9 Random randomNumbers = new Random(); // random number generator 10 int face; // stores each random integer generated 11 12 // loop 20 times 13 for ( int counter = 1; counter <= 20; counter++ ) 14 { 15 // pick random integer from 1 to 6 16 face = 1 + randomNumbers.nextInt( 6 ); 17 18 System.out.printf( "%d ", face ); // display generated value 19 20 // if counter is divisible by 5, start a new line of output 21 if ( counter % 5 == 0 ) 22 23 24 System.out.println(); } // end for } // end main 25 } // end class RandomIntegers 61 Two different sets of results containing integers in the range 1-6  1 5 4 3 5 2 4 1 3 6 4 6 6 5 2 2 2 2 6 2 6 1 6 6 5 2 3 4 4 5 2 2 2 1 2 6 6 3 1 4 Method overloading – Multiple methods with the same name, but different types, number or order of parameters in their parameter lists. – Compiler decides which method is being called by matching the method call’s argument list to one of the overloaded methods’ parameter lists – – A method’s name and number, type and order of its parameters form its signature Differences in return type are irrelevant in method overloading – Overloaded methods can have different return types – Methods with different return types but the same signature cause a compilation error – Declaring overloaded methods with identical parameter lists is a compilation error regardless of whether the return types are different. – Example: 62 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 // Fig. 6.13: MethodOverload.java // Overloaded method declarations. 1 // Fig. 6.14: MethodOverloadTest.java 2 3 4 5 // Application to test class MethodOverload. public class MethodOverload { // test overloaded square methods public void testOverloadedMethods() { System.out.printf( "Square of integer 7 is %d\n", square( 7 ) ); System.out.printf( "Square of double 7.5 is %f\n", square( 7.5 ) ); } // end method testOverloadedMethods // square method with int argument public int square( int intValue ) { System.out.printf( "\nCalled square with int argument: %d\n", intValue ); return intValue * intValue; } // end method square with int argument // square method with double argument public double square( double doubleValue ) { System.out.printf( "\nCalled square with double argument: %f\n", doubleValue ); return doubleValue * doubleValue; } // end method square with double argument } // end class MethodOverload public class MethodOverloadTest { 6 public static void main( String args[] ) 7 8 { MethodOverload methodOverload = new MethodOverload(); 9 methodOverload.testOverloadedMethods(); 10 } // end main 11 } // end class MethodOverloadTest Called square with int argument: 7 Square of integer 7 is 49 Called square with double argument: 7.500000 Square of double 7.5 is 56.250000 63