Chapter 8
Methods

final void toggleStatus()

native Native methods are methods that you want to use, but do not want to write in Java. Native methods are most commonly written in C++, and can provide several benefits such as faster execution time. Like abstract methods, they are declared simply by placing the modifier native in front of the method declaration and by substituting a semicolon for the method body.

native void toggleStatus(); 

However, it is also important to remember that the declaration informs the compiler as to the properties of the method. Therefore, it is imperative that you specify the same return type and parameter list as can be found in the native code.

synchronized By placing the keyword synchronized in front of a method declaration, you can prevent data corruption that may result when two methods attempt to access the same piece of data at the same time. While this may not be a concern for simple programs, once you begin to use threads in your programs, this may become a serious problem.

synchronized void toggleStatus()

See "What Are Threads?" Chapter 13

Returning Information While returning information is one of the most important things a method can do, there is little to discuss by way of details about returning information. Java methods can return any data type ranging from simple ones, such as integers and characters, to more complex objects. (This means that you can return things such as strings as well.) Keep in mind that unless you use the keyword void as your return type, you must return a variable of the type specified in your declaration.

For example, the following method is declared to return a variable of type boolean. The return is actually accomplished by employing the return (either true or false) statement in the third and fourth lines.

public synchronized boolean isEmpty(int x, int y) {
   if (board[x][y] == EMPTY)
      return true;
   return false;
}

Method Name The rules regarding method names are quite simple and are the same as any other Java identifier: begin with a Unicode letter (or an underscore or dollar sign) and continue with only Unicode characters.

Parameter List Simply put, the parameter list is the list of information that will be passed to the method. It is in the form:

DataType VariableName, DataType VariableName,...

and can consist of as many parameters as you want.

Do note, however, that if you have no parameters, Java requires that you simply leave the parentheses empty. (This is unlike other languages that permit you to omit a parameter list, or C, which requires the keyword void.) Therefore, a method that took no parameters would have a declaration resembling:

public static final void cleanBoard()

Passing Parameters in Java
In C and C++, variables are always passed by value. In Pascal, they are always passed by reference. In Java, however, it depends on what data type you are using. This is probably the single most ambiguous part of the entire Java language. Here is the rule: If the type being passed is a primitive type (such as int, char, or float), then the result is passed by value. If, however, the type being passed is an Object (such as a class you created), the object is passed by reference.

So what does this mean? As shown in Listing 8.2, if you pass an int to a method and that method changes the int, in the old class the int still has the value it did before. However, when a class is passed and a variable is changed, the variable is changed in the old method, too. Take a look at Listing 8.3.

Listing 8.3PassingDemo.java--An Example that Demonstrates the Difference Between Passing an Object and a Primitive Type

public class passingDemo {
        public void first(){
                xObject o = new xObject ();
                o.x   = 5;
                int x = 5;
                o.x   = 5;
                int x = 5;
                changeThem (x, o);
                System.out.println();
                System.out.println("Back in the original method");
                System.out.println("The value of o.x is "+o.x)
                System.out.println("But, The value of x is now "+x);
        }
        public void changeThem (int x, xObject o){
                x =9;
                o.x = 9;
                System.out.println("In the changThem method")
                System.out.println("The value of o.x is "+o.x);
                System.out.println("The value of x is now "+x);
        }
        public static void main(String args[]){
                passingDemo myDemo = new passingDemo();
                myDemo.first()
        }
}
class xObject {
        public int x =5;
}

The resulting output from this code is:

In the changeThem method
The value of o.x is 9
The value of x is 9
Back in the original method
The value of o.x is 9
The value of x is 5

Blocks and Statements

Methods and static initializers in Java are defined by blocks of statements. A block of statements is a series of statements enclosed within curly-braces ({}). When a statement's form calls for a statement or substatement as a part, a block can be inserted in the substatement's place.

The simplest block {} is shown in the following example:

public void HiThere() {

}

The next example is only slightly more complex:

public void HiThere(){
    int Test;
    Test = 5;
}

Code blocks are not only integral for defining the start and end of a method, but they can also be used in a variety of locations throughout your code. One very important aspect of a block is that it is treated lexically as one instruction. This means that you can put together large blocks of code that will be treated as one instruction line.

There is nothing in the definition of Java that prevents the programmer from breaking code into blocks even though they are not specifically called for, but this is seldom done. The following code fragment demonstrates this legal but seldom-done technique:

String Batter;
Short Inning, Out, Strikes;
Batsman Casey;                         // Object of class Batsman.
...
if ((Inning == 9) && (Out==2) && (Batter.equals("Casey"))) {
   Casey.manner("ease");
   Casey.bearing("pride");
   {                                   // Begins new block for no reason.
      int OnlyExistsInThisBlock = 1;
      Casey.face("smile");
      Casey.hat("lightly doff");
   }                                   // Ends superfluous blocking.

}

Notice that this fragment contains two complete blocks. One is the substatement of the if statement, and the other is the unneeded block, which contains the unused integer OnlyExistsInThisBlock.

Labeled Statements

Any statement in Java can have a label. The actual label has the same properties as any other identifier; it cannot have the same name as a keyword or already declared local identifier. If it has the same name as a variable, method, or type name that is available to this block, then within that block, the new label takes precedence and that outside variable, method, or type is hidden. It has the scope of the current block. The label is followed by a colon.

Labels are only used by the break and continue Jump statements.

An example of labeled statements appears in the following code fragment:

writhing:
   Pitcher.GrindsBall("Hip");
   Casey.eye("Defiance Gleams");
   Casey.lip("Curling Sneer");
pitch:  while (strike++ < 2) {
      if (strike < 2) continue pitch;
         break writhing;
}

The statement, writhing, is simple labeling of an expression statement, in this case, a method call from a rather complicated object called Pitcher. The statement pitch is labeling an iteration statement (while). This label is used as a parameter for the continue statement.

Scope

Another use of blocks is to control what is known as the scope of an object. When you declare a variable, it is only available for your use within a given code block. For instance, say you had the following block:

{
   int x= 5;
}
System.out.println ("X is ="+x); // This line is not valid.

The last line of this code would not be valid, because the computer creates the x variable, but when the computer reaches the closing brace, it gets rid of x.

Separators

Separators are single-character tokens, which (as their name implies) are found between other tokens. There are nine separators, which are loosely described as follows:

(	Used both to open a parameter list for a method and to establish a precedence for operations in an expression.
)	Used both to close a parameter list for a method and to establish a precedence for operations in an expression.
{	Used to begin a block of statements or an initialization list.
}	Used to close a block of statements or an initialization list.
[	Precedes an expression used as an array index.
]	Follows an expression used as an array index.
;	Used both to end an expression statement and to separate the parts of a for statement.
,	Used as a list delimiter in many contexts.
.	Used both as a decimal point and to separate such things as package name from class name from method or variable name.