Java If-Else Statement

Java If-Else Statement

The if-else class of statements should have the following form:

if (condition) {
statements;
}

if (condition) {
statements;
} else {
statements;
}

if (condition) {
statements;
} else if (condition) {
statements;
} else {
statements;
}

All programming languages have some form of an if statement that allows you to test conditions. All arrays have lengths and we can access that length by referencing the variable arrayname.length. We test the length of the args array as follows:

Source Code

// This is the Hello program in Java
class Hello {

public static void main (String args[]) {

/* Now let's say hello */
System.out.print("Hello ");
if (args.length > 0) {
System.out.println(args[0]);
}
}

}

Compile and run this program and toss different inputs at it. You should note that there's no longer an ArrayIndexOutOfBoundsException if you don't give it any command line arguments at all.

What we did was wrap the System.out.println(args[0]) statement in a conditional test, if (args.length > 0) { }. The code inside the braces, System.out.println(args[0]), now gets executed if and only if the length of the args array is greater than zero. In Java numerical greater than and lesser than tests are done with the > and <>= respectively.

Testing for equality is a little trickier. We would expect to test if two numbers were equal by using the = sign. However we've already used the = sign to set the value of a variable. Therefore we need a new symbol to test for equality. Java borrows C's double equals sign, ==, to test for equality. Lets look at an example when there are more then 1 statement in a branch and how braces are used indefinitely.

Source Code

import java.io.*;
class NumberTest
{
 public static void main (String[] args) throws IOException
 {
  BufferedReader stdin = new BufferedReader ( new InputStreamReader( System.in ) );

  String inS;
  int num;

  System.out.println("Enter an integer number");
  inS = stdin.readLine();
  num = Integer.parseInt( inS ); // convert inS to int using wrapper classes

  if ( num < 0 )  // true-branch
  {
       System.out.println("The number " + num + " is negative");
     System.out.println("negative number are less than zero");
  }
  else   // false-branch
  {
     System.out.println("The number " + num + " is positive");
     System.out.print ("positive numbers are greater ");
     System.out.println("or equal to zero ");
  }
  System.out.println("End of program"); // always executed
 }
}
       

All conditional statements in Java require boolean values, and that's what the ==, <, >, <=, and >= operators all return. A boolean is a value that is either true or false. Unlike in C booleans are not the same as ints, and ints and booleans cannot be cast back and forth. If you need to set a boolean variable in a Java program, you have to use the constants true and false. false is not 0 and true is not non-zero as in C. Boolean values are no more integers than are strings.

Else

Lets look at some examples of if-else:

//Example 1
if(a == b) {
c++;
}
if(a != b) {
c--;
}

//Example 2
if(a == b) {
c++;
}
else {
c--;
}

We could add an else statement like so:

Source Code

// This is the Hello program in Java
class Hello {

public static void main (String args[]) {

/* Now let's say hello */
System.out.print("Hello ");
if (args.length > 0) {
System.out.println(args[0]);
}
else {
System.out.println("whoever you are");
}
}

}

Source Code

public class divisor
{
public static void main(String[] args)
int a = 10;
int b = 2;
if ( a % b == 0 )
{
System.out.println(a + " is divisible by "+ b);
}
else
{
System.out.println(a + " is not divisible by " + b);
}
}

Now that Hello at least doesn't crash with an ArrayIndexOutOfBoundsException we're still not done. java Hello works and Java Hello Rusty works, but if we type java Hello Elliotte Rusty Harold, Java still only prints Hello Elliotte. Let's fix that.

We're not just limited to two cases though. We can combine an else and an if to make an else if and use this to test a whole range of mutually exclusive possibilities.

Lets look at some examples of if-else-if:

//Example 1
if(color == BLUE)) {
System.out.println("The color is blue.");
}
else if(color == GREEN) {
System.out.println("The color is green.");
}

//Example 2
if(employee.isManager()) {
System.out.println("Is a Manager");
}
else if(employee.isVicePresident()) {
System.out.println("Is a Vice-President");
}
else {
System.out.println("Is a Worker");
}

Source Code

// This is the Hello program in Java
class Hello {

public static void main (String args[]) {

/* Now let's say hello */
System.out.print("Hello ");
if (args.length == 0) {
System.out.print("whoever you are");
}
else if (args.length == 1) {
System.out.println(args[0]);
}
else if (args.length == 2) {
System.out.print(args[0]);
System.out.print(" ");
System.out.print(args[1]);
}
else if (args.length == 3) {
System.out.print(args[0]);
System.out.print(" ");
System.out.print(args[1]);
System.out.print(" ");
System.out.print(args[2]);
}
System.out.println();
}
}

Java Conditional Operators

Java Conditional Operators

Java has the conditional operator. It's a ternary operator -- that is, it has three operands -- and it comes in two pieces, ? and :, that have to be used together. It takes the form

Boolean-expression ? expression-1 : expression-2

The JVM tests the value of Boolean-expression. If the value is true, it evaluates expression-1; otherwise, it evaluates expression-2. For

Example

if (a > b) {
max = a;
}
else {
max = b;
}


Setting a single variable to one of two states based on a single condition is such a common use of if-else that a shortcut has been devised for it, the conditional operator, ?:. Using the conditional operator you can rewrite the above example in a single line like this:

max = (a > b) ? a : b;

Java Boolean Operators

Java Boolean Operators

The Boolean logical operators are : | , & , ^ , ! , || , && , == , != . Java supplies a primitive data type called Boolean, instances of which can take the value true or false only, and have the default value false. The major use of Boolean facilities is to implement the expressions which control if decisions and while loops.

These operators act on Boolean operands according to this table

A         B             A|B       A&B      A^B      !A
false     false         false     false    false    true
true      false         true      false    true     false
false     true          true      false    true     true
true      true          true      true     false    false

| the OR operator
& the AND operator
^ the XOR operator
! the NOT operator
|| the short-circuit OR operator
&& the short-circuit AND operator
== the EQUAL TO operator
!= the NOT EQUAL TO operator 

Example

class Bool1{
  public static void main(String args[]){

// these are boolean variables    
     boolean A = true;
     boolean B = false;

     System.out.println("A|B = "+(A|B));
     System.out.println("A&B = "+(A&B));
     System.out.println("!A = "+(!A));
     System.out.println("A^B = "+(A^B));
     System.out.println("(A|B)&A = "+((A|B)&A));
   }
}

Java Relational Operators

Java Relational Operators

A relational operator compares two values and determines the relationship between them. For example, != returns true if its two operands are unequal. Relational operators are used to test whether two values are equal, whether one value is greater than another, and so forth. The relation operators in Java are: ==, !=, <, >, <=, and >=. The meanings of these operators are:

Use	Returns true if
op1 > op2	op1 is greater than op2
op1 >= op2	op1 is greater than or equal to op2
op1 < op2	op1 is less than to op2
op1 <= op2	op1 is less than or equal to op2
op1 == op2	op1 and op2 are equal
op1 != op2	op1 and op2 are not equal

Variables only exist within the structure in which they are defined. For example, if a variable is created within a method, it cannot be accessed outside the method. In addition, a different method can create a variable of the same name which will not conflict with the other variable. A java variable can be thought of

The main use for the above relational operators are in CONDITIONAL phrases The following java program is an example, RelationalProg, that defines three integer numbers and uses the relational operators to compare them.

public class RelationalProg {
 public static void main(String[] args) {

 //a few numbers
 int i = 37;
 int j = 42;
 int k = 42;

 //greater than
 System.out.println("Greater than...");
 System.out.println(" i > j = " + (i > j)); //false
 System.out.println(" j > i = " + (j > i)); //true
 System.out.println(" k > j = " + (k > j)); //false
 //(they are equal)

 //greater than or equal to
 System.out.println("Greater than or equal to...");
 System.out.println(" i >= j = " + (i >= j)); //false
 System.out.println(" j >= i = " + (j >= i)); //true
 System.out.println(" k >= j = " + (k >= j)); //true

 //less than
 System.out.println("Less than...");
 System.out.println(" i < j = " + (i < j)); //true
 System.out.println(" j < i = " + (j < i)); //false
 System.out.println(" k < j = " + (k < j)); //false

 //less than or equal to
 System.out.println("Less than or equal to...");
 System.out.println(" i <= j = " + (i <= j)); //true
 System.out.println(" j <= i = " + (j <= i)); //false
 System.out.println(" k <= j = " + (k <= j)); //true

 //equal to
 System.out.println("Equal to...");
 System.out.println(" i == j = " + (i == j)); //false
 System.out.println(" k == j = " + (k == j)); //true

 //not equal to
 System.out.println("Not equal to...");
 System.out.println(" i != j = " + (i != j)); //true
 System.out.println(" k != j = " + (k != j)); //false
 }
}

Java Increment and Decrement Operators

Java Increment and Decrement Operators

There are 2 Increment or decrement operators -> ++ and --. These two operators are unique in that they can be written both before the operand they are applied to, called prefix increment/decrement, or after, called postfix increment/decrement. The meaning is different in each case.

Example

x = 1;
y = ++x;
System.out.println(y);

prints 2, but

x = 1;
y = x++;
System.out.println(y);

prints 1

Source Code

//Count to ten

class UptoTen {

public static void main (String args[]) {
int i;
for (i=1; i <=10; i++) {
System.out.println(i);
}
}

}

When we write i++ we're using shorthand for i = i + 1. When we say i-- we're using shorthand for i = i - 1. Adding and subtracting one from a number are such common operations that these special increment and decrement operators have been added to the language. T

There's another short hand for the general add and assign operation, +=. We would normally write this as i += 15. Thus if we wanted to count from 0 to 20 by two's we'd write:

Source Code

class CountToTwenty {

public static void main (String args[]) {
int i;
for (i=0; i <=20; i += 2) { //Note Increment Operator by 2
System.out.println(i);
}

} //main ends here

}

As you might guess there is a corresponding -= operator. If we wanted to count down from twenty to zero by twos we could write: -=

class CountToZero {

public static void main (String args[]) {
int i;
for (i=20; i >= 0; i -= 2) { //Note Decrement Operator by 2
System.out.println(i);
}
}

}

Java Assignment Operators

Java Assignment Operators

It's very common to see statement like the following, where you're adding something to a variable. Java Variables are assigned, or given, values using one of the assignment operators. The variable are always on the left-hand side of the assignment operator and the value to be assigned is always on the right-hand side of the assignment operator. The assignment operator is evaluated from right to left, so a = b = c = 0; would assign 0 to c, then c to b then b to a.

i = i + 2;

Here we say that we are assigning i's value to the new value which is i+2.

A shortcut way to write assignments like this is to use the += operator. It's one operator symbol so don't put blanks between the + and =.
i += 2; // Same as "i = i + 2"

The shortcut assignment operator can be used for all Arithmetic Operators i.e. You can use this style with all arithmetic operators (+, -, *, /, and even %).

Here are some examples of assignments:

//assign 1 to
//variable a
int a = 1;

//assign the result
//of 2 + 2 to b
int b = 2 + 2;

//assign the literal
//"Hello" to str
String str = new String("Hello");

//assign b to a, then assign a
//to d; results in d, a, and b being equal
int d = a = b;

Java Arithmetic Operators

Java Arithmetic Operators

The Java programming language has includes five simple arithmetic operators like are + (addition), - (subtraction), * (multiplication), / (division), and % (modulo). The following table summarizes the binary arithmetic operators in the Java programming language.

The relation operators in Java are: ==, !=, <, >, <=, and >=. The meanings of these operators are:

Use	Returns true if
op1 + op2	op1 added to op2
op1 - op2	op2 subtracted from op1
op1 * op2	op1 multiplied with op2
op1 / op2	op1 divided by op2
op1 % op2	Computes the remainder of dividing op1 by op2

The following java program, ArithmeticProg , defines two integers and two double-precision floating-point numbers and uses the five arithmetic operators to perform different arithmetic operations. This program also uses + to concatenate strings. The arithmetic operations are shown in boldface.

public class ArithmeticProg {
 public static void main(String[] args) {

 //a few numbers
 int i = 10;
 int j = 20;
 double x = 10.5;
 double y = 20.5;

 //adding numbers
 System.out.println("Adding");
 System.out.println(" i + j = " + (i + j));
 System.out.println(" x + y = " + (x + y));

 //subtracting numbers
 System.out.println("Subtracting");
 System.out.println(" i - j = " + (i - j));
 System.out.println(" x - y = " + (x - y));

 //multiplying numbers
 System.out.println("Multiplying");
 System.out.println(" i * j = " + (i * j));
 System.out.println(" x * y = " + (x * y));

 //dividing numbers
 System.out.println("Dividing");
 System.out.println(" i / j = " + (i / j));
 System.out.println(" x / y = " + (x / y));

 //computing the remainder resulting
 //from dividing numbers
 System.out.println("Modulus");
 System.out.println(" i % j = " + (i % j));
 System.out.println(" x % y = " + (x % y));

   }
}