int x = 7;                         // pretty standard assignment

byte b = 127;
byte c = b;                        // copy variable b into c, remember there is no relationship between b and c

String text = "Hello World!\n";    // create variable with an object type of String
String text2 = text;               // assign an object to a object variable, point to same object

float f = (float) 32.3;            // Explicitly cast the double literal to a float, otherwise compiler error

Note: if the value is too large for the data type the compiler will let you know

if ( age > 65 ) { ... }           // greater than operator
if ( age < 65 ) { ... }           // less than operator
if ( age >= 65 ) { ... }          // greater than or equal to operator
if ( age <= 65 ) { ... }          // less than or equal to operator

Note: comparison operators always result in a boolean (true or false)

String s = "Hello World!"
if ( s instanceof String ) { ... }

Note: it will check the superclasses as well to confirm it has a IS-A relationship

int age = 60;
if ( age == 60 ) { ... }          // compare variable age with integer 60
if ( age != 60 ) { ... }

String s1 = "Test";
String s2 = "Test";
if ( s1 == s2 ) { ... }           // compare two String objects

int x = 5 * 5;
int y = 20 - 10;
int z = 20 % 3;     // this would result in 2 (20 / 3 = 6 reminder 2), you can also use this with doubles and floats

x += 5;         // this is a short hand way of saying x = x + 5;
x *= 5;         // this is a short hand way of saying x = x * 5;

Note: dividing by zero using int will throw an exception but if using doubles or floats you will get a NaN

String s1 = "Hello ";
String s2 = "World!\n";
String result = s1 + s2;          // result would contain "Hello World!\n"

int a = 2;
int b = 3;
System.out.println( a + b );               // results in 5 being printed
System.out.println( "Answer: " + a + b);   // results in "Answer = 23" being printed

Note: when using integers and Strings, as long as one operand is a String the result is a String, if both operands are integers then the arithmetic will take place

int a = 10, b = 9;
int c = a & b;             // results in 8 being assigned to c (1010 & 1001 = 1000)
int c = a | b;             // results in 11 being assigned to c (1010 | 1001 = 1011)

int x = 5;
int y = ~x;
System.out.println("Y: " + y);     // results in "Y: -6"

~0000 0000 0000 0000 0000 0000 0000 0101 becomes 1111 1111 1111 1111 1111 1111 1111 1010

int a = 100;
long b = a;            // Implicit cast, an int value always fits in a long

float a = 100.001f;
int b = (int) b;       // Explicit cast, a float can loose info as an int

Note: with explicit casting you let the compiler know that you know that you may loose info

# Short-Circuit
if (( age >= 5 ) && ( age <= 17 )) { ... }       // both expressions have to be true to execute the if body
if (( age == 18 ) || ( age == 19 )) { ... }      // only one expression has to be true to execute the if body

# Not Short Circuit
if (( age >= 5 ) & ( age <= 17 )) { ... }        // both expressions have to be true to execute the if body
if (( age == 18 ) | ( age == 19 )) { ... }       // only one expression has to be true to execute the if body

Note: using the not short circuit (& or |) is inefficient because it will evaluate both expressions even if the second expression would not change the outcome.

if (booleanExpression ) { System.out.println("Inside a IF statement ");
        
if ( age == 65 ) { System.out.println("Book yourself a retirement holiday");

if (true)
System.out.println("Hello ");       
System.out.print("World!");             // you actually don't need brackets but it can be hard to read code

if (false);                        
System.out.println("Hello World!");     // notice the semi-colon at the end of the if statement, this terminates the if statement imediately and this line always executes

if ( price < 100 ) {
   System.out.println("Buy it, it's a bargain");
}
else {
   System.out.println("It's to pricey wait until the sales");
}

// You can also remove the brackets when you only have one line of code for each true or false
if ( price < 100 )
   System.out.println("Buy it, it's a bargain");
else
   System.out.println("It's to pricey wait until the sales");

// Using a if-else-if
if ( price < 100 )
   System.out.println("Buy it, it's a bargin"):
else if ( price < 110 )
   System.out.println("You might be tempted");
else
   System.out.println("It's to pricey wait until the sales");

Note: always indent conditional code it makes it much more pleasant on the eyes

result = ( a < b ; a ? b);

if the condition a < b is true then the value of a is assigned to result
if the condition a < b is false then the value of b is assigned to result

Note: The ternary operator (conditional operator) is a short-hand of a if-else statement

int x = 3;

switch (x) {
  case 1:
    System.out.println("x is equal to one");
    break;
  case 2:
    System.out.println("x is equal to two");
    break;
  case (1 + 2):                                   // can even use expressions as well
    System.out.println("x is equal to three");
    break;
  default:                                        // default block does not need to be at the end or even included
    System.out.println("No idea what x is ?????");
}

Note: switch statements can only evaluate byte (Byte), short (Short), int (Integer) and char (Character), enumerated types and the String class

Note: missing break statements means that all case statements will be executed, known as fall-through 

int x = 0;

while ( x < 10 ) {
   System.out.println("x is still less than 10");
   x++;
}

Note: it is possible that the while body may never be executed

int x = 0;

do {
  System.out.println("x is still less than 10");
  x++;
} while ( x < 10 );            // notice the semi-colon 

Note: The while body will always be executed once, also notice the semi-colon at the end of the while expression 

for ( int x = 0; x < 10; x++) {
    System.out.println("x is still less than 10");
}

# More complex FOR loop
for ( int x = 0, y = 0; ( (x < 10) && (y < 10) ); x++, y++) {
    System.out.println("x and y are still less than 10");
}

Note: you can have only one logical expression but it can be very complex.

The for statement is made up of three parts

• Control variable initialization (only called once)
• Loop continuation Condition (must evaluate to true or false)
• Increment/Decrement of the control variable (executed after the iteration)

   for ( control variable initialization ; loop continuation ; increment/decrement of the control variable )

More information about loops:

• You cannot reference a label with the continue or break statements that are not in the loop scope, a compile error occurs
• An outer loop cannot reference the inners loop's labels, but an inner loop can reference the outer's loop lables
• You can break out of a nested loop from a nested loop
• You can also completely break out of a parent loop

init i = 0;
        
for(Strings arg : args) {
  System.out.println("Argument " + (++i) + " = " + arg);
}

int counter = 1;

while (counter <= 10 ) {
   System.out.println ( "Counter = " + counter + " We will break on 5" );
   if ( counter == 5 )
      // Break out of the while loop
      break;
   counter++;
}

Note: The break statement when executed in a while, do/while or switch statement causes immediate exit from that structure and continues on to the next statement after the while, do/while or switch structure.

int counter = 1;

while (counter <= 10 ) {

   if ( (counter % 2) == 0 ) {
      System.out.println ( "Counter = " + counter + " Do not print odd numbers" );
      counter++;
      continue;
   }
   counter++;
}

Note:The continue statement when executed in a while, do/while or switch skips the remaining body statements and proceeds to the next iteration of the loop.

stop: // labeled compound statement
   for ( int row = 1; row <= 10; row++ ) {
      for ( int column = 1; column <= 5; column++ ) {
         if ( row == 5 )
            break stop;   // Jump to end of stop block
      }
   }

Note: Labeled break/continue statements are to breakout of nested set of structures, the beginning of the nested structure starts with a label which is a place that the break statement will exit from.