Arrays

Using arrays is a way to extend the storage of variables to include a list of values, instead of just a single value. It is a way for programmers to handle large quantity of data efficiently.

Arrays are specified using a square bracket (int marks[]) and individual elements in an array can be referred to by their index:

   marks[21] = 68;
  marks[14] = 79;

Because the index is just an integer value, we can always use a variable to represent the index so that we can parse through the array elements one by one.

   for(int i=0; i<marks.length; i++)
   {
      marks[i] = 0;
   }

Methods

Sorry for the non-update last week; was busy attending a conference.

The concept of methods is central to the OO (Object-oriented) methodology, and is also central to the understanding of any programming languages, since programming languages always comes with loads of pre-defined methods or functions (in the form of libraries) that programmers can use to simplify their programs.

As mentioned in the lecture, there are broadly 2 types of methods, the pre-defined ones and the ones that programmers write themselves within an application.

Java has loads of pre-defined methods that comes in packages and can be accessed at this URL (http://java.sun.com/j2se/1.5.0/docs/api/) for the JDK that we are using. You might not need it now, but the list will come in handy during your projects in later semesters when you need to write complicated Java programs.

For programmer-defined methods, you will need to remember to write the method header and method body (refer to Q1 of Lab 5), and to do a method call (refer to Q2 of Lab 5) in the main method so that the method gets executed.

Take note that the variables declared in a method is only valid within a method, and cannot be accessed outside a method. So if you used a variable num1 in a method findAverage(), you need to declare it in the method itself and not in main().

Repetition Structure

This week we continue with the 3rd control structure of programming, namely Repetition Structure.

Repetition structure is used to make certain portions of the program code run repeatedly, to achieve certain logic that you want. There are 3 Java statements to do repetition, while(), for() and do-while(). Refer to your lab 4 or the textbook for the syntax.

The characteristics for these loops are:

while() loop:

• this is a pre-test loop, meaning the condition is tested before going into the loop.
• for a counter-controlled loop, need to specify the starting value for the counter (int i = 0;), the continuation condition (while(i<5)) and the increment (i++;). The starting value is to be specified before the loop, and the increment is to be within the loop.
• for a sentinel-controlled loop, need to ensure that the value to be checked/compared against the sentinel value is being changed within the loop, either by some calculations, or by requesting input from the user.

for() loop:

• a for() loop works exactly the same as a counter-controlled while() loop by collecting all the 3 necessary statements and putting them together in the for() statement.
• a for() loop is particularly useful when we are dealing with arrays.

do-while() loop:

• a do-while() loop is a post-test loop, meaning the statements within the loop is ran first before the condition is checked/tested if the loop is to be repeated.
• the only difference between do-while() loop and while() loop is that statements are ran at least once for a do-while() loop, and statements may not be ran at all for a while() loop.
• for the while() statement in a do-while() loop, you need to put a semi-colon (;) at the end of the statement.
  

That's about the important things that you should take note.

More selection structure

Another selection structure which achieves multiple branching is the switch() structure. This structure is a multiple if() and the broadest use it to create a menu structure for a program.

switch(integer variable)
{
  case C1: //Write statements to do if variable == C1
           break;

  case C2: //Write statements to do if variable == C2
           break;

  default: //Write statements to do if variable is other values
}

Things to note for a switch() structure:

• it can only evaluate an integer value (including char)
  
• values for the cases are exact values and it does not allow range of values (e.g. C1 > 20)
• all cases should have a break statement to prevent statements from falling through
  

Selection structure

The Selection structure is primarily achieved by using the if() condition (flowchart attached below).


The if() condition allows branching of program codes based on a condition. The general structure looks like this:

if(condition)
{
  // Write statements to do if condition is true
}
else
{
  // Write statements to do if condition is false
}

We can also nest (put) if() conditions within another if() conditions to form complex logic for our programs. Do take care of the curly brackets, and always use tabs to indent the statements properly to aid debugging.

Things to note about if() conditions:

• an if() can have one and only one else or not at all
• a else must come with a if()
• if() conditions are independent of each other
  

Comparing Strings

As mentioned in the previous post, relational operators are meant for comparing variables declared in the primitive data types, and not strings. Since strings are objects of the String class, we need to use methods to perform the comparison.

We introduced 3 methods for comparing strings.

• compareTo() - This method compares 2 strings and returns an integer value. If the 2 strings are exactly the same (including the case), a 0 will be returned. Else, the method will return the difference between the 2 strings. Using the return value, we can use it to help us sort strings. Refer to Lab 3 for an example, which I will also elaborate in class.
• equals() - This method also compares 2 strings but returns only the boolean values TRUE (when the strings are exactly the same) or FALSE (when the strings are not the same).
• equalsIgnoreCase() - This method does the same thing as equals() but ignores the case.

We will be using these methods in Lab 3 and I hope it becomes clearer to you how the method works, when you get to use them in real programs.

As usual, leave comments if you have questions.

Comparing Numbers

In Java, we use relational operators (==, !=, >, <, >=, <=) to help us compare numbers, which are represented by variables of the 8 primitive data types. Take note that we cannot compare a string with a number; we can only compare (use the relational operators) variables declared in the primitive data types.

The common error that students always make when writing relational operators is to mixed up the double equal sign (==) which is to check if 2 values are the same, with the single equal sign (=) which is to assign a value to a variable.