2006 Pearson Education, Inc. All rights reserved. 1 7 7 Methods: A Deeper Look.

1

2006 Pearson Education, Inc. All rights reserved.

77

Methods:A Deeper Look

2


E pluribus unum.(One composed of many.)

— Virgil

Form ever follows function.— Louis Henri Sullivan

O! call back yesterday, bid time return.— William Shakespeare

Call me Ishmael.— Herman Melville

3


Answer me in one word.— William Shakespeare

When you call me that, smile!— Owen Wister

There is a point at which methods devour themselves.

— Frantz Fanon

Life can only be understood backwards; but it must be lived forwards.

— Soren Kierkegaard

4


OBJECTIVESIn this chapter you will learn: How static methods and variables are associated with

an entire class rather than specific instances of the class. How the method call/return mechanism is supported by

the method call stack and activation records. How to use random-number generation to implement

game-playing applications. To understand how the visibility of declarations is limited

to specific regions of applications. What method overloading is and how to create overloaded

methods. What recursive methods are. The differences between passing method arguments by

value and by reference.

5


7.1 Introduction

7.2 Packaging Code in C#

7.3 static Methods, static Variables and Class Math7.4 Declaring Methods with Multiple Parameters

7.5 Notes on Declaring and Using Methods

7.6 Method Call Stack and Activation Records

7.7 Argument Promotion and Casting

7.8 The Framework Class Library

7.9 Case Study: Random-Number Generation

7.9.1 Scaling and Shifting Random Numbers

7.9.2 Random-Number Repeatability for Testing and Debugging

7.10 Case Study: A Game of Chance (Introducing Enumerations)

7.11 Scope of Declarations

6


7.12 Method Overloading

7.13 Recursion

7.14 Passing Arguments: Pass-by-Value vs. Pass-by-Reference

7.15 (Optional) Software Engineering Case Study: Identifying Class Operations in the ATM System

7.16 Wrap-Up

7


7.1 Introduction

• Divide and conquer technique– Construct a large program from smaller pieces

– Can be accomplished using methods

•static methods can be called without the need for an object of the class

• Random number generation

• Method overloading

• Recursion

8


7.2 Packaging Code in C#

• Three common ways of packaging code:– Methods

– Classes

– Namespaces

• Benefits of using methods:– Divide and conquer; small and simple pieces

– Able to reuse software

– Easier to maintain and debug

– Hide details of implementation

9


Good Programming Practice 7.1

Familiarize yourself with the classes and methods provided by the FCL (msdn2.microsoft.com/en-us/library/ms229335). In Section 7.8, we present an overview of several common namespaces.

10


Software Engineering Observation 7.1

Don’t try to “reinvent the wheel.” When possible, reuse FCL classes and methods. This reduces application development time and avoids introducing programming errors.

11



To promote software reusability, every method should be limited to performing a single, well-defined task, and the name of the method should express that task effectively. Such methods make applications easier to write, debug, maintain and modify.

12


Error-Prevention Tip 7.1

A small method that performs one task is easier to test and debug than a larger method that performs many tasks.

13



If you cannot choose a concise name that expresses a method’s task, your method might be attempting to perform too many diverse tasks. It is usually best to break such a method into several smaller methods.

14


7.3 static Methods, static Variables and Class Math

•static method (or class method)– Applies to the class as a whole instead of a specific object of

the class

– Call a static method by using the method call:ClassName.methodName( arguments )

– All methods of the Math class are static• Example: Math.Sqrt( 900.0 )

15


Fig. 7.1 | Hierarchical boss-method/worker-method relationship.

16


Fig. 7.2 | Math class methods.

Method Description Example

Abs( x ) absolute value of x Abs( 23.7 ) is 23.7 Abs( 0.0 ) is 0.0 Abs( -23.7 ) is 23.7

Ceiling( x ) rounds x to the smallest integer not less than x Ceiling( 9.2 ) is 10.0 Ceiling( -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 Exp( 1.0 ) is 2.71828 Exp( 2.0 ) is 7.38906

Floor( x ) rounds x to the largest integer not greater than x Floor( 9.2 ) is 9.0 Floor( -9.8 ) is -10.0

Log( x ) natural logarithm of x (base e) Log( Math.E ) is 1.0 Log( Math.E * Math.E ) is 2.0

Max( x, y ) larger value of x and y Max( 2.3, 12.7 ) is 12.7 Max( -2.3, -12.7 ) is -2.3

Min( x, y ) smaller value of x and y Min( 2.3, 12.7 ) is 2.3 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

17


7.3 static Methods, static Variables and Class Math (Cont.)

• Constants– Keyword const

– Cannot be changed after initialization

– Implicitly static; syntax error when explicitly declared

• Fields (or class variables)– static variables and instance variables

•Math.PI and Math.E are const static fields of the Math class

18


7.3 static Methods, static Variables and Class Math (Cont.)

• Method main– main is declared static so it can be invoked without

creating an object of the class containing main

– Any class can contain a main method

– May omit string[] args parameter

– Able to declare main with a return type, instead of void

19


7.4 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

• Sometimes called formal parameters

20


1 // Fig. 7.3: MaximumFinder.cs

2 // User-defined method Maximum.

3 using System;

4

5 public class MaximumFinder

6 {

7 // obtain three floating-point values and determine maximum value

8 public void DetermineMaximum()

9 {

10 // prompt for and input three floating-point values

11 Console.WriteLine( "Enter three floating-point values,\n"

12 + " pressing 'Enter' after each one: " );

13 double number1 = Convert.ToDouble( Console.ReadLine() );



16

17 // determine the maximum value

18 double result = Maximum( number1, number2, number3 );

19

20 // display maximum value

21 Console.WriteLine( "Maximum is: " + result );

22 } // end method DetermineMaximum

Outline

MaximumFinder.cs

(1 of 2)Prompt the user to enter and read three double values

Call method Maximum

Display maximum value

21


23

24 // returns the maximum of its three double parameters

25 public double Maximum( double x, double y, double z )

26 {

27 double maximumValue = x; // assume x is the largest to start

28

29 // determine whether y is greater than maximumValue

30 if ( y > maximumValue )

31 maximumValue = y;

32

33 // determine whether z is greater than maximumValue

34 if ( z > maximumValue )

35 maximumValue = z;

36

37 return maximumValue;

38 } // end method Maximum

39 } // end class MaximumFinder

Outline

MaximumFinder.cs

(2 of 2)

Declare the Maximum method

Compare y and maximumValue

Compare z and maximumValue

Return the maximum value

22


1 // Fig. 7.4: MaximumFinderTest.cs

2 // Application to test class MaximumFinder.

3 public class MaximumFinderTest

4 {

5 // application starting point

6 public static void Main( string[] args )

7 {

8 MaximumFinder maximumFinder = new MaximumFinder();

9 maximumFinder.DetermineMaximum();

10 } // end Main

11 } // end class MaximumFinderTest Enter three floating-point values, pressing 'Enter' after each one: 3.33 2.22 1.11 Maximum is: 3.33 Enter three floating-point values, pressing 'Enter' after each one: 2.22 3.33 1.11 Maximum is: 3.33 Enter three floating-point values, pressing 'Enter' after each one: 1.11 2.22 867.5309 Maximum is: 867.5309

Outline

MaximumFinderTest.cs

Create a MaximumFinder object

Call the DetermineMaximum method

23


Common Programming Error 7.1

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.

24



A method that has many parameters may be performing too many tasks. Consider dividing the method into smaller methods that perform the separate tasks. As a guideline, try to fit the method header on one line if possible.

25


7.4 Declaring Methods with Multiple Parameters (Cont.)

• Reusing method Math.Max– The expression Math.Max( x, Math.Max( y, z ) )

determines the maximum of y and z, and then determines the maximum of x and that value

• String concatenation– Using the + operator with two strings concatenates them

into a new string– Using the + operator with a String and a value of

another data type concatenates the String with a String representation of the other value

• When the other value is an object, its ToString method is called to generate its String representation

26



It is a syntax error to break a string literal across multiple lines in an application. If a string does not fit on one line, split the string into several smaller strings and use concatenation to form the desired string.

27



Confusing the + operator used for string concatenation with the + operator used for addition can lead to strange results. The + operator is left-associative. For 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".

28


7.5 Notes on Declaring and Using Methods

• Three ways to call a method:– Use a method name by itself to call another method of the

same class

– Use a variable containing a reference to an object, followed by a dot (.) and the method name to call a method of the referenced object

– Use the class name and a dot (.) to call a static method of a class

•static methods cannot call non-static methods of the same class directly

29


7.5 Notes on Declaring and Using Methods (Cont.)

• Three ways to return control to the calling statement:

– If method does not return a result:• Program flow reaches the method-ending right brace

• Program executes the return statement

– If method does return a result:• Program executes the statement return expression;

- expression is first evaluated and then its value is returned to the caller

30



Declaring a method outside the body of a class declaration or inside the body of another method is a syntax error.

31



Omitting the return type in a method declaration is a syntax error.

32



Placing a semicolon after the right parenthesis enclosing the parameter list of a method declaration is a syntax error.

33



Redeclaring a method parameter as a local variable in the method’s body is a compilation error.

34



Forgetting to return a value from a method that should return a value is a compilation error. If a return type other than void is specified, the method must contain a return statement that returns a value consistent with the method’s return type. Returning a value from a method whose return type has been declared void is a compilation error.

35


7.6 Method Call Stack and Activation Records

• Stacks– Last-in, first-out (LIFO) data structures

• Items are pushed (inserted) onto the top

• Items are popped (removed) from the top

• Program execution stack– Also known as the method call stack

– Return addresses of calling methods are pushed onto this stack when they call other methods and popped off when control returns to them

36


7.6 Method Call Stack and Activation Records (Cont.)

– A method’s local variables are stored in a portion of this stack known as the method’s activation record or stack frame

• When the last variable referencing a certain object is popped off this stack, that object is no longer accessible by the program

- Will eventually be deleted from memory during “garbage collection”

• Stack overflow occurs when the stack cannot allocate enough space for a method’s activation record

37


7.7 Argument Promotion and Casting

• Argument promotion– C# will promote a method call argument to match its

corresponding method parameter according to the promotion rules

– Values in an expression are promoted to the “highest” type in the expression (a temporary copy of the value is made)

– Converting values to lower types results in a compilation error, unless the programmer explicitly forces the conversion to occur

• Some information may be lost

• Place the desired data type in parentheses before the value

- Example: ( int ) 4.5

- Result: 4

38


Fig. 7.5 | Implicit conversions between simple types.

Type Conversion types

bool no possible implicit conversions to other simple types

byte ushort, short, uint, int, ulong, long, decimal, float or double

char ushort, int, uint, long, ulong, decimal, float or double

decimal no possible implicit conversions to other simple types

double no possible implicit conversions to other simple types

float double

int long, decimal, float or double

long decimal, float or double

sbyte short, int, long, decimal, float or double

short int, long, decimal, float or double

uint ulong, long, decimal, float or double

ulong decimal, float or double

ushort uint, int, ulong, long, decimal, float or double

39



Converting a simple-type value to a value of another simple type may change the value if the promotion is not allowed. For example, converting a floating-point value to an integral value may introduce truncation errors (loss of the fractional part) in the result.

40


7.8 The Framework Class Library

• .NET Framework Class Library– Collection of namespaces

• Groups of related predefined classes

– using directives allow us to use these library class• Allows for unqualified class name

- Ex: using System;

- Instead of typing System.Console.WriteLine();- Able to call same method with Console.WriteLine();

• .NET documentation– msdn2.microsoft.com/en-us/library/ms229335

41


Fig. 7.6 | FCL namespaces (a subset) (Part 1 of 2).

Namespace Description

System.Windows.Forms Contains the classes required to create and manipulate GUIs. (Various classes in this namespace are discussed in Chapter 13, Graphical User Interface Concepts: Part 1, and Chapter 14, Graphical User Interface Concepts: Part 2.)

System.IO Contains classes that enable programs to input and output data. (You will learn more about this namespace in Chapter 18, Files and Streams.)

System.Data Contains classes that enable programs to access and manipulate databases (i.e., organized collections of data). (You will learn more about this namespace in Chapter 20, Database, SQL and ADO.NET.)

System.Web Contains classes used for creating and maintaining Web applications, which are accessible over the Internet. (You will learn more about this namespace in Chapter 21, ASP.NET 2.0, Web Forms and Web Controls.)

System.Xml Contains classes for creating and manipulating XML data. Data can be read from or written to XML files. (You will learn more about this namespace in Chapter 19, Extensible Markup Language (XML).)

42


Fig. 7.6 | FCL namespaces (a subset) (Part 2 of 2).

Namespace Description

System.Collections System.Collections.Generic

Contains classes that define data structures for maintaining collections of data. (You will learn more about this namespace in Chapter 27, Collections.)

System.Net Contains classes that enable programs to communicate via computer networks like the Internet. (You will learn more about this namespace in Chapter 23, Networking: Streams-Based Sockets and Datagrams.)

System.Text Contains classes and interfaces that enable programs to manipulate characters and strings. (You will learn more about this namespace in Chapter 16, Strings, Characters and Regular Expressions.)

System.Threading Contains classes that enable programs to perform several tasks at the same time. (You will learn more about this namespace in Chapter 15, Multithreading.)

System.Drawing Contains classes that enable programs to perform basic graphics processing, such as displaying shapes and arcs. (You will learn more about this namespace in Chapter 17, Graphics and Multimedia.)

43



The online .NET Framework documentation is easy to search and provides many details about each class. As you learn each class in this book, you should review the class in the online documentation for additional information.

44


7.9 Case Study: Random-Number Generation

• Random-number generation– Class Random

• Random’s Next method generates a random int value in the range 0 to +2,147,483,646, inclusive

• Scaling: With one int argument, Next returns a value from 0 up to, but not including, the argument’s value

• Shifting: With two int argument, Next returns a value from the lower int up to, but not including, the higher int

• Equal likelihood

– Class Random from System namespace • Is seeded with the current time of day to generate different

sequences of numbers each time the program executes

45


1 // Fig. 7.7: RandomIntegers.cs

2 // Shifted and scaled random integers.

3 using System;

4

5 public class RandomIntegers

6 {


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 = randomNumbers.Next( 1, 7 );

17

18 Console.Write( "{0} ", face ); // display generated value

19

20 // if counter is divisible by 5, start a new line of output

21 if ( counter % 5 == 0 )

22 Console.WriteLine();

23 } // end for

24 } // end Main

25 } // end class RandomIntegers

Outline

RandomIntegers.cs

(1 of 2)

Create a Random object

Generate a random die roll

46


Outline

RandomIntegers.cs

(2 of 2)

3 3 3 1 1 2 1 2 4 2 2 3 6 2 5 3 4 6 6 1 6 2 5 1 3 5 2 1 6 5 4 1 6 1 3 3 1 4 3 4

Two different sets of results containing integers in the range 1-6

47


1 // Fig. 7.8: RollDie.cs

2 // Roll a six-sided die 6000 times.

3 using System;

4

5 public class RollDie

6 {


8 {

9 Random randomNumbers = new Random(); // random number generator

10

11 int frequency1 = 0; // count of 1s rolled






17

18 int face; // stores most recently rolled value

19

20 // summarize results of 6000 rolls of a die

21 for ( int roll = 1; roll <= 6000; roll++ )

22 {

23 face = randomNumbers.Next( 1, 7 ); // number from 1 to 6

Outline

RollDie.cs

(1 of 3)

Declare frequency counters


Iterate 6000 times

Generate a random die roll

48


24

25 // determine roll value 1-6 and increment appropriate counter

26 switch ( face )

27 {

28 case 1:

29 frequency1++; // increment the 1s counter

30 break;

31 case 2:


33 break;

34 case 3:


36 break;

37 case 4:


39 break;

40 case 5:


42 break;

43 case 6:


45 break;

46 } // end switch

47 } // end for

Outline

RollDie.cs

(2 of 3)

switch based on the die roll to determine frequency

49


48

49 Console.WriteLine( "Face\tFrequency" ); // output headers

50 Console.WriteLine( "1\t{0}\n2\t{1}\n3\t{2}\n4\t{3}\n5\t{4}\n6\t{5}",

51 frequency1, frequency2, frequency3, frequency4,

52 frequency5, frequency6 );

53 } // end Main

54 } // end class RollDie Face Frequency 1 1039 2 994 3 991 4 970 5 978 6 1028 Face Frequency 1 985 2 985 3 1001 4 1017 5 1002 6 1010

Outline

RollDie.cs

(3 of 3)Display die roll frequencies

50


7.9.1 Scaling and Shifting of Random Numbers

• To generate a random number in certain sequence or range

– Use the expressionshiftingValue + differenceBetweenValues * randomNumbers.Next( 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

51


7.9.2 Random-Number Repeatability for Testing and Debugging

• To get a Random object to generate the same sequence of random numbers every time the program executes, seed it with a certain value

– When creating the Random object:Random randomNumbers =

new Random( seedValue );

– seedValue argument is of type int

52



While an application is under development, create the Random object with a specific seed value to produce a repeatable sequence of random numbers each time the application executes. If a logic error occurs, fix the error and test the application again with the same seed value—this allows you to reconstruct the same sequence of random numbers that caused the error. Once the logic errors have been removed, create the Random object without using a seed value, causing the Random object to generate a new sequence of random numbers each time the application executes.

53


7.10 Case Study: A Game of Chance (Introducing Enumerations)

• Enumerations– Programmer-declared types consisting of sets of constants

– enum keyword

– A type name (e.g. Status)

– Enumeration constants (e.g. WON, LOST and CONTINUE)• To compare simple-type value to underlying value of an

enumeration, you must typecast for the two types to match

54


1 // Fig. 7.9: Craps.cs

2 // Craps class simulates the dice game craps.

3 using System;

4

5 public class Craps

6 {

7 // create random number generator for use in method RollDice

8 private Random randomNumbers = new Random();

9

10 // enumeration with constants that represent the game status

11 private enum Status { CONTINUE, WON, LOST }

12

13 // enumeration with constants that represent common rolls of the dice

14 private enum DiceNames

15 {

16 SNAKE_EYES = 2,

17 TREY = 3,

18 SEVEN = 7,

19 YO_LEVEN = 11,

20 BOX_CARS = 12

21 }

Outline

Craps.cs

(1 of 4)


Declare an enumeration

55


22

23 // plays one game of craps

24 public void Play()

25 {

26 // gameStatus can contain CONTINUE, WON or LOST

27 Status gameStatus = Status.CONTINUE;

28 int myPoint = 0; // point if no win or loss on first roll

29

30 int sumOfDice = RollDice(); // first roll of the dice

31

32 // determine game status and point based on first roll

33 switch ( ( DiceNames ) sumOfDice )

34 {

35 case DiceNames.SEVEN: // win with 7 on first roll

36 case DiceNames.YO_LEVEN: // win with 11 on first roll

37 gameStatus = Status.WON;

38 break;

39 case DiceNames.SNAKE_EYES: // lose with 2 on first roll

40 case DiceNames.TREY: // lose with 3 on first roll

41 case DiceNames.BOX_CARS: // lose with 12 on first roll

42 gameStatus = Status.LOST;

43 break;

44 default: // did not win or lose, so remember point

45 gameStatus = Status.CONTINUE; // game is not over

46 myPoint = sumOfDice; // remember the point

47 Console.WriteLine( "Point is {0}", myPoint );

48 break;

49 } // end switch

Outline

Craps.cs

(2 of 4)

Call RollDice method

Player wins with a roll of 7 or 11

Player loses with a roll of 2, 3 or 12

Set and display the point

56


50

51 // while game is not complete

52 while ( gameStatus == Status.CONTINUE ) // game not WON or LOST

53 {

54 sumOfDice = RollDice(); // roll dice again

55

56 // determine game status

57 if ( sumOfDice == myPoint ) // win by making point

58 gameStatus = Status.WON;

59 else

60 // lose by rolling 7 before point

61 if ( sumOfDice == ( int ) DiceNames.SEVEN )

62 gameStatus = Status.LOST;

63 } // end while

64

65 // display won or lost message

66 if ( gameStatus == Status.WON )

67 Console.WriteLine( "Player wins" );

68 else

69 Console.WriteLine( "Player loses" );

70 } // end method Play

Outline

Craps.cs

(3 of 4)

Call RollDice method

Player wins by making the point

Player loses by rolling 7

Display outcome

57


71

72 // roll dice, calculate sum and display results

73 public int RollDice()

74 {

75 // pick random die values

76 int die1 = randomNumbers.Next( 1, 7 ); // first die roll

77 int die2 = randomNumbers.Next( 1, 7 ); // second die roll

78

79 int sum = die1 + die2; // sum of die values

80

81 // display results of this roll

82 Console.WriteLine( "Player rolled {0} + {1} = {2}",

83 die1, die2, sum );

84 return sum; // return sum of dice

85 } // end method RollDice

86 } // end class Craps

Outline

Craps.cs

(4 of 4)

Generate two dice rolls

Declare RollDice method

Display dice rolls and their sum

58


1 // Fig. 7.10: CrapsTest.cs

2 // Application to test class Craps.

3 public class CrapsTest

4 {


6 {

7 Craps game = new Craps();

8 game.Play(); // play one game of craps

9 } // end Main

10 } // end class CrapsTest Player rolled 2 + 5 = 7 Player wins Player rolled 2 + 1 = 3 Player loses

Outline

CrapsTest.cs

(1 of 2)

59


Outline

CrapsTest.cs

(2 of 2)

Player rolled 4 + 6 = 10 Point is 10 Player rolled 1 + 3 = 4 Player rolled 1 + 3 = 4 Player rolled 2 + 3 = 5 Player rolled 4 + 4 = 8 Player rolled 6 + 6 = 12 Player rolled 4 + 4 = 8 Player rolled 4 + 5 = 9 Player rolled 2 + 6 = 8 Player rolled 6 + 6 = 12 Player rolled 6 + 4 = 10 Player wins Player rolled 2 + 4 = 6 Point is 6 Player rolled 3 + 1 = 4 Player rolled 5 + 5 = 10 Player rolled 6 + 1 = 7 Player loses

60



Use only uppercase letters in the names of constants. This makes the constants stand out in an application and reminds you that enumeration constants are not variables.

61



Using enumeration constants (like Status.WON, Status.LOST and Status.CONTINUE) rather than literal integer values (such as 0, 1 and 2) can make code easier to read and maintain.

62


6.11 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 local variable or parameter in a method that has the same name as a field of a class is hidden until the block terminates execution

63



Use different names for fields and local variables to help prevent subtle logic errors that occur when a method is called and a local variable of the method hides a field of the same name in the class.

64


1 // Fig. 7.11: Scope.cs

2 // Scope class demonstrates instance and local variable scopes.

3 using System;

4

5 public class Scope

6 {

7 // instance variable that is accessible to all methods of this class

8 private int x = 1;

9

10 // method Begin creates and initializes local variable x

11 // and calls methods UseLocalVariable and UseInstanceVariable

12 public void Begin()

13 {

14 int x = 5; // method's local variable x hides instance variable x

15

16 Console.WriteLine( "local x in method Begin is {0}", x );

17

18 // UseLocalVariable has its own local x

19 UseLocalVariable();

20

21 // UseInstanceVariable uses class Scope's instance variable x

22 UseInstanceVariable();

23

24 // UseLocalVariable reinitializes its own local x

25 UseLocalVariable();

26

27 // class Scope's instance variable x retains its value

28 UseInstanceVariable();

Outline

Scope.cs

(1 of 2)

Display value of local variable x

Shadows field x

65


29

30 Console.WriteLine( "\nlocal x in method Begin is {0}", x );

31 } // end method Begin

32

33 // create and initialize local variable x during each call

34 public void UseLocalVariable()

35 {

36 int x = 25; // initialized each time UseLocalVariable is called

37

38 Console.WriteLine(

39 "\nlocal x on entering method UseLocalVariable is {0}", x );

40 x++; // modifies this method's local variable x

41 Console.WriteLine(

42 "local x before exiting method UseLocalVariable is {0}", x );

43 } // end method UseLocalVariable

44

45 // modify class Scope's instance variable x during each call

46 public void UseInstanceVariable()

47 {

48 Console.WriteLine( "\ninstance variable x on entering {0} is {1}",

49 "method UseInstanceVariable", x );

50 x *= 10; // modifies class Scope's instance variable x

51 Console.WriteLine( "instance variable x before exiting {0} is {1}",

52 "method UseInstanceVariable", x );

53 } // end method UseInstanceVariable

54 } // end class Scope

Outline

Scope.cs

(2 of 2)

Shadows field x

Display value of local variable x

Display value of field x

66


1 // Fig. 7.12: ScopeTest.cs

2 // Application to test class Scope.

3 public class ScopeTest

4 {

5 // application starting point


7 {

8 Scope testScope = new Scope();

9 testScope.Begin();

10 } // end Main

11 } // end class ScopeTest local x in method Begin is 5 local x on entering method UseLocalVariable is 25 local x before exiting method UseLocalVariable is 26 instance variable x on entering method UseInstanceVariable is 1 instance variable x before exiting method UseInstanceVariable is 10 local x on entering method UseLocalVariable is 25 local x before exiting method UseLocalVariable is 26 instance variable x on entering method UseInstanceVariable is 10 instance variable x before exiting method UseInstanceVariable is 100 local x in method Begin is 5

Outline

ScopeTest.cs

67


7.12 Method Overloading

• 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

68


1 // Fig. 7.13: MethodOverload.cs

2 // Overloaded method declarations.

3 using System;

4

5 public class MethodOverload

6 {

7 // test overloaded square methods

8 public void TestOverloadedMethods()

9 {

10 Console.WriteLine( "Square of integer 7 is {0}", Square( 7 ) );

11 Console.WriteLine( "Square of double 7.5 is {0}", Square( 7.5 ) );

12 } // end method TestOverloadedMethods

13

14 // square method with int argument

15 public int Square( int intValue )

16 {

17 Console.WriteLine( "Called square with int argument: {0}",

18 intValue );

19 return intValue * intValue;

20 } // end method Square with int argument

21

22 // square method with double argument

23 public double Square( double doubleValue )

24 {

25 Console.WriteLine( "Called square with double argument: {0}",

26 doubleValue );

27 return doubleValue * doubleValue;

28 } // end method Square with double argument

29 } // end class MethodOverload

Outline

MethodOverload.cs

Correctly calls the “Square of int” method

Correctly calls the “Square of double” method

Declaring the “Square of int” method

Declaring the “Square of double” method

69


1 // Fig. 7.14: MethodOverloadTest.cs

2 // Application to test class MethodOverload.

3 public class MethodOverloadTest

4 {


6 {

7 MethodOverload methodOverload = new MethodOverload();

8 methodOverload.TestOverloadedMethods();

9 } // end Main

10 } // end class MethodOverloadTest Called square with int argument: 7 Square of integer 7 is 49 Called square with double argument: 7.5 Square of double 7.5 is 56.25

Outline

MethodOverload.cs

70


1 // Fig. 7.15: MethodOverload.cs

2 // Overloaded methods with identical signatures

3 // cause compilation errors, even if return types are different.

4 public class MethodOverloadError

5 {

6 // declaration of method Square with int argument

7 public int Square( int x )

8 {

9 return x * x;

10 }

11

12 // second declaration of method Square with int argument

13 // causes compilation error even though return types are different

14 public double Square( int y )

15 {

16 return y * y;

17 }

18 } // end class MethodOverloadError

Outline

MethodOverload.cs

Same method signature

Compilation error

71



Declaring overloaded methods with identical parameter lists is a compilation error regardless of whether the return types are different.

72


7.13 Recursion

• Recursion– A method that calls itself

– Break the problem you want to solve into pieces

– Recursive method consists of:• Base case(s)

- Solving simple problem

• Recursive call(s)

- Also known as recursion step(s)

- Normally includes a return statement

73


Fig. 7.16 | Recursive evaluation of 5!.

74


1 // Fig. 7.17: FactorialTest.cs

2 // Recursive Factorial method.

3 using System;

4

5 public class FactorialTest

6 {


8 {

9 // calculate the factorials of 0 through 10

10 for ( long counter = 0; counter <= 10; counter++ )

11 Console.WriteLine( "{0}! = {1}",

12 counter, Factorial( counter ) );

13 } // end method Main

Outline

FactorialTest.cs

(1 of 2)

Call recursive method

75


14

15 // recursive declaration of method Factorial

16 public static long Factorial( long number )

17 {

18 // base case

19 if ( number <= 1 )

20 return 1;

21 // recursion step

22 else

23 return number * Factorial( number - 1 );

24 } // end method Factorial

25 } // end class FactorialTest

0! = 1 1! = 1 2! = 2 3! = 6 4! = 24 5! = 120 6! = 720 7! = 5040 8! = 40320 9! = 362880 10! = 3628800

Outline

FactorialTest.cs

(2 of 2)

static method header declaration

Base case: number <= 1 (ends recursion)

Recursive call

76



Either omitting the base case or writing the recursion step incorrectly so that it does not converge on the base case will cause infinite recursion, eventually exhausting memory. This error is analogous to the problem of an infinite loop in an iterative (nonrecursive) solution.

77


7.14 Passing Arguments: Pass-by-Value vs. Pass-by-Reference

• Argument pass by value– Copy of value is made and passed into the function

– Changes to the copy does not affect the original value (unless it is a reference type)

• Argument pass by reference– Gives the method the ability to access and modify original

variable

– Objects always passed by reference

– To pass value by reference:• ref: For initialized variables

• out: For uninitialized variables

78


Performance Tip 7.1

Pass-by-reference is good for performance reasons, because it can eliminate the pass-by-value overhead of copying large amounts of data.

79



Pass-by-reference can weaken security, because the called function can corrupt the caller’s data.

80


1 // Fig. 7.18: ReferenceAndOutputParameters.cs

2 // Reference, output and value parameters.

3 using System;

4

5 class ReferenceAndOutputParameters

6 {

7 // call methods with reference, output and value parameters

8 public void DemonstrateReferenceAndOutputParameters()

9 {

10 int y = 5; // initialize y to 5

11 int z; // declares z, but does not initialize it

12

13 // display original values of y and z

14 Console.WriteLine( "Original value of y: {0}", y );

15 Console.WriteLine( "Original value of z: uninitialized\n" );

16

17 // pass y and z by reference

18 SquareRef( ref y ); // must use keyword ref

19 SquareOut( out z ); // must use keyword out

20

21 // display values of y and z after they are modified by

22 // methods SquareRef and SquareOut, respectively

23 Console.WriteLine( "Value of y after SquareRef: {0}", y );

24 Console.WriteLine( "Value of z after SquareOut: {0}\n", z );

25

26 // pass y and z by value

27 Square( y );

28 Square( z );

Outline

ReferenceAndOutputParameters.cs

(1 of 2)

The declaration of local variables that are being passed by reference

Passes y with the ref keyword since the variable is initialized

Pass y and z by value

Passes z with the out keyword since the variable is not initialized

81


29

30 // display values of y and z after they are passed to method Square

31 // to demonstrate arguments passed by value are not modified

32 Console.WriteLine( "Value of y after Square: {0}", y );

33 Console.WriteLine( "Value of z after Square: {0}", z );

34 } // end method DemonstrateReferenceAndOutputParameters

35

36 // uses reference parameter x to modify caller's variable

37 void SquareRef( ref int x )

38 {

39 x = x * x; // squares value of caller's variable

40 } // end method SquareRef

41

42 // uses output parameter x to assign a value

43 // to an uninitialized variable

44 void SquareOut( out int x )

45 {

46 x = 6; // assigns a value to caller's variable

47 x = x * x; // squares value of caller's variable

48 } // end method SquareOut 49 50 // parameter x receives a copy of the value passed as an argument,

51 // so this method cannot modify the caller's variable

52 void Square( int x )

53 {

54 x = x * x;

55 } // end method Square

56 } // end class ReferenceAndOutputParameters

Outline

ReferenceAndOutputParameters.cs

(2 of 2)

Assignments are saved since arguments was passed by reference

Modifications are disregarded since the argument was passed by value

82


1 // Fig. 7.19: ReferenceAndOutputParamtersTest.cs

2 // Application to test class ReferenceAndOutputParameters.

3 class ReferenceAndOutputParamtersTest

4 {

5 static void Main( string[] args )

6 {

7 ReferenceAndOutputParameters test =

8 new ReferenceAndOutputParameters();

9 test.DemonstrateReferenceAndOutputParameters();

10 } // end Main

11 } // end class ReferenceAndOutputParamtersTest

Original value of y: 5 Original value of z: uninitialized

Value of y after SquareRef: 25 Value of z after SquareOut: 36

Value of y after Square: 25 Value of z after Square: 36

Outline

ReferenceAndOutputParamtersTest.cs

83



The ref and out arguments in a method call must match the parameters specified in the method declaration; otherwise, a compilation error occurs.

84



By default, C# does not allow you to choose whether to pass each argument by value or by reference. Value-types are passed by value. Objects are not passed to methods; rather, references to objects are passed to methods. The references themselves are passed by value. When a method receives a reference to an object, the method can manipulate the object directly, but the reference value cannot be changed to refer to a new object. In Section 8.8, you’ll see that references also can be passed by reference.

85


7.15 (Optional) Software Engineering Case Study: Identifying Class Operations in the ATM System• Identifying operations

– Examine key verbs and verb phrases in the requirements document

• Modeling operations in UML– Each operation is given an operation name, a parameter

list and a return type:• operationName( parameter1, parameter2, …, parameterN ) : return type

• Each parameter has a parameter name and a parameter type

- parameterName : parameterType

86


7.15 (Optional) Software Engineering Case Study: Identifying Class Operations in the ATM System (Cont.)

– Some operations may not have return types yet• Remaining return types will be added as design and

implementation proceed

• Identifying and modeling operation parameters– Examine what data the operation requires to perform its

assigned task

– Additional parameters may be added later on

87


Fig. 7.20 | Verbs and verb phrases for each class in the ATM system.

Class Verbs and verb phrases

ATM executes financial transactions

BalanceInquiry [none in the requirements document]

Withdrawal [none in the requirements document]

Deposit [none in the requirements document]

BankDatabase authenticates a user, retrieves an account balance, credits an account, debits an account

Account retrieves an account balance, credits a deposit amount to an account, debits a withdrawal amount to an account

Screen displays a message to the user

Keypad receives numeric input from the user

CashDispenser dispenses cash, indicates whether it contains enough cash to satisfy a withdrawal request

DepositSlot receives a deposit envelope

88


Fig. 7.21 | Classes in the ATM system with attributes and operations.

89


Fig. 7.22 | Class BankDatabase with operation parameters.

90


Fig. 7.23 | Class Account with operation parameters.

91


Fig. 7.24 | Class Screen with an operation parameter.

92


Fig. 7.25 | Class CashDispenser with operation parameters.

2006 Pearson Education, Inc. All rights reserved. 1 7 7 Methods: A Deeper Look.

Documents

Transcript of 2006 Pearson Education, Inc. All rights reserved. 1 7 7 Methods: A Deeper Look.