6. Methods
Objectives:
To understand how
parameters are passed
into methods and how
values are returned
from methods
To understand the
difference between
instance methods and
static methods
To introduce the
concept of static
variables; the scope of
variables
To be able to program
recursive methods
Method Parameters
public class
BankAccount
{ …public void deposit
(double amount)
{ …
}
...
}
This method has two
formal parameters:
implicit parameter this;
explicit parameter
amount
myChecking.deposit
(allowance-200);
this = myChecking;
amount = allowance –
200;
Parameters
The parameter amount
is called an explicit
parameter because it
is explicitly named in
the method definition.
The parameter this
(the bank account
reference) is called an
implicit parameter
because it is not
explicit in the method
definition.
When you call a
method, you supply the
value for the implicit
parameter before the
method name,
separated by a dot (.),
and you supply the
values for the explicit
parameters inside
parentheses after the
method name:
implicitParameter.
methodName
(explicitParameter);
myChecking.deposit
(allowance - 200);
This method Call,
supply two actual
parameters or
arguments.
The object reference
stored in the variable
myChecking.
The value of the
expression allowance
– 200.
When a method is
called, the actual
parameter values are
computed and copied
into the formal
parameter variables.
public class
BankAccount
{… public void transfer
(BankAccount other,
double amount)
{ withdraw(amount);
other.deposit(amount);
}…
}
For example,
double allowance =
800;
momsSaving.transfer
(myChecking,
allowance);
this = momsSaving;
double allowance =
800;
momsSaving.transfer
(myChecking,
allowance);
Accessor Methods &
Mutator Methods
A method that
accesses an object
and returns some
information without
changing the object is
called an accessor
method.
For example, in the
BankAccount class,
getBalance is an
accessor method.
A method that
modifies the state of
an object is called a
mutator method.
For example, the
deposit/withdraw
methods are mutator
methods.
Static Methods
A static method or a
class method is a
method that does not
need an implicit
parameter.
A method that needs
implicit parameter is
called an instance
method because it
operates on a
particular instance of
an object.
For example, the sqrt
of the Math class is a
static method because
we don’t need to
supply any implicit
parameter.
The reason that we
want to write a static
method is because we
want to encapsulate
some computations
that involves only
numbers.
Static Method
Two floating-point
numbers x and y are
approximately equal
ifThe parameters are
only numbers and the
method doesn’t
operate on any objects
so we can make it into
a static method:
class Numeric
{ public static boolean
approxEqual(double x,
double y)
{ final double EPSILON
= 1E-14;
double xymax =
Math.max(Math.abs(x),
Math.abs(y));
return Math.abs(x - y)
<= EPSILON * xymax;
}…
}
Static Method
When calling the static
method, you supply the
name of the class
containing the method:
double r = Math.sqrt(2);
if
(Numeric.approxEqual
( r*r, 2))
System.out.println
(“Math.sqrt(2) squared
is apporx 2”);
The main method is
static because when
the program starts,
there isn’t any objects
yet.
The static method
means “class method”.
Call by Value/Call by
Reference
Trying to modify
numeric parameters
public static void
updateBalance(double
balance, double intRate)
{ double interest = balance
* intRate / 100;
balance = balance +
interest;
}
public static void main
(String[] args)
{ double savings = 10000,
rate = 5;
updateBalance(savings,
rate);
// savings is not updated
….
}
A method can modify
the state of object
parameters
public static void
updateBalance
(BankAccount account,
double intRate)
{ double interest =
account.getBalance() *
intRate / 100;
account.deposit
(interest);
}
public static void main
(String[] args)
{ BankAccount
collegeFund = new
BankAccount(10000);
double rate = 5;
updateBalance
(collegeFund, rate);
…
}
“numbers are passed
by value, objects are
passed by referece” is
not quite correct.
public static void
chooseAccount
(BankAccount
betterAccount,
BankAccount
candidate1,
BankAccount
candidate2)
{ if
(candidate1.getBalance
() >
candidate2.getBalance
())
betterAccount =
candidate1;
else
betterAccount =
candidate2;
}
public static void main
(String[] args)
{ BankAccount
collegeFund = new
BankAccount(10000);
BankAccount momAcc
= new BankAccount
(8000);
BankAccount
myAccount = null;
chooseAccount
(myAccount, momAcc,
collegeFund); // ?
…
}
public static
BankAccount
chooseAccount
(BankAccount
candidate1,
BankAccount
candidate2)
{ BankAccount
betterAccount;
if
(candidate1.getBalance
() >
candidate2.getBalance
())
betterAccount =
candidate1;
else
betterAccount =
candidate2;
return betterAccount;
}
public static void main
(String[] args)
{ BankAccount
collegeFund = new
BankAccount(10000);
BankAccount momAcc
= new BankAccount
(8000);
BankAccount
myAccount;
myAccount =
chooseAccount
(momAcc,
collegeFund); // ?
…
}
The return Statement
A method that has a
return type other than
void must return a
value, by executing
return expression;
Missing Return Value
public static int sign
(double x)
{ if (x < 0) return -1;
if (x > 0) return +1;
// Error: missing return
value if x == 0
}
Static Variables
public class
BankAccount
{ private double
balance;
private int
accountNumber;
private int
lastAssignedNumber;
}
public class BankAccount
{ private double balance;
private int
accountNumber;
privatestatic int
lastAssignedNumber;
}
How to initialize static
variables?
public BankAccount( )
{ lastAssignedNumber =
0; // ?
…
}
public class
BankAccount
{ … private static int
lastAssingedNumber =
0;
}
public class Math
{ … public static final
double PI = 3.
141592653589793238
456;
}
Math.PI
Static variable is
initialized with 0 (for
numbers), false (for
boolean), null (for
objects).
Variable Lifetime and
Scope
Four kinds of variables:
Instance variables,
Static variables, Local
variables, and
Parameter variables.
public void withdraw
(double amount)
{ if (amount <=
balance)
{ double newBalance =
balance - amount;
balance = newBalance;
}
}
Shadowing
public class Coin
{ public Coin(double
aValue, String aName)
{ value = aValue;
String name =
aName; // local
variable
}
…
private double value;
private String name; //
instance variable
public Coin(String
name, double value)
{ this.name = name;
this.value = value;
}
Calling One
Constructor from
Another
public class
BankAccount
{ public BankAccount
(double initialBalance)
{ balance =
initialBalance;
}
public BankAccount()
{ this(0);
}
}
Comments
/**
Computes the maximum
of two integers.
@param x an integer
@param y another
integer
@return the larger of the
two inputs
*/
public static int max(int x,
int y)
{ if (x > y)
return x;
else
return y;
}
javadoc MyProg.java
Recursion
public static int
factorial(int n)
{ if (n == 0)
return 1;
else
{ int result = n *
factorial(n - 1);
return result;
}
}
Exercise
Write an application
using classes and
methods to draw a fan
and to make its pedals
rotated
Thursday, June 30, 2011
lesson 6-methods
11:13 AM
Ravi mishra
No comments
0 comments:
Post a Comment