As you’ve learned in the sequential statements topic, the computer while running a java program, starts executing from the topmost line of the code. It reads the first line of the code, and continues doing so till the last line. Control statements help you run a program in a manner you define. These statements are used to change the computer’s control from reading and executing the statements in a given sequence to the way you define.

Control statements always base the program execution on a set of conditions. Let’s take an example of a programmer designing a program for a financial institute. The data for such programs is confidential and cannot be accessed by all the users. You would provide such an access to the user only if they provide the correct username and password. “Only” if both the passwords and the username are correct, should the program code allow them to see the records. The “else” part of code will run for people who don’t have valid password and enter incorrect information.

As you can see, the control statements help you check a certain condition. You can also put one control statement into another. Such statements are then known as nested control statements. In the example given above, the financial institute software provides 3 chances o each user. If the user enters incorrect information in all the three chances, their records are locked for a particular period. A sample algorithm that would help you design such a program is shown below:

1. Set Variable_counter_1 to 0;
2. Show the computer screen that asks you to enter your password;
3. If the password you enter is correct, run the code that allows the user to see the records which he wanted to see;
4. Else increment Variable_counter_1  i.e. add one to the Variable_counter_1;
5. If Variable_counter_1 is not equal to 3, then return back to line two and Show the computer screen again that asks you to enter your password;
6. Else if Variable_counter_1  equals 3 then lock the records and display the "goodbye" screen (If the counter equals 3 this means user have tried 3 times to enter the password and he does not have valid password so the user does not have valid rights.)

The code given above is a pseudo code. Since this code is written in simple English, it is understood by any person, but not by the computer.  In this pseudo code one if else statement is place within another if else statement. The manner in which the code would be executed is:

1. 1. Enter the password
2. 2. If the password is correct, skip lines dealing with incorrect passwords i.e. lines 4,5 and 6
3. 3. Else, if the password is incorrect, read line 4 instead of reading end of line 3
4. 4. If the counter does not equal to 3, do not run line 6; but go back and run line 4 and 5
5. 5. Else, if the password is incorrect for the third time, don’t run line 4 and 5 but run line 6

The control statements used in Java language are simple and can be understood by the computer easily. Because of this, they are very simple and are used extensively.  In case your condition has a complex structure, you can build it by combining a number of complex statements that contain a number of if-else statements.

Console input refers to keyboard. Most of the times we assign value s to the variables while declaring them. However, there are times when the program depends on the user provided inputs also. For example:

String your_name_example;

your_name_example  = Console.ReadLine();

In this example, first statement declares a string variable ` your_name_example ‘. Next statement, the Console.ReadLine command will read the value from console that is value which is entered by the user and store it in the variable ` your_name_example ‘.

This command works great if you assigning and entering the values into string variables. However, the input that the computer receives from using the command Console.ReadLine(); does not work with data types such as integers or doubles. This command will accept inputs in the text format only. If you try to input other types of variables using Console.ReadLine() command, an error message is generated.

Instead you can use the parse command as shown below:

int num_var_1;

num_var_1 = int.Parse(Console.ReadLine());

In the above example, the int.Parse command will convert the text input from the string output of  Console.ReadLine() into an integer variable num_var_1.

Similarly, the command double.parse is used to enter a double data type user defined value.

Not only this, the command `Console.WriteLine’ can be used to display messages and values stored in variables. For example,

Console.WriteLine(“Hello. This is an example of display message on screen”);

The code snippet given below displays the use of the command `Console.WriteLine’ -

static void Main(string[] args) { int num_var_1;

Console.WriteLine(“Please enter a number”); num_var_1=int.Parse(Console.ReadLine()); Console.WriteLine(“The number you have entered is {0}”, num_var_1); }

In the above code snippet, the first `Console.WriteLine’ command is used to display a simple message: “Please enter a number. “

The second `Console.WriteLine’ statement, makes use of a {0} with the message, where 0 acts as a placeholder. When the computer displays the output, it replaces the placeholder with the variable specified after the comma (,), which is num_var_1 in the example

If the user enters the number 56, the message that will be displayed is:

The number you have entered are 56.

Just as a single placeholder is used to input a single variable or value, multiple placeholders can be used to show multiple values or variables. The code snippet given below illustrates the use of this concept:

static void Main(string[] args) {

int num_var_1;

string string_variable_name;

Console.WriteLine(“Please enter name of your best friend”);

string_variable_name = Console.ReadLine();

Console.WriteLine(“Next, please enter age of your best friend”);

num_var_1=int.Parse(Console.ReadLine());

Console.WriteLine(“Your best friend {0} is {1} years old”, string_variable_name, num_var_1);

}

In the example given above, the last `Console.WriteLine’ statement uses two placeholders. When the program is run and the output is displayed, the first placeholder {0} will be replaced by the value stored in the variable ` string_variable_name ‘. Similarly, the second placeholder {1} will be replaced by the value stored in variable ` num_var_1′.

If we input John as name of best friend and 32 as his age, the final output of this program will be – “Your best friend John is 32 years old”.

Just as the Console Input command, accepts the user defined input, the Console. Output command displays the output on the monitor. In the Java programming language, you can write programs that write text lines to the console, which is a DOS based command window.

Though it’s not as popular as a Graphical User Interface or a GUI, the Console.Output command is used sometimes by programmers. Also, the Console.Output command doesn’t work properly with applets, WebStart applications and normal GUI programs. A sample code that shows the dialog or the console output program for simple input/output command is shown below:

public class example_Console_Output

{

public static void main(String[] args) {

System.out.println(“Hello, This is the example of Console Output command. “);

}

}

The System.out.println command is used to display an entire line of output on the console. The message passed as an argument to the System.out.println command is printed on the console. The println is the short form of print line command and originates from the Pascal programming language.

You can also substitute the println command with the print command. This command also prints the output to the console. However, it does not start a new line after the output is displayed.

Therefore, we can say that println is a method called by the System.out object used for displaying the console output. In this method, as you’ve already seen the data that needs to be displayed is passed as an argument to this command. The command uses a (+) sign to connenct two or more items. Not only this, each time the println command is invoked, it generates a new line once it has finished printing on the console. The example given below displays this:

System.out.println(“The answer to the question is ” + 9390);

Let’s first look at expressions. An expression is a program construct defined according to the syntax of the programming language, which uses variables, operators, and methods. Let’s now look at some examples of expressions:

int category_var = 0;

cat_Array[0]=200;

Now you can use these variables in the following expression:

System.out.println(“An element 1 at index 0: ” + cat_Array[0]);

int result_operator = 22 + 40; // result is now 62

The data type of resultant value returned by an expression depends on the data types of the operand used in the expression.  In the example shown above, the data type of the expression category_var = 0 return an int. This is because the assignment operator returns the value of int data type. Apart from int, the expressions can also return data of other types also such as Boolean or String.

Not only this, you can also construct compound expressions in the Java programming language. These compound expressions can be constructed by combining a number of smaller expressions. The only condition being the data type of the left side of the expression should match the data type of the right type.

The following code snippet displays the following compound expression:

3 * 4 * 5

In this example, apart from the product obtained from this expression, it is also important to note the order in which this expression is evaluated by the compiler. The outcome or the product of the expression always remains same irrespective of the order in which they appear in the expression.

For example, in the expression given below, the result or the outcome would vary depending on the use or evaluation of the division or the addition operator.

Num_var_1 + Num_var_2 / 25     // an unclear expression

The use of parenthesis in such expression makes them clear and helps determine the order of precedence.

Let’s see how the use of parenthesis helps in making the above unclear expression clear.

(Num_var_1 + Num_var_2) / 25    // use of parenthesis to rectify an unclear statement

The operator precedence defined within an expression takes precedence and the output is determined in that manner, if you don’t explicitly define the order of operators.  As you’ve already learnt operators having higher precedence are evaluated before the others. In the expression we just saw, the division operator would be evaluated before the addition operator.  Therefore, the result or the output of the following two statements would be the same:

Num_var_1 + Num_var_2 / 10

Num_var_1 + (Num_var_2 / 25)   // use of parenthesis to rectify an unclear statement

When defining compound expressions, it is important to explicitly define the order of operator precedence with the use of parenthesis. It will also help a programmer to make the code more readable and maintainable.

You can convert expressions into a statement by terminating the expression with a semicolon (;). Some such expressions are:

• Assignment expressions
• Use  of ++ or –
• Method invocations
• Object creation expressions

These statements are known as expression statements. Some examples of expression statements are:

Sample_Value_var = 9834.435;

Sample_Value_var++;

System.out.println(“Hello! How are you?”);

A program is defined as a group of statements executed in a given order to achieve a predetermined result.  Therefore, a program executes the statements in a sequential manner, either from top to bottom or vice versa. These are executed in the manner that they appear in the program code, called the sequential execution or sequential control flow.

The sequential statements can also be used in Processes, Procedures and Functions. These are further divided into:

• Expressions
• Console Input statements
• Console Output statements

A statement is a command given by the programmer to the computer program. Statements are used by different computer programming languages, such as Java, C, and C++. The syntax for declaring and using statements varies in each language. A simple example of a statement can be:

println “Hello ! I hope you are enjoying your stay here”

The statement uses a set of words “Hello! I hope you are enjoying your stay here?” and other details, such as what will be printed on screen.  The command println tells the computer to show the output on the monitor and not on the printer. The computer understands this command in the following two ways:

The programmer can give the command to the computer in the running mode, as the program is being executed.

They can also store a statement or a set of statements in a text file and execute it as and when required. This will then save the task of executing the statements again and again. For example, the command we just saw can be saved in a file Hello.txt and give this file to the computer.

As stated above, you can also save a set of multiple statements in a text file, which will then be executed in the top to bottom order. This means that the statement on the top will be executed first, followed by all other statements in that order.

Continuing with the above example, the file “Hello.txt” can contain multiple statements in a single file:

println “Hello! I hope you are enjoying your stay here.”

println “How was the dinner yesterday?”

println “Enjoy your lunch.”

As stated above, each of these commands will be performed from top to bottom in a sequential manner. On seeing the text file, the computer:

• Reads the first statement from the text file
• Determines if it is a println statement
• Determines the text that needs to be printed
• Displays the text on screen.

Therefore, the first command to be displayed on the screen would be: Hello! I hope you are enjoying your stay here.

The last statement would be: What is the duration of the course

The question marks that you saw in the code are not displayed on the computer screen. These punctuation marks are used to tell the computer where the statement would begin and end respectively. The computer then reads the second line, followed by the third line and displays the output in the following manner:

Hello! I hope you are enjoying your stay here.

How was the dinner yesterday?

Enjoy your lunch.

The computer stops reading the file once it reaches the end of the file. It is important to provide correct code in these text files, otherwise the code can also be erroneous.

Different programming languages use different types of computer statements. For example, a language can use a beep statement directing the computer to produce a beep in its speakers. Similarly, a window statement can direct the computer to popup a new window.

Not only this, different programming languages display and code statements differently. The set of rules such as println used to describe a statement is known as its syntax, while the actual message that needs to be displayed in known as its library.

Therefore, we can say that statements are used to change the value of variables, process input, display the desired output, or produce an action in response to user mouse or keyboard actions.

Different types of statements that we will commonly come across in the Java are:

• Assignment Statements
• Message Statements
• Statement Blocks

The relational operators work well in conditions where only a single condition needs to be checked. Logical operators either return a True value or a False value based on the state of the Variables. The six logical or Boolean, operators used in the Java programming language are:

• AND
• conditional AND
• OR
• conditional OR
• exclusive OR
• NOT

A logical operator accepts only arguments declared as Boolean data types. Also, these operators return value of Boolean data type.

These operators unlike the relational operators, that you already know, are used to check whether a set of conditions is true or not. In such as case, if statements are used. The code snippet below shows example of this:

if (num_var_1 == 4) {

  if (num_var_2 != 4) {

     System.out.println("Both conditions are true.");

   }

}

However, as you can see this is not a user-friendly code, and is both harder to write and read. Such a code snippet becomes difficult to manage when multiple conditions are used. Let’s now look at the use of the following three conditional operators:&&, || and !.

The logical operator && combines two Boolean values and gives a True result if and only if both of its operands are true. This is shown in the following code snippet:

Boolean c;

num_var_1 = 51 > 49 && 13 < 13; // num_var_1 is true

num_var_1 = 44 > 52 && 7 < 9; // num_var_1 is now false

Similarly, the logical operator || combines two Boolean variables or expressions. It returns a true result only if either or both of its operands are true. Let’s look at the following code snippet which shows the rule:

Boolean d;

num_var_4 = 51 > 49 || 73 < 91; // num_var_4 is true

num_var_4 = 49 > 51 || 73 < 91; // num_var_4 is still true

num_var_4 = 49 > 51 || 73 > 91; // now num_var_4 is false

The third and the last logic operator which we will look at is “!”  Which denotes “not”. The “!” logical operator reverses the value of a Boolean expression.

According to this logical operator:

if x is true !x is false.

If x is false  !x is true.

boolean bol_var_1;

bol_var_1 = !(4 > 5); // bol_var_1 is false

bol_var_1 = !(5 > 4); // bol_var_1 is true

As already stated logical operators allow you to test and use multiple conditions. For example, we can use the logical operators in the code snippet we saw above as follows:

if (var_num_1 == 2 && var_num_2 != 2) {

  System.out.println("Both conditions are true.");

}

Let’s look at a code snippet Demo_of_Logical_Operators which makes use of multiple logical operators:

public class Demo_of_Logical_Operators

{

public Demo_of_Logical_Operators () {

boolean bol_var_1 = true;

boolean bol_var_2 = false;

System.out.println(“bol_var_1 & bol_var_2 : ” + (bol_var_1 & bol_var_2));

System.out.println(“bol_var_1 && bol_var_2 : ” + (bol_var_1 && bol_var_2));

System.out.println(“bol_var_1 | bol_var_2 : ” + (bol_var_1 | bol_var_2));

System.out.println(“bol_var_1 || bol_var_2: ” + (bol_var_1 || bol_var_2));

System.out.println(“bol_var_1 ^ bol_var_2 : ” + (bol_var_1 ^ bol_var_2));

System.out.println(“!bol_var_1 : ” + (!bol_var_1));

}

public static void main(String args[]) {

new Demo_of_Logical_Operators ();

The table given below defines the different Boolean operators, if x and y are both Boolean expressions.

The relational operators are used to determine if one operand is equal to, greater than, less than, or not equal to the other operand with which it is compared. Just like mathematical operators, most of these operators are just like the normal operators we use in the everyday life. But certain operators are used in a different manner also.

For example, in place of “=” operator that we generally use for comparing two operands are equal, the relational operators in the Java programming language use  “==’.

The relational operators are defined as binary expressions, while their operands are numeric expressions.

When applying these operators, the rules that apply to the binary operators are applied and their evaluation returns a numeric value. Not only this, the operator precedence of relational operators is higher than assignment operators but lower than arithmetic operators.

The six relational operators used in Java and their uses are listed in the table below:

Next, let’s look at the code for the program demo_of_relational_operator that shows the use of the comparison operators.

class demo_of_relational_operator {

public static void main(String[] args){

int num_var_1 = 32;

int num_var_2 = 47;

if(num_var_1 == num_var_2) System.out.println(“num_var_1 == num_var_2″);

if(num_var_1 != num_var_2) System.out.println(“num_var_1 != num_var_2″);

if(num_var_1 > num_var_2) System.out.println(“num_var_1 > num_var_2″);

if(num_var_1 < num_var_2) System.out.println(“num_var_1 < num_var_2″);

if(num_var_1 <= num_var_2) System.out.println(“num_var_1 <= num_var_2″);

}

}

Output:

num_var_1 != num_var_2

num_var_1 < num_var_2

num_var_1 <= num_var_2

Next, let’s look at another code snipped displaying the use of different relational operators.

public class Demo_of_Relational_Operators

{

public Demo_of_Relational_Operators ( )

{

int num_var_1 = 10, num_var_2 = 5;

System.out.println(”num_var_1 > num_var_2 : “+(num_var_1 > num_var_2 ));

System.out.println(”num_var_1 < num_var_2 : “+(num_var_1 < num_var_2 ));

System.out.println(”num_var_1 >= num_var_2 : “+(num_var_1 >= num_var_2 ));

System.out.println(”num_var_1 <= num_var_2 : “+(num_var_1 <= num_var_2 ));

System.out.println(”num_var_1 == num_var_2 : “+(num_var_1 == num_var_2 ));

System.out.println(”num_var_1 != num_var_2 : “+(num_var_1 != num_var_2 ));

}

public static void main(String args[]){

new Demo_of_Relational_Operators ();

}

}

The Java programming language provides operators that perform simple mathematical operations such as addition, subtraction, multiplication, and division. These operators resemble the basic mathematics symbols that we all are aware of. Unlike the normal mathematical symbols, the “%”operator divides one operand by another and returns a remainder in the result.

The Java programming languages uses the following symbols:

• + Additive operator: This operator is not only used for addition, but is also used for String concatenation purposes.
• - Subtraction operator: This operator is used for subtracting the operands.
• * Multiplication operator:  This operator is used for multiplying the operands.
• / Division operator: This operator is used for dividing two or more operands.
• % remainder operator: This operator is used for obtaining the remainder by dividing one operand with another.

Let’s now look at a small program, Demo_of_operator_program, which shows the use of different arithmetic operators.

class Demo_of_operator_program {

public static void main (String[] args){

int result_operator = 20 + 42; // The result_operator is now 62

System.out.println(result_operator);

result_operator = result_operator – 22; // The result_operator is now 40

System.out.println(result_operator);

result_operator = result_operator * 3; // The result_operator is now 120

System.out.println(result_operator);

result_operator = result_operator / 2; // The result_operator is now 60

System.out.println(result_operator);

result_operator = result_operator + 10; // The result_operator is now 70

result_operator = result % 14; // The result_operator is now 5

System.out.println(result_operator);

}

}

The arithmetic operators listed above can be combined with the simple assignment operator to create compound assignments. For example the compound assignments such as, y+=1; and y=y+1; both increment the value of y by 1.

Not only this, you can also use the + or the additive operator for joining or concatenating two strings together. The Demo_of_Concat_Stings program displayed below displays a sample of string concatenation:

class Demo_of_Concat_Stings {

public static void main(String[] args){

String first_normal_String = “This is an”;

String second_normal_String = ” arithmetic operator”;

String third_concataneted_String = first_normal_String+second_normal_String;

System.out.println(third_concataneted_String);

}

}

This program displays the result: “This is an arithmetic operator.” which gets stored in the variable third_concataneted_String.

Computer operators are special symbols that perform specific operations on operands to return a result. Most computer programming languages support pre-defined set of operators, similar in function to mathematical operators.

Many a times, these operators are built-into a programming language, while at other times these may be defined in the program itself.  Therefore, languages such as C support built-in operators, while C++ and Java contain program-defined operators.

Operator precedence and associativity are defined in computer programming language specifications. Similarly, the position of the computer operator with respect to the computer operands can be prefix, postfix, or infix.

In the Java programming language, the operators act according to their precedence. Therefore, it is important that we know in advance about the operators with highest precedence, as these operators are evaluated before the operators with lower precedence. On the other hand, all the operators appearing on the same line have equal precedence. The Java compiler evaluates all operators, except the binary operators from left to right. Only the assignment operators are evaluated from right to left.

The following table lists the operators according to their precedence.

Operator Precedence

Programmers tend to use some operators mot than the others. For example, they tend to us the assignment operator “=”much more than the unsigned left shift operator “>>>=”