cosc236 modularity1 top-down design design before code most programs so far have been simple, less...
TRANSCRIPT
COSC236 Modularity 1
Top-Down Design
• Design before code• most programs so far have been simple,
less than one page in length• most problems are not so simple• top-down design-identify first the major
tasks and then further subtasks within them
• stepwise refinement• divide and conquer
COSC236 Modularity 2
Procedural decomposition
• all tasks can be subdivided and further subdivided into subtasks
• goal - can easily construct code for each subtask
• each module constructed and tested as unit• Black box• Stubbing in (write dummy methods), always
have something working• Single entry, single exit• Short enough to be easily read and modified• Long enough top perform a single method
COSC236 Modularity 3
Procedural decomposition
• subroutines, subprograms, or procedures• In Java these subparts are called methods. • Advantages of using methods:
– Different people can work on different subtasks when producing very large programs.
– Block of code can be used more than once - the final program is more modular.
– Each method performs some task - can work as a black box
COSC236 Modularity 4
Methods - Overview
• Every Java program must have a method called main
• Program execution always begins with method main
• method definitions can occur in any order
COSC236 Modularity 5
2 types of methods in java
1. Predefined
2. User created– Value-returning– void
Math class> import static java.lang.Math.*;
> E
2.718281828459045
> PI
3.141592653589793
> sqrt (25)
5.0
> abs(-1)
1
> ceil (5.6)//double arg, returns smallest integer that is not less than x
6.0
> floor (5.6)//double arg, returns largest integer that is less than x
5.0
> log(2)
0.6931471805599453COSC236 Modularity 6
Math class> import static java.lang.Math.*;
> log10(2)
0.3010299956639812
> max(23.6,-4)
23.6
> min(23.6,-4)
-4.0
> pow(2,3)
8.0
> round(24.83)
25
> sqrt(1024)
32.0
> cos(0)
1.0COSC236 Modularity 7
Class Character• isDigit(ch) returns true or false
– isDigit(‘a’) returns false, isDigit(‘8’) returns true
• isLetter(ch) returns true or false– isLetter(‘a’) returns true, isLetter(‘8’) returns false
• isLowerCase(ch) returns true or false– isLowerCase(‘a’) returns true, isLowerCase(‘A’) returns false
• isUpperCase(ch) returns true or false– isUpperCase(‘A’) returns true, isUpperCase(‘a’) returns false
• isSpaceChar(ch) returns true or false– isSpaceChar(‘ ’) returns true, isSpaceChar(‘A’) returns false
• isWhiteSpace(ch) returns true or false– isWhiteSpace(‘ ’) returns true, isWhiteSpace(‘\n’) returns true
• toLowerCase(ch) returns lowercase equivalent or ch– toLowerCase(‘A’) returns ‘a’, toLowerCase(‘*’) returns *
• toUpperCase(ch) returns uppercase equivalent or ch– toUpperCase(‘a’) returns ‘A’, toUpperCase(‘*’) returns *
COSC236 Modularity 8
Using predefined methods
• Java automatically imports classes from the package java.lang
• Class methods can be static or nonstatic• Class methods can be public or nonpublic• A public and static method can be called using
the name of the class, the dot operator, the method name, and the appropriate parameters
• Exa: Math.methodName(parameters)• Math.pow(2.5,3.5);
COSC236 Modularity 9
Simpler use of public static methods
• Static import statements• To use any (public) static method of a class
– import static pkgName.ClassName.*;
• To use a specific method of the class– import static pkgName.ClassName.methodname;
• Allow omission of the class name and the dot operator
• import static java.lang.Math.*;• pow(2.5,3.5) as opposed to Math.pow(2.5,3.5);
COSC236 Modularity 10
User defined methods-value-returning
• requires1. Name of the method
2. The number of parameters
3. The data type of each parameter
4. The data type of the value computed (method type)
5. code
Use the value:• Save the value• Use the value• Print the value
COSC236 Modularity 11
Naming value-returning methods
• Should use a noun or an adjective and the name should suggest a value.
• Examples: maxScore
finalBalance square cube squareRootisPalindromeisValid
COSC236 Modularity 12
Example method
public static int abs (int number)
{
if (number < 0)
number = -number;
return number;
}
COSC236 Modularity 13
Invoking the method
• Save the value– y = abs(-2);
• Use the value– a = abs(x) + 25;
• Print the value– System.out.println(abs(h));
COSC236 Modularity 14
Parameters or arguments
• Data passed between methods• Formal parameter- variable declared in the method
heading (generalized parameter)• Actual parameter (argument) – variable or expression
listed in a call to a method– Could be constant
• Formal parameter and actual parameter names do not
have to match
COSC236 Modularity 15
Syntax: Value-returning method
modifier(s) returnType methodName(formal param list)
{Statements //body
}
• Modifier – visibility– public – can be accessed outside the class– private – cannot be used outside the class– static, abstract, final (more later)
COSC236 Modularity 16
Method syntax
• Syntax: Formal parameter list– dataType identifier, dataType identifier..– Can be empty
• Syntax: Method call– methodName(actual parameter list)
• Syntax: Actual parameter list– expr. or variable, expr. or variable,…
• The number of actual parameters, and their data types must match formal parameter list
COSC236 Modularity 17
return Statement
• Syntax: return statement– return expr;– Type must match return type of method
COSC236 Modularity 18
//version 1
public static double larger(double x, double y)
{
double max;
if (x >= y)
max = x;
else
max = y;
return max;
}COSC236 Modularity 19
// version 2
public static double larger(double x, double y)
{
if (x >= y)
return x;
else
return y;
}
//version 3
public static double larger(double x, double y)
{
if (x >= y)
return x;
return y;
}
COSC236 Modularity 20
Sample calls
• maxNum = larger(x,y);
• System.out.println(larger(a,b));
• result = larger(f,30) *3;
COSC236 Modularity 21
COSC236 Modularity 22
boolean methodpublic static void main(String[] args){ double angleA, angleB, angleC;
System.out.println ( "Enter 3 values for angles: "; console.nextDouble(angleA); console.nextDouble(angleB); console.nextDouble(angleC ); while(angleA <= 0 || angleB <= 0 || angleC <= 0) { System.out.println("ERROR! Should be positive. Reenter: “); console.nextDouble(angleA);
console.nextDouble(angleB);console.nextDouble(angleC);
} if (IsTriangle(angleA,angleB,angleC))//method call System.out.println("The three angles form a valid triangle.”); else System.out.println("These angles do not form a triangle.”);} // method definition public static boolean IsTriangle (float a, float b, float c){ //remember how to test for equality when working with float! return (fabs(a + b + c - 180.0) < 0.00000001); }
void methods
modifier(s) void methodName(formal param list)
{Statements
}
Call:
methodName(actual params);
COSC236 Modularity 23
COSC236 Modularity 24
Naming void methods
• Begin with verb
• make it look like a command or an instruction to the computer
• Example: printLines(), openFile(), getData(), printData(), generateArray(), etc.
COSC236 Modularity 25
Example #1:public class Banner{
public static void main (String[] args){
printStars(); System.out.println(“*******Annual *********”); printStars(); System.out.println(“***** Spring Sale *****”); printStars();
}//*********************************************************** // This method prints 2 lines with 30 stars each//*********************************************************** public static void printStars(){
for (int lines = 1; lines <= 2; lines ++) { for (int stars = 1; stars <= 30; stars++)
System.out.print(“*”); System.out.println(); } } }
public class Banner{
public static void main (String[] args){
printSymbol(‘!’, 2); System.out.println(“*******Annual *********”); printSymbol(‘*’,10); System.out.println(“***** Spring Sale *****”); printSymbol(‘!’,2);
}//*********************************************************** // This method prints numRows of 30 symbols//*********************************************************** public static void printSymbol(char symbol, int numRows){
for (int lines = 1; lines <= numRows; lines ++) { for (int cnt = 1; cnt <= 30; cnt++)
System.out.print(symbol); System.out.println(); } }
}
COSC236 Modularity 26
COSC236 Modularity 27
void method call methodName(actual parameter list);
• control passed to method at its definition in calling program
• temporary memory is set up (stores params and vars)• Begins with first statement in the called method’s body• Executes until return or } • control returns to the line following the method call• call must match number, order, data type of parameters • May have 0,1, or many parameters• Parentheses required• Multiple parameters are separated by commas
COSC236 Modularity 28
The return statement
• return 0; //not used with void methods • return; // returns no value
– valid ONLY with void methods– can appear anywhere in the body of the method– causes control to exit the method immediately and
transfers control back to caller. – Use in special cases only (the programs are
confusing, hard to follow and more difficult to debug). – Single-entry single-exit approach is generally better
COSC236 Modularity 29
EXAMPLE:public static void main(String[] args){ float roomLength,roomWidth;
System.out.println("Enter length and width" ); roomLenth = console.nextDouble(); roomWidth = console.nextDouble(); dispArea(roomLength,roomWidth);}public static void dispArea(float length, float width){ int area; area = length * width; System.out.println(“Area is “ + area);}
COSC236 Modularity 30
Example:
public static void main (String[] args){
int num1, num2;
System.out.println(“Enter two numbers” )num1 = console.nextInt();
num2 = console.nextInt();displaySum(num1,num2);System.out.println(“sum is “ + sum(num1,num2));
}public static void displaySum (int num1,int num2) // note the name begins with a verb{ int sum;
sum = num1 + num2; System.out.println(“sum is “ + sum);}public static int sum (int num1,int num2) // name is a noun{
int sum;
sum = num1 + num2;return sum; // return num1 + num2;
}
COSC236 Modularity 31
Scope of Identifiers• A variable can generally be used at any point after it has been
declared. The one exception to this rule is a variable declared in the control portion of a for loop, which can only be used within the loop. This is an example of scope, which identifies the range over which any identifier (e.g., variable or method) can be accessed. Each method is a block
• Block -set of statements enclosed within braces
• Any method can declare identifiers within its block. • The scope of a variable spans from the point where it is declared to
the end of the block where it was declared. • Once we reach the brace bracket that closes the block, the variable
can no longer be used.• Local identifiers = identifiers declared within a block and not
accessible outside of that block.
Consider the following code
public static void scopeSample (double a) // scope of a begins {
int b = 0; // scope of b begins
...
for (int c = 1; ...) // scope of c begins
{
int d = 2; // scope of d begins
...
} // scope of c,d ends
} // scope of a,b ends
As you can see, our method included one parameter. The scope of a parameter is the entire method that uses the parameter, just as the scope of the variable in the for loop is the entire loop.
COSC236 Modularity 32
Local variables
• A local variable is used to store information that is relevant for the duration of the execution of one method
• A local variable will exists as long as the method in which they have been created is still running
• As soon as the method terminates (i.e., returns), all the local variables defined inside the method are destroyed.
COSC236 Modularity 33
COSC236 Modularity 34
Scope of Identifiers• Each method is a block• Block -set of statements enclosed within braces
• Any method can declare identifiers within its block. • The scope of a variable spans from the point where it is declared to
the end of the block where it was declared. • Once we reach the brace bracket that closes the block, the variable
can no longer be used.• Local identifiers = identifiers declared within a block and not
accessible outside of that block. • Global variables = identifiers declared outside of all the methods in a
program • No nesting of methods• Within a method or a block, an identifier must be declared before it
can be used• Identifier can be declared anywhere inside a class• Cannot use same identifier name in the outer block and inner block
scope
• An identifier, declared within a method or block is accessible:– Only within the block from the point at which it is
declared until the end of the block– By those blocks that are nested within the blocks
for (int count = 1; count < 10; count++) System.out.println(count);
COSC236 Modularity 35
scope
• An identifier, x, declared within a class and outside every method’s definition– If x is declared static, then it can be accessed within
the method, assuming the method has no other identifier named x
– If x is not declared static, then it cannot be accessed within a static method
COSC236 Modularity 36
• Local identifiers exist only when the method is executing
• When the method is called (invoked) - memory space is created for its local identifiers
• When the method is finished (returns)- its local identifiers are destroyed .
COSC236 Modularity 37
COSC236 Modularity 38
• Example:
public static void main (String[] args){ int x,y;
x = 1; y = 2; System.out.println("x = " + x + " y = " + y); OutputX(); // method call OutputY(); // method call System.out.println("x = " + x + " y = " + y); return 0; } public static void OutputX(){ int x; // local variable
x = 3; System.out.println("x = " + x ); } public static void OutputY(){ int y; // local variable
y = 4; System.out.println(" y = " + y);
}
OutputX
x
OutputY
y
main
x
y
COSC236 Modularity 39
void vs value-returning
1. When returning more than one value or modify any of the caller's arguments - use void method
2. When I/O is required in the method - use void method 3. When returning just one value and the value is Boolean
- use value returning method4. When returning one value to be used immediately in an
expression - use value returning method5. When in doubt - use void. 6. If both void and value returning are acceptable, use the
one you prefer.
COSC236 Modularity 40
pass by value
• transfers a copy of the value of the actual parameter to a formal parameter.
• The method sees only this copy and cannot access the actual parameter itself.
• pass by value leads to two separate copies of the data: one in the actual parameter and one in the formal parameter.
• This protects the actual parameter from being modified
• Can also pass constants and arbitrary expressions to actual value parameter
• If formal argument is a primitive data type – pass by value
COSC236 Modularity 41
public class DemoPassByValue { public static void main(String[] args) { // Part I - primitive data types int i = 25; System.out.println(i); // print it (1) iMethod(i); System.out.println(i); // print it (3) System.out.println("-----------------"); } public static void iMethod(int iTest) { iTest = 9; // change it System.out.println(iTest); // print it (2) }}> java DemoPassByValue25925
Pass by reference
• formal parameter must be a reference parameter• reference variable contains address• use new to allocate memory for an object• pass variable=> actual and formal point to same address• changes to formal, change actual• useful:
– when you want to return more than one value– when the value of an actual object needs to be changed– when passing the address would save memory space and time
COSC236 Modularity 42
COSC236 Modularity 43
public class DemoPassByReference{ public static void main(String[] args) { // Part III - strings String s = "Java is fun!"; System.out.println(s); // print it (7) sMethod(s); System.out.println(s); // print it (9) } public static void sMethod(String sTest) { sTest = sTest.substring(8, 11); // change it System.out.println(sTest); // print it (8) }}
Java is fun!funJava is fun!
precaution with strings
• Remember - the String class is immutable• String str;• str = "hello"; str 1500 "hello"• str = "Hello There"; str 1800 "Hello There"• anytime you use assignment with a String
variable, new memory space is allocated• also, the String class has no methods that allow
you to change an existing string
COSC236 Modularity 44
COSC236 Modularity 45
public class DemoPassByReference { public static void main(String[] args) { // Part II - objects and object references StringBuffer sb = new StringBuffer("Hello, world"); System.out.println(sb); // print it (4) sbMethod(sb); System.out.println(sb); // print it (6) System.out.println("-----------------"); } public static void sbMethod(StringBuffer sTest) { sTest = sTest.insert(7,"cruel "); // change it System.out.println(sTest); // print it (8) }}
Hello, worldHello, cruel worldHello, cruel world
import java.awt.*;
public class DemoPassByReference
{
public static void main(String[] args)
{
Point p = new Point (1,2);
System.out.println(p);
testMethod(p);
System.out.println(p);
}
public static void testMethod(Point p)
{
System.out.println(p);
p.setLocation(3,4);
System.out.println(p);
}
}
COSC236 Modularity 46
COSC236 Modularity 47
Scope Rules
• Avoid (don't use) global data
• method name has global scope
• formal parameters are local to method.
• global variables visible from declaration to the end of the file.
• Local variable (or constant) scope extends from declaration to the end of the block where declared.
• local identifiers have name precedence.
Preconditions and Postconditions
• precondition – assertion describing everything that the
method requires to be true before method is invoked
• postcondition – describes the state at the moment the method
finishes executing
• the caller is responsible for ensuring the precondition, and the method code must ensure the postcondition
COSC236 Modularity 49
Testing and debugging - stubs and drivers
• Work Incrementally, Keep Something Working• Stub
– a dummy method with a very simple body– often just an output statement that this method was
reached, and a return value (if required) of the correct type.– same name and parameter list.
• Driver – a simple main method used to call a method that is being
tested. – Allows direct control of the testing process.
• Both stubs and drivers allow testing different situations and combinations that may reveal errors.
Introduction to Method Overloading
• methods with the same name, different formal parameter list or different return type
• public void methodXYZ()
• public void methodXYZ(int x, double y)
• public void methodXYZ(double one, int y)
• public void methodABC(int x, double y)
• public int methodABC(int x, double y)COSC236 Modularity 50
• int larger(int x, int y)
• char larger(char first, char second)
• double larger(double u, double v)
• String larger(String first, String second)
COSC236 Modularity 51