1. Procedural programming in Java

2. Procedural programming in Java
A simple programming problem
Problem definition
A program is required which will take a string as a
command line argument of any length and determine
if the string represents a palindrome - i.e. a word which
reads the same backwards as forwards.
If the word is a palindrome, a message :-
<command line argument> is a palindrome
should be displayed. If not, the message should be :-
<command line argument> is not a palindrome
If the number of command line arguments is not equal
to 1 an error message should be displayed.

3. Procedural programming in Java
A simple programming problem
Program design
word : string * represents command line argument
length : integer *represents length of word
if there is one command line argument then
set word = command line argument
set length = length of word
for all characters at pos in the first half of the word
if char at pos not equal to char at length-pos then
exit for
end if
end for
if premature exit from loop then
display not a palindrome
else
display palindrome
display error message

4. Procedural programming in Java
A simple programming problem
Program code
public class Palindrome {
public static void main(String [] args) {
String word;
int length, pos = 0;
if ( args.length == 1 ) {
word = args[0]; length = word.length();
while ( pos <= length / 2) {
if ( word.charAt(pos) != word.charAt(length pos))
break;
pos++;
} //end while
if ( pos > length / 2 )
System.out.println(word + “ is a palindrome”);
else
System.out.println(word + “ is not a palindrome”);
} else
System.err.println(“One command line argument only”);
} //end main
} //end class Palindrome

5. Procedural Programming in Java
The square root algorithm
The square root of a number can be calculated by taking a series of estimates.
Each successive estimate is derived from the previous using the following
formula :-
new estimate = average of (old estimate + value/old estimate)
This can be expressed as pseudo-code as follows :-
value : integer *value who’s square root is required
e1 : real *first estimate
e2 : real *next estimate
e2 = value / *a crude way to start off with a first guess do
set e1 to e2
set e2 to (e1 + value/e1)/2
while positive difference between e1 and e2 > accuracy required
Note : In order to repeat the loop, the new estimate must become the old one
next time round. Hence the need for - set e1 to e2

6. Procedural Programming in Java
public class SquareRoot {
public static void main(String [] args) {
int value; double e1, e2;
value = Integer.parseInt(args[0]);
if (value > 0){ //now we can calculate square root
e2 = value / 2;
do {
e1 = e2;
e2 = (e1 + value / e1) / 2;}
while (Math.abs(e1 - e2) > );
System.out.println("Square root = " + e2);
} else
System.err.println("Only positive arguments allowed");
} //end main
} //end class SquareRoot
Implementation
of square-root
program

7. Procedural Programming in Java
Sub-programs in Java
It is not desirable or practicable to place all code in one main program.
As programs become larger and perhaps more people are working on them
simultaneously, it is necessary to subdivide the code into sub-programs.
These are called - subroutines (FORTRAN), procedures (PASCAL),
functions (C) or methods (Java), but all refer to sub-programs.
Use of methods allow you to :-
Subdivide a large program into smaller pieces - easier to understand.
Allow several people to work on different parts of the program at once.
Factor out commonly occurring pieces of code and write only once.
Avoid repetition and hence changes only made in one place.
Create sub-programs which can be re-used in other applications.
Minimise the amount of re-compilation when changes are made.

8. Procedural Programming in Java
Parameterless methods
public class Rabbit {
public static void main(String [] args) {
chatter(); //all methods must have a parameter
chatter(); //list () even if it is empty
chatter();
} //end main
public static void chatter(){
System.out.println(“Hello and welcome to Java”);
} //end chatter
} //end class Rabbit
Here, the method chatter() needs no additional information to do its job.
Hence, nothing is passed to it as parameters and nothing is returned.

9. Procedural Programming in Java
Method with parameters
In this version of chatter(), the method needs to be told how often to repeat
the message - the int repeat in the method header is a formal parameter,
the 2 * x and the 5 in the method calls are actual parameters.
public class Rabbit {
public static void main(String [] args) {
int x = 10;
chatter(2 * x); //here an actual value (parameter) is passed
chatter(5); //to tell the method how often to loop
} //end main
public static void chatter(int repeat){
for (int i = 0; i < repeat; i++)
System.out.println(“Hello and welcome to Java”);
} //end chatter
} //end class Rabbit

10. Procedural Programming in Java
Method with parameters
Here, chatter() needs to be told what to say and how often. Formal parameters
consist of lists of data type followed by name - int repeat, String message Actual parameters consist of a corresponding set of values - 5 , args[0]
public class Rabbit {
public static void main(String [] args) {
int x = 10;
chatter(x % 3, “Hello there”); //must send both repeat
chatter(5, args[0]); //amount and message string
} //end main
public static void chatter(int repeat, String message){
for (int i = 0; i < repeat; i++)
System.out.println(message);
} //end chatter
} //end class Rabbit

11. Procedural Programming in Java
Method which return results
Here, chatter() needs to be told what to say and how often. Formal parameters
consist of lists of data type followed by name - int repeat, String message Actual parameters consist of a corresponding set of values - 5 , args[0]
public class Rabbit {
public static void main(String [] args) {
int val = Integer.parseInt(args[0]);
System.out.println(“Square root = “ + squareRoot(val));
} //end main
public static double squareRoot(int value) {
double e1, e2 = value / 2; //local variables known only to method
do {
e1 = e2;
e2 = ( e1 + value / e1 ) / 2;}
while (Math.abs(e1 - e2) > 1.0e-5); //use of scientific notation
return e2; //result returned to calling program
} //end squareRoot
} //end class Rabbit

12. Important concept #1
Divide and Conquer: Break large programs into a series of smaller modules
Helps manage complexity
Makes it easier to build large programs
Makes it easier to debug programs

13. Important concept #2
Abstraction: Most of the time, you need to know what a method does, but not how it actually does it.
Also helps manage complexity
You use other people’s code without knowing how it does it’s job.

14. Methods Declarations Methods Allow programmers to modularize programs
Makes program development more manageable
Software reusability
Avoid repeating code
Local variables
Declared in method declaration
Parameters
Communicates information between methods via method calls

15. Method Declarations (cont.)
General format of method declaration: modifiers return-value-type method-name( parameter1, …, parameterN ) { declarations and statements }
Method can also return values:
return expression;

16. As with variables naming methods is important
Naming your methods
As with variables naming methods is important
You should give your methods names which clearly describe what the function is doing
helps debugging
helps others read your code
Same rules as naming variables
E.g. public static float calculateTax( int sale )
When you write about a method in an explanation use the parenthesis to indicate you are referencing a method (as opposed to a regular variable):
E.g. //call squareInteger() to calculate the square

17. Good programming with methods
A method should do one and only one useful action
If you see names for your method that suggest multiple actions then it’s time to break it up into separate functions; for example,
calculateTaxAndPrintReturnAndSaveFile(); -ugh
If you do something more than once in a program, you should write a method for that action.

18. More Good Programming
If you have written a method to do something in one project, and you need to do the same action in another project, you should reuse the method.
In Java this is usually accomplished by using classes which we will not cover this semester.