This chapter reviews method parameters and local variables, as well as method overloading and method signature. Method overloading means two or more methods have the same name but have different parameter lists: either a different number of parameters or different types of parameters. When a method is called, the corresponding method is invoked by matching
the arguments in the call to the parameter lists of the methods. The name together with the number and types of a method's parameter list is called the signature of a method. The return type itself is not part of the signature of a method. Although it is usually a bad idea, you can declare a formal parameter
or a local variable with the same name as one of the instance variables. This is not a syntax error (although it will probably result in a logic error, a bug). The compiler will compile this code without complaint. The second declaration of balance (the one in red) creates a local variable for the processDeposit method. The scope of this variable starts with its declaration and ends at the end of the block (as with all local variables). So the next statement uses the local variable, not the instance
variable. The local variable balance is said to shadow the instance variable. When this modified method is called, it will add amount to the local variable balance, and then return to the caller. The local variable will no longer hold a value after the method has returned. The instance variable will not have been changed. Hint: Think of statements as looking "upward" from their own location inside
their "glass box" to find a variable. If they find a variable inside their box (scope), that is the one they use. An instance variable of the same name will have been shadowed. They can look outside of their "glass box" in any direction if they fail to find a variable inside their own method. You need to be careful if you use the same name for an instance variable and for a local variable. But it is not a syntax error, so the compiler will not warn you of impending doom.11. Instance Variable and Local Variable with Same Name
Answer:
Yes — the scopes will not overlap so there will be two local variables, one per method,
each with the same name.Instance Variable and Local Variable
with Same Name
class CheckingAccount
{
. . . .
private int balance;
. . . .
public void processDeposit( int amount )
{
int balance = 0; // New declaration of balance.
balance = balance + amount ; // This uses the local variable, balance.
}
}
Question 11:
Examine this modification:public class CheckingAccount { . . . . private int balance; . . . . public void processDeposit( int amount ) { int balance = 0; // New declaration of balance. this.balance = balance + amount ; // ?????? } } |
1.14. Defining Two or More Methods with the Same Name
Problem
You would like to implement two or more methods with the same name in one object. In object-oriented programming, this is called method overloading. However, in Objective-C, method overloading does not exist in the same way as it does in other programming languages such as C++.
Solution
Use the same name for your method, but keep the number and/or the names of your parameters different in every method:
- (void) drawRectangle{ [self drawRectangleInRect:CGRectMake(0.0f, 0.0f, 4.0f, 4.0f)]; } - (void) drawRectangleInRect:(CGRect)paramInRect{ [self drawRectangleInRect:paramInRect withColor:[UIColor blueColor]]; } - (void) drawRectangleInRect:(CGRect)paramInRect withColor:(UIColor*)paramColor{ [self drawRectangleInRect:paramInRect withColor:paramColor andFilled:YES]; } - (void) drawRectangleInRect:(CGRect)paramInRect withColor:(UIColor*)paramColor andFilled:(BOOL)paramFilled{ /* Draw the rectangle here */ }This example shows a typical pattern in overloading. Each rectangle can be drawn either filled (solid color) or empty (showing just its boundaries). The first procedure is a “convenience procedure” that allows the caller to avoid specifying how to fill the rectangle. In our implementation of the first procedure, we merely call the second procedure, making the choice for the caller (andFilled:YES) The second procedure gives the caller control over filling.
Discussion
You can define two methods with the same name so long as they differ in the parameters they accept. One reasons for doing this is one function offers more customization (through parameterization) than the other function.
Method overloading is a programming language feature supported by Objective-C, C++, Java, and a few other languages. Using this feature, programmers can create different methods with the same name, in the same object. However, method overloading in Objective-C differs from that which can be used in C++. For instance, in C++, to overload a method, the programmer needs to assign a different number of parameters to the same method and/or change a parameter’s data type.
In Objective-C, however, you simply change the name of at least one parameter. Changing the type of parameters will not work:
- (void) method1:(NSInteger)param1{ /* We have one parameter only */ } - (void) method1:(NSString *)param1{ /* This will not compile as we already have a method called [method1] with one parameter */ }Changing the return value of these methods will not work either:
- (int) method1:(NSInteger)param1{ /* We have one parameter only */ return param1; } - (NSString *) method1:(NSString *)param1{ /* This will not compile as we already have a method called [method1] with one parameter */ return param1; }As a result, you need to change the number of parameters or the name of (at least) one parameter that each method accepts. Here is an example where we have changed the number of parameters:
- (NSInteger) method1:(NSInteger)param1{ return param1; } - (NSString*) method1:(NSString *)param1 andParam2:(NSString *)param2{ NSString *result = param1; if ([param1 length] > 0 && [param2 length] > 0){ result = [result stringByAppendingString:param2]; } return result; }Here is an example of changing the name of a parameter:
- (void) drawCircleWithCenter:(CGPoint)paramCenter radius:(CGFloat)paramRadius{ /* Draw the circle here */ } - (void) drawCircleWithCenter:(CGPoint)paramCenter Radius:(CGFloat)paramRadius{ /* Draw the circle here */ }Can you spot the difference between the declarations of these two methods? The first method’s second parameter is called radius (with a lowercase r) whereas the second method’s second parameter is called Radius (with an uppercase R). This will set these two methods apart and allows your program to get compiled. However, Apple has guidelines for choosing method names as well as what to do and what not to do when constructing methods. For more information, please refer to the “Coding Guidelines for Cocoa” Apple documentation available here.
Here is another example of two methods that draw a circle but have different names for their second parameter:
- (void) drawCircleWithCenter:(CGPoint)paramCenterPoint radiusInPoints:(CGFloat)paramRadiusInPoints{ /* Draw the circle here */ } - (void) drawCircleWithCenter:(CGPoint)paramCenterPoint radiusInMillimeters:(CGFloat)paramRadiusInMillimeters{ /* Draw the circle here */ }Here is a concise extract of the things to look out for when constructing and working with methods:
Have your method names describe what the method does clearly, without using too much jargon and abbreviations. A list of acceptable abbreviations is in the Coding Guidelines.
Have each parameter name describe the parameter and its purpose. On a method with exactly three parameters, you can use the word and to start the name of the last parameter if the method is programmed to perform two separate actions. In any other case, refrain from using and to start a parameter name. An example of the name of a method that performs two actions and uses the word and in its name is prefixFirstName:withInitials:andMakeInitialisUppercase:, where the method can prefix a first name (of type NSString) with the initials (of type NSString again) of that individual. In addition, the method accepts a boolean parameter named andMakeInitialsUppercase which, if set to YES, will prefix the first name with an uppercase equivalent of the initials passed to the method. If this parameter is set to NO, the method will use the initials it is given, without changing their case, to prefix the first name parameter.
Start method names with a lowercase letter.
For delegate methods, start the method name with the name of the class that invokes that delegate method.