which is equivalent to saying:

There are also the increment and decrement operators, ++ and --. They are equivalent to saying +=1, and -=1, respectively. For example, to increment the value of a variable by 1, you can say:

When the ++ is put at the back, number2 receives the value of number1 first, and then number1 is incremented by 1. Then, when the ++ is put in the front, number1 is incremented first (since the ++ is in front) and then the new value is passed to number2. The first case is called the post-increment operator, and the second is called the pre-increment operator.

B. Arrays and Strings

Arrays

Arrays are an extension to variables and its usefulness will be seen later on. But it basically allows you to have a group of variables of the same data type with the same identifier. How, then, do you differentiate between the different variables? Well, that's where the index or key come into play. The index is a number used to reference a particular variable in an array. In Java and many other languages, an index value of 0 indicates the first variable in the array and an index value of 1 indicates the second variable, and so on. An array is declared in the following manner:

[] = new [];

The complex notation is due to the fact that Java arrays are what are called "objects," which we'll discuss further in the Object-Oriented Programming section.

For example we can do this:

int[] our_first_array = new int[10]; // creates integer array with 10 slots

This creates an array with 10 slots, thus able to fit 10 variables of type int. Then to initialize, for example, the first variable in the array we do this, and afterwards we can use it just like any other variable.

our_first_array[0] = 123; // intializes first slot of array
number3 = our_first_array[0] + number1;

To find out the length of a string, just use .length. For example, typing our_first_array.length will return the integer 10.

As you can see, initializing all slots of an array would become difficult when the array size is large. But we can actually automate the process using what are called "loops," which we'll discuss later.

Multi-dimensional Arrays

Multi-dimensional arrays, or arrays of arrays, can be implemented in a straightforward manner. For example, if you want a 2D 5-by-5 array, you would write:

Then, to work with the array, you just do the same as before, except now there are two indices (plural of index) you have to indicate. For example, test[4][4] refers to the last slot of the array.

You don't always have to specify the length of the arrays of your array. For example you can have an array of integer arrays of length 5 and length 7. To implement this, you just specify the first number when creating your array. Then you create each member array of the array one by one.

Strings

There is a special data type in Java called String (please note the capital S in String). It is not one of the primitive data types but somewhat acts like one. It is actually something called an object, which we'll discuss later. Usually in programming, a string refers to a group of characters, and so it shouldn't be surprising that in some languages, a string is implemented with an array of characters. However, this is not the case in Java, which includes a special string type that is simplified so that it can be used more or less like a primitive type. To create a string in Java, you would do the same as you create variables of primitive data types, like this:

Note that the text in a string is enclosed with double quotes (") while a char character is enclosed with single quotes ('). This is always the case for strings. Inside strings, you can also enclose the special characters using the unicode or escape sequences like '\n' for the newline symbol.

You can put two strings together by using the concatenation operator, which in Java is just the add sign (+).

Just like for arrays, to find out the length of your string, you can use .length.

Sometimes you might want to access a particular character in your string. For arrays, you could just put int the index with brackets [], but you can't do this for strings. Instead you have to use, charat(). For example, if you want to access the second character of text1 (the 'o'), you type text1.charat(1) (just like in arrays, you start with 0, not 1).

To compare and see if two strings are equal, you can NOT use the == operator. This is due to the way strings are really implemented in Java. In Java, the string variable doesn't really hold the characters, it refers to some other place in memory that contains the characters. Therefore, if you try to test two strings for equality using ==, you're testing if they refer to the same place in memory, which is frequently not the case even if the two strings represent the same characters. What you should use instead is Java's equals method. For example, to test if text1 is equal to text2, type:

You can also create arrays of strings in a similar fashion to arrays of integers and other primitive types.

C. Basic I/O (Input/Output)

Text Output in Java

One of the most first things people learn in a new programming language is how to output text to the screen and read characters from the keyboard. The output part is fairly simple in Java. To print something on the screen and a newline afterwards (so that when you output again, it will start on a new line), you simply type in:

System.out.println("your text!");

Be sure to enclose your text with double quotes "" as they are necessary. Later, when we talk about object-oriented programming, you'll understand the System.out.println part, but for now, just remember the syntax, and be sure to have the capitalization exactly the way it's printed or else it won't work. Note that for some "special" characters, like the ", you can't just type that in your code. Instead, to avoid confusion with other parts of code, you have to type in its Unicode value \u0022 or its escape sequence \".

If you ever want to print out the value of a variable, just attach it outside of the double quotes with a plus sign +, like this:

Be sure not to enclose the variable with double quotes. Doing that will print the variable name "myint" not its value.

If you don't want the newline symbol automatically attached, you can use:

If you ever want to manually put in the newline symbol, just use the escape sequence \n.

Basic Number Formatting (Optional Section)

Sometimes the number doesn't look good when you print it. It might have too many decimals or something. To format numbers in Java requires the use of classes, which we will discuss in more detail when we talk about Object-Oriented Programming, but for now, just follow these basic principles.

First, if you ever want to format text you have to put in the line import java.text.*; in the very beginning of your program, before everything else. Doing this tells Java to look up its prewritten libraries with the formatting instructions. Next, in your variable declarations, type in

For the char type, the comparision operators are almost identical. For example 'B'>'A' will return true while 'z'<'y' will return false. However, you should not mix up uppercase and lowercase letters as they are different. We encourage you try out some if tests to see the order of the characters. For example, are the uppercase letters "bigger" than the lowercase letters?

To combine multiple tests in one expression, you can use the "boolean operators." They are && (called AND), || (called OR), and ! (called NOT). If you connect two boolean expressions into one with the AND operator, the new expression will only return true if both original expressions are true. Similarly, the OR operator will return true only if either one or both of the expressions are true. The NOT operator negates the original value of the expression; hence, if it's originally true, the NOT will change the overall expression to false and if it's orignally false, NOT will change it to true.

For example, take a look at the following tests:

if ((myint >= 1)&&(myint <=; 10)) {
	System.out.println("myint ranges from 1 to 10");
}

if ((myint = 2)||(myint = 5)) {
	System.out.println("myint is either 2 or 5");
}

if (!(myint = 4)) {
  System.out.println("myint is not 4"); 
  // here we could have used != instead
}  
  

Switch statements

The switch statement can possibly be considered a more complex conditional structure. In it, you compare a single variable's value to a number of test values and do things accordingly if there is a match. The syntax is:

switch ()
{
  case :
    ;
    break; // this statement
    // quits the switch
	case :
    ;
    break; 
    ...
  default:
    ; 
    // these statements are executed 
    // if the interpreter gets to this point
    break; 
    // not necessary here, only 
    // put in for good programming habit
}

The syntax is more or less self-explanatory, but you have to be extra careful of the break statements. If you don't put them in after each case, the interpreter will continue to run the rest of the cases, including the default case, which can give you unwanted results. Why? Although running the other test cases would probably only slow the program, the default case, originally intended as an "otherwise do this" case, is actually run if the interpreter reaches it. Thus, if you don't put in the break's, your program could find a matching test case, execute the statements, and then continue on to the default case and execute those statements, too!

For example, try executing the following the program, setting myint equal to 2, with and without the break statements:

switch(myint)
{
  case 1:
    System.out.println("myint is 1");
    break;
  case 2:
    System.out.println("myint is 2");
    break;
  case 3:
    System.out.println("myint is 3");
    break;
  default:
    System.out.println("myint is neither 1, 2, or 3");
    break;
}

Loops/Iteration

As said before, loops allow repeated statements to be automated. In Java, there are primarly 3 different loop structures. The first is the for loop, which has the following syntax:

for (int i=0;i<10;i++) {
  System.out.println("The counter is now at "+i);
}

This program has the integer variable i as the counter. The first part initializes i to 0. The second part is the test, which tells the interpreter to test whether i is less than 10 after every cycle of the loop. The last part tells the interpreter to increment i by 1 after every cycle. Thus, the program will run a total of ten times (starting at 0, 1, 2... all the way to 9. When i is 10, the loop will no longer be executed since i<10 is false).

Another loop statement in Java is the while statement. While perhaps not as simple for in some cases, it is still very useful and has more versatility, unlike for which is very limited to iterative processes with a counter. while has the following syntax:

The while loop works like this: at the beginning of each cycle, the test expression is tested. If it is true, the interpreter goes on to run the statements in the loop, which should contain something to change whatever the test expression is testing. Otherwise, the test expression will always evaluate true and the loop never ends. This is in general bad programming practice and is called an infinite loop.

The following is an example of a while loop (note that the result is the same as the for loop code shown earlier):

Note the initialization has to be done outside of the loop. Otherwise, i will be set to 0 every time the loop executes and the loop will never end.

The last loop control flow structure in Java is the do-while. It works almost the same way as the while loop, with the following syntax.

The only difference between the two is that for the while loop, the test expression is tested before each execution of the statements, while for the do-while, the test expression is run after the statements are executed. While this might not seem to make a big difference, it does. If the test expression is false to begin with (even before the loop is executed once), the statements will not be executed in the while loop, but they will be run in the do-while loop one time.

In case you are wondering, the for statement, like the while statement, also checks the test expression before each cycle.

Using Loops to Initialize Arrays

We've said before that to avoid lots of repetitive code, we can use a loop to initialize an array. An example of how may be done is the following:

int[] myarray = new int[100];

for (int i=0;i<100;i++) {
  myarray[i]=0;
}

E. A Working Java Program

Now that we've got the basics down, the question we face is: how do we put them together into a Java program that compiles and runs? We can't simply put down our variable declarations and code, can we? In fact, we always have to put in some more or less generic code in our program for it to run properly. Instead of explaining it, we will just give a working example and then discuss the parts.

public class OurFirst  // required code
{
  public static void main (String args[]) // required 
  {
    int i;
    int[] MyArray = new int[10];
	
    for(i=0;i<10;i++) {
      MyArray[i] = i+1; // initializes MyArray
    }

    for(i=0;i<10;i++) {
      if (MyArray[i]%3==0) {	// check for remainder
        System.out.println("The number "+MyArray[i]+" 
                            IS divisible by 3");
      }
      else {
        System.out.println("The number "+MyArray[i]+" 
                            ISN'T divisible by 3");
      }
    }
  }
}

So what does this all mean? The first line public class OurFirst is required. Furthermore, the name there (OutFirst in our case) has to match the name of the java file (thus, our example will have to be saved as OurFirst.java).

The next statement, public static void main(String args[]), is also required. Anything inside of the "main" braces will be run.

To begin with, we declared our variables. Then, we initialized the array with a for loop. Afterwards, we have another for loop that runs through the array, printing out the value of each element and whether or not the number is divisible by 3 (remember that the % modulo operator gives the remainder. So if the remainder is 0, it is divisible).

Lastly, to end our program, we put in all the corresponding close braces (keep in mind that the number of open braces have to equal the number of close braces).

For simple programs, just write all code inside the "main" part. But as we'll discover in the next section, we can put code outside of "main."

F. Programming With Methods

Background History

Now we will learn about splitting up programs into sizeable parts. First we will tell a little history. In the early days of computer programs, the pioneer programmers would just write out all code in one big blob with what are called "gotos" to point from one line of code to another. Because of the unstructured and clumsy nature of programming this way, that kind of code has since been named "spaghetti code." To make programming more structured, people came up with what is called "procedural programming." The fundamental idea behind procedural programming is that we can split a big program into small parts, called procedures, which are neatly arranged and named for easy reference later. So, say we have some account balance program. We might split the program up into different procedures for depositing, withdrawal, etc. The advantage to procedural programming is that we can eliminate some of the former clumsiness. Furthermore, different people can work on different procedures or modules and then at the end combine all into the complete program. But perhaps most importantly, with procedural programming, if we want to modify our program later on, we can just take out the procedure that needs change and work only with that and not touch the other good code. Most programming languages of today support some form of procedural programming.

As promising as procedural programming was, it was not enough. Later on, people came up with what is called "Object-Oriented Programming" (OOP) that extends procedural programming into a new level. Java is one of the first major languages to be completely OOP-based.

So why should we still learn procedural programming, you ask? The reason is that procedural programming is actually part of the groundwork and a subset of OOP and is also very useful. However, one thing you have to keep in mind is that because Java is a completely OOP language, even as we program "procedures" we actually have to mask them with OOP code and terminology.

The Terminology

You will probably hear people use different names for procedures, depending on their programming background, ranging from "procedures" to "functions" to "methods" to "modules."

However, they are not precisely the same, according to the common computer terminology. Procedures are code that do something but do not return any data. Functions are like procedures but return data, usually the result of whatever function it performs. A method is the OOP (hence Java) term for both procedures and functions. Lastly, the word module is a relatively informal term that refers to procedures and functions or sometimes, a file containing many procedures and functions.

To stick with correct Java terminology, from now on we will use the word method to refer to this kind of code.

So How Do You Do It?

Remember the sacred "main" thing we mentioned earlier, where all the code is put inside? Well, it turns out, when you write a method, you DON'T put it inside of "main"! In fact, "main" itself is just another method, albeit a special one. Therefore, it shouldn't surprise you that methods we create will look a lot like "main." The exact syntax is:

(modifiers)   ((arg1_type arg1), 
                                 (arg2_type arg2)...))
{
	;
}

For the optional modifiers, just put public for now. We'll discuss its meaning when we talk about OOP. The return type, however, is not optional. Some methods "return" data after performing calculations and other processing, and so you have to put in what type of data (int, double, char, etc.)the method will return beforehand. Then, usually at the end of the method, you would return the value by saying:

The "somevalue" can be a literal but more likely a variable or expression. If your method does not return anything, then put the word void for the return type and don't worry about the return statement. Theoretically, you can also return an array. In that case, you will have to specify the return type with brackets [] in first line of the method. When returning the array, just type the array name with no brackets.

Some methods have what are called "arguments" or "parameters" (there is a slight difference between the terms though). That means they require some data to be passed to them when you "call" or use the method. For example, say you have a method that calculates the price of something after tax. Then, you might want the method to require the base price and tax rate as parameters so that people with different items and tax rates can all use the method.

With that said, let's write the AfterTax method.

public static double AfterTax (double price, 
                              double taxrate)
{
	double totalprice = 0;
	totalprice = price * (1 + taxrate/100.0);
	return totalprice;
}
  

Then, to use the method, you call it from, usually, another method, like main. To call it, you just type its name and the necessary parameters (if there are no parameters, then just put empty parentheses).

To sum up, here is an example of a complete program called Prices that contains and calls the AfterTax method. Note that we put AfterTax before main. Although the order does not matter in Java, it is convention to put main at the end of the program and all the manually-coded methods at the before it.

public class Prices{
	
  public static double AfterTax (double price, 
                                double taxrate)
  {
    double totalprice = 0;
    totalprice = price * (1 + taxrate/100.0);
    return totalprice;
  }
	
  public static void main(String args[])
  {
    double oldprice = 2.50, tax  = 7.5;
    double newprice = 0;
    newprice = AfterTax (oldprice, tax);
    System.out.println("The base price of the 
                        item is $"+oldprice);
    System.out.println("With a tax rate of "
                        +tax+"%,");
    System.out.println("The after tax price 
                        is $" + newprice);
  }
}

Arrays as Arguments

What if we want to pass a whole array as an argument? How can we implement that? Actually, it's very simple. All you have to do is when you write in the parameters of your method, put in the data type of your array with brackets [] following it to indicate that an array is to be passed to this method. For example, say you want to have a method that'll print out the elements of any integer array. You would write something like this: