• Simple - Java was designed for professional developers to learn and use easily . If you are aware of basic programming principles, then Java is not a hard nut to crack.
• Secure - Java achieve security by confining Java Programs to Java Execution Environment and not allowing Java programs to access other parts of the computer system.
• Portable - Portable code must run on variety of operating systems , CPU’s , browsers . When Java program is compiled, a Bytecode is generated, this bytecode can be executed on any platform using JVM ( Java Virtual Machine ). We will discuss JVM details in the later part of the tutorial.
• Object Oriented - Java provides a clean, usable, pragmatic approach to objects, it was designed on the principle that “Everything under the sun is Object.”
• Robust - Robustness of the program is reliable execution on a variety of systems , to better understand this , consider one of the main reasons for program failure is memory management, In C/C++ programmer, must manually allocate and free dynamic memory, there are cases programmers forgot to free up the dynamic memory, unlike Java virtually solves this problem as unused objects are garbage collected automatically.
• Architecture Neutral - The central issue for Java Designers was that of code longevity and portability. One of the main problem for programmers was that there was no guarantee that program running perfectly fine today will run tomorrow because of the system upgrades, processor upgrades or changes in core system resources. Java Designers made several hard decisions and designed Java Virtual Machine to solve this Problem. Their goal was “write once, run anywhere, any time, forever “ .
• Distributed - Java is designed for distributed environment because it handles TCP/IP protocol. It is very much useful in building large scale distributed computing based applications. Java also supports Remote Method Invocation. This feature enables a program to invoke methods across a network.
  
• Dynamic - Java programs have run time meta information to verify and resolve accesses of the objects at runtime. This makes it possible to dynamically link code in a safe and secure environment. It also gives us feature to update small fragments of bytecode dynamically updated on a running system.
  

• Classloader - It loads the class file for JVM execution.
  
• Bytecode Verifier - It verifies the bytecode and restrict objects for illegal access of other part of the system.
• Interpreter - It read the bytecode instructions and execute it line by line.

Java program Execution Flow:

• A specification where working of Java Virtual Machine is specified. But implementation provider is independent to choose the algorithm. Its implementation has been provided by Sun and other companies.
• An implementation is a computer program that meets the requirements of the JVM specification
• Runtime Instance Whenever you write java command on the command prompt to run the java class, an instance of JVM is created.

First Program - "Hello World"

Hello, World

1. Class definition:This line uses the keyword class to declare that a new class is being defined.
   

   class HelloWorld 
   

   HelloWorld is an identifier that is the name of the class. The entire class definition, including all of its members, will be between the opening curly brace  {  and the closing curly brace  } .
2. main method: In Java programming language, every application must contain a main method whose signature is:
   

   public static void main(String[] args)
   public: So that JVM can execute the method from anywhere.
   static: Main method is to be called without object. 
   The modifiers public and static can be written in either order.
   void: The main method doesn't return anything.
   main(): Name configured in the JVM.
   String[]: The main method accepts a single argument: 
             an array of elements of type String.
   

   Like in C/C++, main method is the entry point for your application and will subsequently invoke all the other methods required by your program.
3. The next line of code is shown here. Notice that it occurs inside main( ).
   

   System.out.println("Hello, World");
   

   This line outputs the string "Hello, World" followed by a new line on the screen. Output is actually accomplished by the built-in println( ) method. System is a predefined class that provides access to the system, and out is the variable of type output stream that is connected to the console.
4. Comments: They can either be multi-line or single line comments.
   

   /* This is a simple Java program. 
   Call this file "HelloWorld.java". */
   

   This is a multiline comment. This type of comment must begin with /* and end with */. For single line you may directly use // as in C/C++.

• The name of the class defined by the program is HelloWorld, which is the same as the name of the file(HelloWorld.java). This is not a coincidence. In Java, all codes must reside inside a class and there is at most one public class which contain main() method.
• By convention, the name of the main class(a class which contain the main method) should match the name of the file that holds the program.

Java Basic Console Input/Output

1.Using Buffered Reader Class

Advantages :
• The input is buffered for efficient reading.

Drawback: :
• The wrapping code is hard to remember.

Geek

Geek

2. Using Scanner Class

Advantages:

• Convenient methods for parsing primitives (nextInt(), nextFloat(), …) from the tokenized input.
• Regular expressions can be used to find tokens.

Drawback:
• The reading methods are not synchronized

GeeksforGeeks
12
3.4

You entered integer 12
Enter a float
You entered float 3.4

3. Using Console Class

• Reading password without echoing the entered characters.
• Reading methods are synchronized.
• Format string syntax can be used.

Drawback:
• Does not work in non-interactive environment (such as in an IDE).

Java Identifiers

public class Test
{
    public static void main(String[] args)
    {
        int a = 20;
    }
}

• Test : class name.
• main : method name.
• a :  variable name.

• The only allowed characters for identifiers are all alphanumeric characters([A-Z],[a-z],[0-9]), '$'(dollar sign) and '_' (underscore).For example "geek@" is not a valid java identifier as it contain '@' special character.
• Identifiers should not start with digits([0-9]). For example "123geeks" is a not a valid java identifier.
• Java identifiers are case-sensitive.
• There is no limit on the length of the identifier but it is advisable to use an optimum length of 4 - 15 letters only.
• Reserved Words can't be used as an identifier. For example "int while = 20;" is an invalid statement as while is a reserved word. There are 53 reserved words in Java.

MyVariable
MYVARIABLE
myvariable
x
i
x1
i1
_myvariable
$myvariable
sum_of_array
geeks123

My Variable  // contains a space
123geeks   // Begins with a digit
a+c // plus sign is not an alphanumeric character
variable-2 // hyphen is not an alphanumeric character
sum_&_difference // ampersand is not an alphanumeric character

• The value stored in a variable can be changed during program execution.
• A variable is only a name given to a memory location, all the operations done on the variable effects that memory location.
• In Java, all the variables must be declared before use.

How to declare variables?

• Data Type: Type of data that can be stored in this variable.
• Variable Name: Name given to the variable.
• Value: It is the initial value stored in the variable.

//Declaring float variable
float simpleInterest;
//Declaring and Initializing integer variable 
int time = 10, speed = 20; 
// Declaring and Initializing character variable
char var = 'h'; 

Types of variables

• Local Variables
• Instance Variables
• Static Variables

1. Local Variables: A variable defined within a block or method or constructor is called local variable.
   
   • These variable are created when the block in entered or the function is called and destroyed after exiting from the block or when the call returns from the function.
   • The scope of these variables exists only within the block in which the variable is declared. i.e. we can access these variable only within that block.
   • Initilisation of Local Variable is Mandatory.
   
   Sample Program 1:
   1

   2

   3

   4

   5

   6

   7

   8

   9

   10

   11

   12

   13

   14

   15

   16

   17

   public class StudentDetails

   {

   public void StudentAge()

   { //local variable age

   int age = 0;

   age = age + 5;

   System.out.println("Student age is : " + age);

   }

   public static void main(String args[])

   {

   StudentDetails obj = new StudentDetails();

   obj.StudentAge();

   }

   }

   הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה

   XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
   Run
   Output:
   

   Student age is : 5
   

   In the above program the variable age is local variable to the function StudentAge(). If we use the variable age outside StudentAge() function, the compiler will produce an error as shown in below program.
   
   Sample Program 2:
   1

   2

   3

   4

   5

   6

   7

   8

   9

   10

   11

   12

   13

   14

   15

   16

   17

   public class StudentDetails

   {

   public void StudentAge()

   { //local variable age

   int age = 0;

   age = age + 5;

   }

   public static void main(String args[])

   {

   //using local variable age outside it's scope

   System.out.println("Student age is : " + age);

   }

   }

   הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה

   XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
   Run
   Output:
   

   error: cannot find symbol
    " + age);
   



2. Instance Variables: Instance variables are non-static variables and are declared in a class outside any method, constructor or block.
   
   • As instance variables are declared in a class, these variables are created when an object of the class is created and destroyed when the object is destroyed.
   • Unlike local variables, we may use access specifiers for instance variables. If we do not specify any access specifier then the default access specifier will be used.
   • Initilisation of Instance Variable is not Mandatory. Its default value is 0
   • Instance Variable can be accessed only by creating objects.
   Sample Program:
   
   1

   2

   3

   4

   5

   6

   7

   8

   9

   10

   11

   12

   13

   14

   15

   16

   17

   18

   19

   20

   21

   22

   23

   24

   25

   26

   27

   28

   29

   30

   31

   import java.io.*;

   class Marks

   {

   //These variables are instance variables.

   //These variables are in a class and are not inside any function

   int engMarks;

   int mathsMarks;

   int phyMarks;

   }

   class MarksDemo

   {

   public static void main(String args[])

   { //first object

   Marks obj1 = new Marks();

   obj1.engMarks = 50;

   obj1.mathsMarks = 80;

   obj1.phyMarks = 90;

   //second object

   Marks obj2 = new Marks();

   obj2.engMarks = 80;

   obj2.mathsMarks = 60;

   obj2.phyMarks = 85;

   //displaying marks for first object

   System.out.println("Marks for first object:");

   System.out.println(obj1.engMarks);

   System.out.println(obj1.mathsMarks);

   System.out.println(obj1.phyMarks);

   הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה

   XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
   Run
   Output:
   

   Marks for first object:
   50
   80
   90
   Marks for second object:
   80
   60
   85
   

   As you can see in the above program the variables, engMarks , mathsMarks , phyMarksare instance variables. In case we have multiple objects as in the above program, each object will have its own copies of instance variables. It is clear from the above output that each object will have its own copy of instance variable.


3. Static Variables: Static variables are also known as Class variables.
   
   • These variables are declared similarly as instance variables, the difference is that static variables are declared using the static keyword within a class outside any method constructor or block.
   • Unlike instance variables, we can only have one copy of a static variable per class irrespective of how many objects we create.
   • Static variables are created at start of program execution and destroyed automatically when execution ends.
   • Initilisation of Static Variable is not Mandatory. Its default value is 0
   • If we access the static variable like Instance variable (through object), compiler will show the warning message and it wont hault the program. Compiler will replace the object name to class name automatically.
   • If we access the static variable without classname, Compiler will automatically append the class name.
   To access static variables, we need not to create any object of that class, we can simply access the variable as:

   class_name.variable_name;

   
   Sample Program:
   
   1

   2

   3

   4

   5

   6

   7

   8

   9

   10

   11

   12

   13

   14

   15

   16

   17

   18

   19

   20

   import java.io.*;

   class Article {

   // static variable salary

   public static double rating;

   public static String name = "Variables Declaration";

   }

   public class ArticleDemo

   {

   public static void main(String args[]) {

   //accessing static variable without object

   Article.rating = 4.5;

   System.out.println(Article.name + "'s rating:" + Article.rating);

   }

   }

   הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה

   XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
   Run
   output:
   

   Variables Declaration's rating:4.5
   

Instance variable Vs Static variable

• Each object will have its own copy of instance variable whereas We can only have one copy of a static variable per class irrespective of how many objects we create.
• Changes made in an instance variable using one object will not be reflected in other objects as each object has its own copy of instance variable. In case of static, changes will be reflected in other objects as static variables are common to all object of a class.
• We can access instance variables through object references and Static Variables can be accessed directly using class name.
• Syntax for static and instance variables:
  

  class Example
      {
          static int a; //static variable
          int b;        //instance variable
      }
  

Java Data Types

• Primitive data (e.g., number, character)
• Object data (programmer created types)

Primitive data

• boolean: boolean data type represents only one bit of information either true or false . Values of type boolean are not converted implicitly or explicitly (with casts) to any other type. But the programmer can easily write conversion code.
  
  1

  2

  3

  4

  5

  6

  7

  8

  9

  10

  11

  12

  // A Java program to demonstrate boolean data type

  class GeeksforGeeks

  {

  public static void main(String args[])

  {

  boolean b = true;

  if (b == true)

  System.out.println("Hi Geek");

  }

  }

  הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה

  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  Run
  Output:
  

  Hi Geek
  

• byte: The byte data type is an 8-bit signed two's complement integer. The byte data type is useful for saving memory in large arrays.
  
  • Size: 8-bit
  • Value: -128 to 127
  
  
  1

  2

  3

  4

  5

  6

  7

  8

  9

  10

  11

  12

  13

  14

  15

  16

  17

  18

  19

  20

  21

  22

  23

  24

  // Java program to demonstrate byte data type in Java

  class GeeksforGeeks

  {

  public static void main(String args[])

  {

  byte a = 126;

  // byte is 8 bit value

  System.out.println(a);

  a++;

  System.out.println(a);

  // It overflows here because

  // byte can hold values from -128 to 127

  a++;

  System.out.println(a);

  // Looping back within the range

  a++;

  System.out.println(a);

  }

  }

  הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה

  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  Run
  Output:
  

  126
  127
  -128
  -127
  

• short: The short data type is a 16-bit signed two's complement integer. Similar to byte, use a short to save memory in large arrays, in situations where the memory savings actually matters.
  
  • Size: 16 bit
  • Value: -32,768 to 32,767 (inclusive)
• int: It is a 32-bit signed two's complement integer.
  
  • Size: 32 bit
  • Value: -2³¹ to 2³¹-1
  Note: In Java SE 8 and later, we can use the int data type to represent an unsigned 32-bit integer, which has value in range [0, 2³²-1]. Use the Integer class to use int data type as an unsigned integer.
  
• long: The long data type is a 64-bit two's complement integer.
  
  • Size: 64 bit
  • Value: -2⁶³ to 2⁶³-1.
  
  Note: In Java SE 8 and later, you can use the long data type to represent an unsigned 64-bit long, which has a minimum value of 0 and a maximum value of 2⁶⁴-1. The Long class also contains methods like compareUnsigned, divideUnsigned etc to support arithmetic operations for unsigned long.
  
• 
  Floating point Numbers : float and double
  float: The float data type is a single-precision 32-bit IEEE 754 floating point. Use a float (instead of double) if you need to save memory in large arrays of floating point numbers.
  
  • Size: 32 bits
  • Suffix : F/f Example: 9.8f
  
  double: The double data type is a double-precision 64-bit IEEE 754 floating point. For decimal values, this data type is generally the default choice.
  
  Note: Both float and double data types were designed especially for scientific calculations, where approximation errors are acceptable. If accuracy is the most prior concern then, it is recommended not to use these data types and use BigDecimal class instead.
  
• char: The char data type is a single 16-bit Unicode character. A char is a single character.
  
  • Value: '\u0000' (or 0) to '\uffff' 65535
  
  
  1

  2

  3

  4

  5

  6

  7

  8

  9

  10

  11

  12

  13

  14

  15

  16

  17

  18

  19

  20

  21

  22

  23

  24

  25

  26

  27

  28

  29

  30

  31

  // Java program to demonstrate primitive data types in Java

  class GeeksforGeeks

  {

  public static void main(String args[])

  {

  // declaring character

  char a = 'G';

  // Integer data type is generally

  // used for numeric values

  int i=89;

  // use byte and short if memory is a constraint

  byte b = 4;

  // this will give error as number is

  // larger than byte range

  // byte b1 = 7888888955;

  short s = 56;

  // this will give error as number is

  // larger than short range

  // short s1 = 87878787878;

  // by default fraction value is double in java

  double d = 4.355453532;

  // for float use 'f' as suffix

  הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה

  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  Run
  Output:
  

  char: G
  integer: 89
  byte: 4
  short: 56
  float: 4.7333436
  double: 4.355453532
  

1. Arithmetic Operators: They are used to perform simple arithmetic operations on primitive data types.
   
   
   
   • * : Multiplication
   
   
   • / : Division
   
   
   • % : Modulo
   
   
   • + : Addition
   
   
   • - : Subtraction
   1

   2

   3

   4

   5

   6

   7

   8

   9

   10

   11

   12

   13

   14

   15

   16

   17

   18

   19

   20

   21

   22

   23

   24

   25

   26

   27

   28

   29

   30

   31

   // Java program to illustrate

   // arithmetic operators

   public class operators

   {

   public static void main(String[] args)

   {

   int a = 20, b = 10, c = 0, d = 20, e = 40, f = 30;

   String x = "Thank", y = "You";

   // + and - operator

   System.out.println("a + b = "+(a + b));

   System.out.println("a - b = "+(a - b));

   // + operator if used with strings

   // concatenates the given strings.

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

   // * and / operator

   System.out.println("a * b = "+(a * b));

   System.out.println("a / b = "+(a / b));

   // modulo operator gives remainder

   // on dividing first operand with second

   System.out.println("a % b = "+(a % b));

   // if denominator is 0 in division

   // then Arithmetic exception is thrown.

   // uncommenting below line would throw

   // an exception

   // System.out.println(a/c);

   הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה

   XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
   Run
   Output:

   a+b = 30
   a-b = 10
   x+y = ThankYou
   a*b = 200
   a/b = 2
   a%b = 0
   

2. Unary Operators: Unary operators needs only one operand. They are used to increment, decrement or negate a value.
   
   • - :Unary minus, used for negating the values.
   
   
   • + :Unary plus, used for giving positive values. Only used when deliberately converting a negative value to positive.
   
   
   • ++ :Increment operator, used for incrementing the value by 1. There are two varieties of increment operator.
     
     • Post-Increment : Value is first used for computing the result and then incremented.
     • Pre-Increment : Value is incremented first and then result is computed.
   
   
   • -- : Decrement operator, used for decrementing the value by 1. There are two varieties of decrement operator.
     
     • Post-decrement : Value is first used for computing the result and then decremented.
     • Pre-Decrement : Value is decremented first and then result is computed.
   
   
   • ! : Logical not operator, used for inverting a boolean value.
   1

   2

   3

   4

   5

   6

   7

   8

   9

   10

   11

   12

   13

   14

   15

   16

   17

   18

   19

   20

   21

   22

   23

   24

   25

   26

   27

   28

   29

   30

   31

   // Java program to illustrate

   // unary operators

   public class operators

   {

   public static void main(String[] args)

   {

   int a = 20, b = 10, c = 0, d = 20, e = 40, f = 30;

   boolean condition = true;

   // pre-increment operator

   // a = a+1 and then c = a;

   c = ++a;

   System.out.println("Value of c (++a) = " + c);

   // post increment operator

   // c=b then b=b+1

   c = b++;

   System.out.println("Value of c (b++) = " + c);

   // pre-decrement operator

   // d=d-1 then c=d

   c = --d;

   System.out.println("Value of c (--d) = " + c);

   // post-decrement operator

   // c=e then e=e-1

   c = e--;

   System.out.println("Value of c (e--) = " + c);

   // Logical not operator

   הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה

   XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
   Run
   Output:

   Value of c (++a) = 21
   Value of c (b++) = 10
   Value of c (--d) = 19
   Value of c (e--) = 40
   Value of !condition =false
   

3. Assignment Operator : '=' Assignment operator is used to assign a value to any variable. It has a right to left associativity, i.e value given on right hand side of operator is assigned to the variable on the left and therefore right hand side value must be declared before using it or should be a constant.
   General format of assignment operator is,
   

   variable = value;

   In many cases assignment operator can be combined with other operators to build a shorter version of statement called Compound Statement. For example, instead of a = a+5 , we can write a += 5.
   
   • +=, for adding left operand with right operand and then assigning it to variable on the left.
   • -=, for subtracting left operand with right operand and then assigning it to variable on the left.
   • *=, for multiplying left operand with right operand and then assigning it to variable on the left.
   • /=, for dividing left operand with right operand and then assigning it to variable on the left.
   • %=, for assigning modulo of left operand with right operand and then assigning it to variable on the left.

   int a = 5;
   a += 5; //a = a+5;
   

   1

   2

   3

   4

   5

   6

   7

   8

   9

   10

   11

   12

   13

   14

   15

   16

   17

   18

   19

   20

   21

   22

   23

   24

   25

   26

   27

   28

   29

   30

   31

   // Java program to illustrate

   // assignment operators

   public class operators

   {

   public static void main(String[] args)

   {

   int a = 20, b = 10, c, d, e = 10, f = 4, g = 9;

   // simple assignment operator

   c = b;

   System.out.println("Value of c = " + c);

   // This following statement would throw an exception

   // as value of right operand must be initialised

   // before assignment, and the program would not

   // compile.

   // c = d;

   // instead of below statements,shorthand

   // assignment operators can be used to

   // provide same functionality.

   a = a + 1;

   b = b - 1;

   e = e * 2;

   f = f / 2;

   System.out.println("a,b,e,f = " + a + ","

   + b + "," + e + "," + f);

   a = a - 1;

   b = b + 1;

   e = e / 2;

   הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה

   XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
   Run
   Output :

   Value of c =10
   a,b,e,f = 21,9,20,2
   a,b,e,f (using shorthand operators)= 21,9,20,2
   

4. Relational Operators : These operators are used to check for relations like equality, greater than, less than. They return boolean result after the comparison and are extensively used in looping statements as well as conditional if else statements. General format is,
   

   variable relation_operator value 

   Some of the relational operators are-
   
   • == , Equal to : returns true of left hand side is equal to right hand side.
   • != , Not Equal to : returns true of left hand side is not equal to right hand side.
   • < , less than : returns true of left hand side is less than right hand side.
   • <= , less than or equal to : returns true of left hand side is less than or equal to right hand side.
   • > , Greater than : returns true of left hand side is greater than right hand side.
   • >= , Greater than or equal to: returns true of left hand side is greater than or equal to right hand side.
   
   
   1

   2

   3

   4

   5

   6

   7

   8

   9

   10

   11

   12

   13

   14

   15

   16

   17

   18

   19

   20

   21

   22

   23

   24

   25

   26

   27

   28

   29

   30

   // Java program to illustrate

   // relational operators

   public class operators

   {

   public static void main(String[] args)

   {

   int a = 20, b = 10;

   String x = "Thank", y = "Thank";

   int ar[] = { 1, 2, 3 };

   int br[] = { 1, 2, 3 };

   boolean condition = true;

   //various conditional operators

   System.out.println("a == b :" + (a == b));

   System.out.println("a < b :" + (a < b));

   System.out.println("a <= b :" + (a <= b));

   System.out.println("a > b :" + (a > b));

   System.out.println("a >= b :" + (a >= b));

   System.out.println("a != b :" + (a != b));

   // Arrays cannot be compared with

   // relational operators because objects

   // store references not the value

   System.out.println("x == y : " + (ar == br));

   System.out.println("condition==true :" + (condition == true));

   }

   }

   הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה

   XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
   Run
   Output :

   a == b :false
   a < b :false
   a <= b :false
   a > b :true
   a >= b :true
   a != b :true
   x == y : false
   condition==true :true
   

5. Logical Operators : These operators are used to perform "logical AND" and "logical OR" operation, i.e. the function similar to AND gate and OR gate in digital electronics. One thing to keep in mind is the second condition is not evaluated if the first one is false, i.e. it has short-circuiting effect. Used extensively to test for several conditions for making a decision.
   Conditional operators are-
   • && , Logical AND : returns true when both conditions are true.
   • || , Logical OR : returns true if at least one condition is true.
   1

   2

   3

   4

   5

   6

   7

   8

   9

   10

   11

   12

   13

   14

   15

   16

   17

   18

   19

   20

   21

   22

   23

   24

   25

   26

   27

   // Java program to illustrate

   // logical operators

   public class operators

   {

   public static void main(String[] args)

   {

   String x = "Sher";

   String y = "Locked";

   Scanner s = new Scanner(System.in);

   System.out.print("Enter username:");

   String uuid = s.next();

   System.out.print("Enter password:");

   String upwd = s.next();

   // Check if user-name and password match or not.

   if ((uuid.equals(x) && upwd.equals(y)) ||

   (uuid.equals(y) && upwd.equals(x))) {

   System.out.println("Welcome user.");

   } else {

   System.out.println("Wrong uid or password");

   }

   }

   }

   הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה

   XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
   Run
   Output :

   Enter username:Sher
   Enter password:Locked
   Welcome user.
   

6. Ternary operator : Ternary operator is a shorthand version of if-else statement. It has three operands and hence the name ternary. General format is-
   

   condition ? if true : if false

   The above statement means that if the condition evaluates to true, then execute the statements after the '?' else execute the statements after the ':'.
   
   1

   2

   3

   4

   5

   6

   7

   8

   9

   10

   11

   12

   13

   14

   15

   16

   17

   18

   // Java program to illustrate

   // max of three numbers using

   // ternary operator.

   public class operators

   {

   public static void main(String[] args)

   {

   int a = 20, b = 10, c = 30, result;

   //result holds max of three

   //numbers

   result = ((a > b) ? (a > c) ? a :

   c : (b > c) ? b : c);

   System.out.println("Max of three numbers = "+result);

   }

   }

   הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה

   XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
   Run
   Output :

   Max of three numbers = 30
   

7. Bitwise Operators : These operators are used to perform manipulation of individual bits of a number. They can be used with any of the integer types. They are used when performing update and query operations of Binary indexed tree.
   
   • & , Bitwise AND operator: returns bit by bit AND of input values.
   • | , Bitwise OR operator: returns bit by bit OR of input values.
   • ^ , Bitwise XOR operator: returns bit by bit XOR of input values.
   • ~ , Bitwise Complement Operator: This is a unary operator which returns the one's compliment representation of the input value, i.e. with all bits inversed.
   1

   2

   3

   4

   5

   6

   7

   8

   9

   10

   11

   12

   13

   14

   15

   16

   17

   18

   19

   20

   21

   22

   23

   24

   25

   26

   27

   28

   29

   30

   31

   // Java program to illustrate

   // bitwise operators

   public class operators

   {

   public static void main(String[] args)

   {

   //if int a = 010 java considers it as octal value of 8 as number starts with 0.

   int a = 0x0005;

   int b = 0x0007;

   // bitwise and

   // 0101 & 0111=0101

   System.out.println("a&b = " + (a & b));

   // bitwise and

   // 0101 | 0111=0111

   System.out.println("a|b = " + (a | b));

   // bitwise xor

   // 0101 ^ 0111=0010

   System.out.println("a^b = " + (a ^ b));

   // bitwise and

   // ~0101=1010

   System.out.println("~a = " + ~a);

   // can also be combined with

   // assignment operator to provide shorthand

   // assignment

   // a=a&b

   הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה

   XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
   Run
   Output :

   a&b = 5
   a|b = 7
   a^b = 2
   ~a = -6
   a= 5
   



8. Shift Operators :These operators are used to shift the bits of a number left or right thereby multiplying or dividing the number by two respectively. They can be used when we have to multiply or divide a number by two. General format-
   

    number shift_op number_of_places_to_shift;

   • << , Left shift operator: shifts the bits of the number to the left and fills 0 on voids left as a result. Similar effect as of multiplying the number with some power of two.
   • >> , Signed Right shift operator: shifts the bits of the number to the right and fills 0 on voids left as a result. The leftmost bit depends on the sign of initial number. Similar effect as of dividing the number with some power of two.
   • >>> , Unsigned Right shift operator: shifts the bits of the number to the right and fills 0 on voids left as a result. The leftmost bit is set to 0.
   1

   2

   3

   4

   5

   6

   7

   8

   9

   10

   11

   12

   13

   14

   15

   16

   17

   18

   19

   20

   21

   22

   23

   24

   25

   26

   27

   // Java program to illustrate

   // shift operators

   public class operators

   {

   public static void main(String[] args)

   {

   int a = 0x0005;

   int b = -10;

   // left shift operator

   // 0000 0101<<2 =0001 0100(20)

   // similar to 5*(2^2)

   System.out.println("a<<2 = " + (a << 2));

   // right shift operator

   // 0000 0101 >> 2 =0000 0001(1)

   // similar to 5/(2^2)

   System.out.println("a>>2 = " + (a >> 2));

   // unsigned right shift operator

   System.out.println("b>>>2 = "+ (b >>> 2));

   }

   }

   הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה

   XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
   Run
   Output :

   a2 = 1
   b>>>2 = 1073741821
   

Precedence and Associativity of Operators

Interesting Questions on Operators

1. Precedence and Associativity: There is often a confusion when it comes to hybrid equations that are equations having multiple operators. The problem is which part to solve first. There is a golden rule to follow in these situations. If the operators have different precedence, solve the higher precedence first. If they have the same precedence, solve according to associativity, that is either from right to left or from left to right. Explanation of the below program is well written in comments within the program itself.
   
   1

   2

   3

   4

   5

   6

   7

   8

   9

   10

   11

   12

   13

   14

   15

   16

   17

   18

   19

   public class operators

   {

   public static void main(String[] args)

   {

   int a = 20, b = 10, c = 0, d = 20, e = 40, f = 30;

   // precedence rules for arithmetic operators.

   // (* = / = %) > (+ = -)

   // prints a+(b/d)

   System.out.println("a+b/d = "+(a + b / d));

   // if same precendence then associative

   // rules are followed.

   // e/f -> b*d -> a+(b*d) -> a+(b*d)-(e/f)

   System.out.println("a+b*d-e/f = "+(a + b * d - e / f));

   }

   }

   הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה

   XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
   Run
   Output:

   a+b/d = 20
   a+b*d-e/f = 219
   

2. Be a Compiler: Compiler in our systems uses lex tool to match the greatest match when generating tokens. This creates a bit of problem if overlooked. For example, consider the statement a=b+++c;, to many of the readers this might seem to create compiler error. But this statement is absolutely correct as the token created by lex are a, =, b, ++, +, c. Therefore this statement has similar effect of first assigning b+c to a and then incrementing b. Similarly, a=b+++++c; would generate error as tokens generated are a, =, b, ++, ++, +, c. which is actually a error as there is no operand after second unary operand.
   
   1

   2

   3

   4

   5

   6

   7

   8

   9

   10

   11

   12

   13

   14

   15

   16

   17

   18

   19

   20

   21

   public class operators

   {

   public static void main(String[] args)

   {

   int a = 20, b = 10, c = 0;

   // a=b+++c is compiled as

   // b++ +c

   // a=b+c then b=b+1

   a = b+++c;

   System.out.println("Value of a(b+c),b(b+1),c = " + a + "," + b + "," + c);

   // a=b+++++c is compiled as

   // b++ ++ +c

   // which gives error.

   // a=b+++++c;

   // System.out.println(b+++++c);

   }

   }

   הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה

   XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
   Run
   Output:

   Value of a(b+c),b(b+1),c = 10,11,0
   

3. Using + over (): When using + operator inside system.out.println() make sure to do addition suing parenthesis. If we write something before doing addition, then string addition takes place, that is associativity of addition is left to right and hence integers are added to string first producing a string, and string objects concatenates when using +, therefore it can create unwanted results.
   
   1

   2

   3

   4

   5

   6

   7

   8

   9

   10

   11

   12

   13

   14

   15

   16

   17

   18

   19

   20

   public class operators

   {

   public static void main(String[] args)

   {

   int x = 5, y = 8;

   // concatenates x and y

   // as first x is added to "concatenation (x+y) = "

   // producing "concatenation (x+y) = 5" and then 8 is

   // further concatenated.

   System.out.println("Concatenation (x+y)= " + x + y);

   // addition of x and y

   System.out.println("Addition (x+y) = " + (x + y));

   }

   }

   הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה

   XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
   Run
   Output:

   Concatenation (x+y)= 58
   Addition (x+y) = 13
   

• Problem 1 : Change the case of the character entered. (using operators only).
  
  1

  2

  3

  4

  5

  6

  7

  8

  9

  10

  11

  12

  13

  14

  15

  16

  import java.util.*;

  import java.lang.*;

  import java.io.*;

  class GFG

  {

  public static void main (String[] args)

  {

  char ch1 = 'p', ch2 = 'P';

  System.out.println("Character p changed to: " + (char)((ch1 >= 'a' && ch1 <= 'z') ? (ch1 - 'a' + 'A') : (ch1 - 'A' + 'a')) );

  System.out.println("Character P changed to: " + (char)((ch2 >= 'a' && ch2 <= 'z') ? (ch2 - 'a' + 'A') : (ch2 - 'A' + 'a')) );

  }

  }

  הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה

  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  Run
  
  Output:

  Character p changed to: P
  Character P changed to: p
  

  In the above program, we use ternary-operator to output the character with changed case. If the character ch entered lies between 'a' and 'z', it means it is in lower-case, so we output: (ch - 'a' + 'A'), otherwise, we output (ch - 'A' + 'a').
  
  
• Problem 2 : Write a program to convert temperature given in Celsius (user input) to Fahrenheit.
  
  1

  2

  3

  4

  5

  6

  7

  8

  9

  10

  11

  12

  13

  14

  15

  16

  17

  18

  19

  #include <bits/stdc++.h>

  using namespace std;

  import java.util.*;

  import java.lang.*;

  import java.io.*;

  class GFG

  {

  public static void main (String[] args)

  {

  int cel1 = 47;

  int cel2 = 29;

  System.out.printf("47 deg Celsius in Fahrenheit: %.2f\n", (9.0/5*cel1 + 32) );

  System.out.printf("29 deg Celsius in Fahrenheit: %.2f\n", (9.0/5*cel2 + 32) );

  }

  }

  הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה

  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  Run
  
  Output:

  47 deg Celsius in Fahrenheit: 116.6
  29 deg Celsius in Fahrenheit: 84.2
  

  The above program is a good example of implicit type-casting in C++. Conversion of temperatures is a floating point operation. Thus, we need to have one operand as a double. i.e. 9.0 here. Otherwise, (9/5) would yield 1 and not 1.8. Once, we have converted the literal operands to a double, automatically cel1 and cel2 gets type-casted. This behaviour is also termed as up-casting.
  


• Problem 3 : Write a program to find the area of a triangle. Take the length of sides as user input. (Area printed should be rounded off to two decimal places).
  
  1

  2

  3

  4

  5

  6

  7

  8

  9

  10

  11

  12

  13

  14

  15

  16

  17

  18

  19

  20

  21

  import java.util.*;

  import java.lang.*;

  import java.io.*;

  import java.lang.Math;

  class GFG

  {

  public static void main (String[] args)

  {

  int a = 6, b = 8, c = 10;

  //We shall use heron's formula to calculate triangle area

  double s = (a + b + c)/2.0;

  double area = Math.sqrt(s*(s-a)*(s-b)*(s-c));

  System.out.printf("Area of the Triangle : %.2f\n",area);

  }

  }

  הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה

  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  Run
  
  Output:

  24.00
  

  Above program uses Heron's formula for calculating the area of a triangle. Similar to the previous example, we here divide by 2.0 to upcast the integral lengths to yield a final double s value.
  


• Problem 4 : Take user input amount of money and consider an infinite supply of denominations 1, 20, 50 and 100. What is the minimum number of denominations to make the change?
  
  1

  2

  3

  4

  5

  6

  7

  8

  9

  10

  11

  12

  13

  14

  15

  16

  17

  18

  19

  20

  21

  22

  23

  24

  25

  26

  27

  28

  29

  30

  31

  import java.util.*;

  import java.lang.*;

  import java.io.*;

  import java.lang.Math;

  class GFG

  {

  public static void main (String[] args)

  {

  int amt = 253, q, ans=0;

  //To calculate min. no. of denominations

  //we need to first divide by 100

  //then, by 50

  //then by 20

  //then the rest of the amount can be made using 1

  //add notes of 100 required

  q = amt / 100;

  ans += q;

  amt -= q*100;

  //add notes of 50 required

  q = amt/50;

  ans += q;

  amt -= q*50;

  //add notes of 20 required

  q = amt/20;

  ans += q;

  amt -= q*20;

  הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה

  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  Run
  
  Output:

  Min. notes to get a sum of 253: 6
  

  In this problem, we have been given the relaxation of having an unlimited supply of the said denominations. Hence, to make it possible with the minimum number of notes in total, we try to accommodate the sum in the decreasing order of value. i.e. We try out first with 100, then the remaining amount with 50, then 20 and finally the remaining amount can be made up using 1s.
  

• if
• if-else
• nested-if
• if-else-if
• switch-case
• jump - break, continue, return

• if: if statement is the most simple decision making statement. It is used to decide whether a certain statement or block of statements will be executed or not i.e if a certain condition is true then a block of statement is executed otherwise not.
  Syntax:
  

  if(condition) 
  {
     // Statements to execute if
     // condition is true
  }
  

  Here, condition after evaluation will be either true or false. if statement accepts boolean values - if the value is true then it will execute the block of statements under it.
  If we do not provide the curly braces '{' and '}' after if( condition ) then by default if statement will consider the immediate one statement to be inside its block. For example,
  

  if(condition)
     statement1;
     statement2;
  
  // Here if the condition is true, if block 
  // will consider only statement1 to be inside 
  // its block.
  

  Flow chart:
  
  Example:
  
  
  1

  2

  3

  4

  5

  6

  7

  8

  9

  10

  11

  12

  13

  14

  15

  16

  17

  // Java program to illustrate If statement

  class IfDemo

  {

  public static void main(String args[])

  {

  int i = 10;

  if (i > 15)

  System.out.println("10 is less than 15");

  // This statement will be executed

  // as if considers one statement by default

  System.out.println("I am Not in if");

  }

  }

  הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה

  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  Run
  Output:
  

  I am Not in if
  

• if-else: The if statement alone tells us that if a condition is true it will execute a block of statements and if the condition is false it won't. But what if we want to do something else if the condition is false. Here comes the else statement. We can use the else statement with if statement to execute a block of code when the condition is false.
  Syntax:
  

  if (condition)
  {
      // Executes this block if
      // condition is true
  }
  else
  {
      // Executes this block if
      // condition is false
  }
  

  
  Example:
  
  
  1

  2

  3

  4

  5

  6

  7

  8

  9

  10

  11

  12

  13

  14

  15

  // Java program to illustrate if-else statement

  class IfElseDemo

  {

  public static void main(String args[])

  {

  int i = 10;

  if (i < 15)

  System.out.println("i is smaller than 15");

  else

  System.out.println("i is greater than 15");

  }

  }

  הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה

  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  Run
  Output:
  

  i is smaller than 15




• if-else-if ladder: Here, a user can decide among multiple options.The if statements are executed from the top down. As soon as one of the conditions controlling the if is true, the statement associated with that if is executed, and the rest of the ladder is bypassed. If none of the conditions is true, then the final else statement will be executed.
  

  if (condition)
      statement;
  else if (condition)
      statement;
  .
  .
  else
      statement;
  

  
  Example:
  
  
  1

  2

  3

  4

  5

  6

  7

  8

  9

  10

  11

  12

  13

  14

  15

  16

  17

  18

  19

  // Java program to illustrate if-else-if ladder

  class ifelseifDemo

  {

  public static void main(String args[])

  {

  int i = 20;

  if (i == 10)

  System.out.println("i is 10");

  else if (i == 15)

  System.out.println("i is 15");

  else if (i == 20)

  System.out.println("i is 20");

  else

  System.out.println("i is not present");

  }

  }

  הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה

  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  Run
  Output:
  

  i is 20
  

• switch-case The switch statement is a multiway branch statement. It provides an easy way to dispatch execution to different parts of code based on the value of the expression.
  Syntax:
  

  switch (expression)
  {
    case value1:
      statement1;
      break;
    case value2:
      statement2;
      break;
    .
    .
    case valueN:
      statementN;
      break;
    default:
      statementDefault;
  }
  

  • Expression can be of type byte, short, int char or an enumeration. Beginning with JDK7, expression can also be of type String.
  • Dulplicate case values are not allowed.
  • The default statement is optional.
  • The break statement is used inside the switch to terminate a statement sequence.
  • The break statement is optional. If omitted, execution will continue on into the next case.
  
  Example:
  
  
  1

  2

  3

  4

  5

  6

  7

  8

  9

  10

  11

  12

  13

  14

  15

  16

  17

  18

  19

  20

  21

  22

  23

  24

  // Java program to illustrate switch-case

  class SwitchCaseDemo

  {

  public static void main(String args[])

  {

  int i = 9;

  switch (i)

  {

  case 0:

  System.out.println("i is zero.");

  break;

  case 1:

  System.out.println("i is one.");

  break;

  case 2:

  System.out.println("i is two.");

  break;

  default:

  System.out.println("i is greater than 2.");

  }

  }

  }

  הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה

  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  Run
  
  Output:
  

  i is greater than 2.
  

• jump: Java supports three jump statement: break, continue and return. These three statements transfer control to other part of the program.
  
  1. Break: In Java, break is majorly used for:
     
     • Terminate a sequence in a switch statement (discussed above).
     • To exit a loop.
     • Used as a "civilized" form of goto.

     Using break to exit a Loop

     Using break, we can force immediate termination of a loop, bypassing the conditional expression and any remaining code in the body of the loop.
     Note: Break, when used inside a set of nested loops, will only break out of the innermost loop.
     
     Example:
     
     
     1

     2

     3

     4

     5

     6

     7

     8

     9

     10

     11

     12

     13

     14

     15

     16

     17

     18

     19

     20

     // Java program to illustrate using

     // break to exit a loop

     class BreakLoopDemo

     {

     public static void main(String args[])

     {

     // Initially loop is set to run from 0-9

     for (int i = 0; i < 10; i++)

     {

     // terminate loop when i is 5.

     if (i == 5)

     break;

     System.out.println("i: " + i);

     }

     System.out.println("Loop complete.");

     }

     }

     הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה

     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
     Run
     Output:
     

     i: 0
     i: 1
     i: 2
     i: 3
     i: 4
     Loop complete.
     

     Using break as a Form of Goto

     Java does not have a goto statement because it provides a way to branch in an arbitrary and unstructured manner. Java uses label. A Label is use to identifies a block of code.
     Syntax:
     

     label:
     {
       statement1;
       statement2;
       statement3;
       .
       .
     }
     

     Now, break statement can be use to jump out of target block.
     Note: You cannot break to any label which is not defined for an enclosing block.
     Syntax:
     

     break label;
     

     Example:
     
     1

     2

     3

     4

     5

     6

     7

     8

     9

     10

     11

     12

     13

     14

     15

     16

     17

     18

     19

     20

     21

     22

     23

     24

     25

     26

     27

     28

     29

     30

     31

     // Java program to illustrate using break with goto

     class BreakLabelDemo

     {

     public static void main(String args[])

     {

     boolean t = true;

     // label first

     first:

     {

     // Illegal statement here as label second is not

     // introduced yet break second;

     second:

     {

     third:

     {

     // Before break

     System.out.println("Before the break statement");

     // break will take the control out of

     // second label

     if (t)

     break second;

     System.out.println("This won't execute.");

     }

     System.out.println("This won't execute.");

     }

     // Third block

     System.out.println("This is after second block.");

     הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה

     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
     Run
     Output:
     

     Before the break.
     This is after second block.
     

  2. Continue: Sometimes it is useful to force an early iteration of a loop. That is, you might want to continue running the loop but stop processing the remainder of the code in its body for this particular iteration. This is, in effect, a goto just past the body of the loop, to the loop's end. The continue statement performs such an action.
     
     Example:
     
     
     1

     2

     3

     4

     5

     6

     7

     8

     9

     10

     11

     12

     13

     14

     15

     16

     17

     18

     19

     20

     // Java program to illustrate using

     // continue in an if statement

     class ContinueDemo

     {

     public static void main(String args[])

     {

     for (int i = 0; i < 10; i++)

     {

     // If the number is even

     // skip and continue

     if (i%2 == 0)

     continue;

     // If number is odd, print it

     System.out.print(i + " ");

     }

     }

     }

     הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה

     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
     Run
     Output:
     

     1 3 5 7 9 
     

  3. Return:The return statement is used to explicitly return from a method. That is, it causes a program control to transfer back to the caller of the method.
     Example:
     
     
     1

     2

     3

     4

     5

     6

     7

     8

     9

     10

     11

     12

     13

     14

     15

     16

     17

     18

     // Java program to illustrate using return

     class Return

     {

     public static void main(String args[])

     {

     boolean t = true;

     System.out.println("Before the return.");

     if (t)

     return;

     // Compiler will bypass every statement

     // after return

     System.out.println("This won't execute.");

     }

     }

     הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה

     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
     Run
     Output:
     

     Before the return.
     

1. while loop: A while loop is a control flow statement that allows code to be executed repeatedly based on a given Boolean condition. The while loop can be thought of as a repeating if statement.
   Syntax :

   while (boolean condition)
   {
      loop statements...
   }
   

   
   Flowchart:
   
   • While loop starts with the checking of condition. If it evaluated to true, then the loop body statements are executed otherwise first statement following the loop is executed. For this reason it is also called Entry control loop
   • Once the condition is evaluated to true, the statements in the loop body are executed. Normally the statements contain an update value for the variable being processed for the next iteration.
   • When the condition becomes false, the loop terminates which marks the end of its life cycle.
   
   
   1

   2

   3

   4

   5

   6

   7

   8

   9

   10

   11

   12

   13

   14

   15

   16

   17

   18

   19

   20

   // Java program to illustrate while loop

   class whileLoopDemo

   {

   public static void main(String args[])

   {

   int x = 1;

   // Exit when x becomes greater than 4

   while (x <= 4)

   {

   System.out.println("Value of x:" + x);

   // Increment the value of x for

   // next iteration

   x++;

   }

   }

   }

   הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה

   XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
   Run
   Output:

   Value of x:1
   Value of x:2
   Value of x:3
   Value of x:4
   



2. for loop: for loop provides a concise way of writing the loop structure. Unlike a while loop, a for statement consumes the initialization, condition and increment/decrement in one line thereby providing a shorter, easy to debug structure of looping.
   Syntax:

   for (initialization condition; testing condition; 
                                 increment/decrement)
   {
       statement(s)
   }
   

   Flowchart:
   
   
   1. Initialization condition: Here, we initialize the variable in use. It marks the start of a for loop. An already declared variable can be used or a variable can be declared, local to loop only.
   2. Testing Condition: It is used for testing the exit condition for a loop. It must return a boolean value. It is also an Entry Control Loop as the condition is checked prior to the execution of the loop statements.
   3. Statement execution: Once the condition is evaluated to true, the statements in the loop body are executed.
   
   
   4. Increment/ Decrement: It is used for updating the variable for next iteration.
   5. Loop termination:When the condition becomes false, the loop terminates marking the end of its life cycle.
   1

   2

   3

   4

   5

   6

   7

   8

   9

   10

   11

   12

   13

   // Java program to illustrate for loop.

   class forLoopDemo

   {

   public static void main(String args[])

   {

   // for loop begins when x=2

   // and runs till x <=4

   for (int x = 2; x <= 4; x++)

   System.out.println("Value of x:" + x);

   }

   }

   הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה

   XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
   Run
   Output:

   Value of x:2
   Value of x:3
   Value of x:4
   

   
   

   Enhanced For loop

   Java also includes another version of for loop introduced in Java 5. Enhanced for loop provides a simpler way to iterate through the elements of a collection or array. It is inflexible and should be used only when there is a need to iterate through the elements in a sequential manner without knowing the index of the currently processed element.
   Also, note that the object/variable is immutable when enhanced for loop is used i.e it ensures that the values in the array can not be modified, so it can be said as a read-only loop where you can't update the values as opposed to other loops where values can be modified.
   
   We recommend using this form of the for statement instead of the general form whenever possible.(as per JAVA doc.)
   Syntax:

   for (T element:Collection obj/array)
   {
       statement(s)
   }
   

   
   Let's take an example to demonstrate how enhanced for loop can be used to simplify the work. Suppose there is an array of names and we want to print all the names in that array. Let's see the difference between these two examples.
   
   Enhanced for loop simplifies the work as follows-
   
   1

   2

   3

   4

   5

   6

   7

   8

   9

   10

   11

   12

   13

   14

   15

   16

   17

   18

   19

   20

   21

   22

   23

   // Java program to illustrate enhanced for loop

   public class enhancedforloop

   {

   public static void main(String args[])

   {

   String array[] = {"Ron", "Harry", "Hermoine"};

   //enhanced for loop

   for (String x:array)

   {

   System.out.println(x);

   }

   /* for loop for same function

   for (int i = 0; i < array.length; i++)

   {

   System.out.println(array[i]);

   }

   */

   }

   }

   הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה

   XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
   Run
   Output:
   

   Ron
   Harry
   Hermoine
   



3. do while: do while loop is similar to while loop with only difference that it checks for condition after executing the statements, and therefore is an example of Exit Control Loop. Syntax:

   do
   {
       statements..
   }
   while (condition);
   

   Flowchart:
   
   1. do while loop starts with the execution of the statement(s). There is no checking of any condition for the first time.
   2. After the execution of the statements, and update of the variable value, the condition is checked for true or false value. If it is evaluated to true, next iteration of loop starts.
   3. When the condition becomes false, the loop terminates which marks the end of its life cycle.
   4. It is important to note that the do-while loop will execute its statements atleast once before any condition is checked, and therefore is an example of exit control loop.
   1

   2

   3

   4

   5

   6

   7

   8

   9

   10

   11

   12

   13

   14

   15

   16

   17

   18

   // Java program to illustrate do-while loop

   class dowhileloopDemo

   {

   public static void main(String args[])

   {

   int x = 21;

   do

   {

   // The line will be printed even

   // if the condition is false

   System.out.println("Value of x:" + x);

   x++;

   }

   while (x < 20);

   }

   }

   הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה

   XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
   Run
   Output:

   Value of x: 21
   

4. For Each Loop For-each is another array traversing technique like for loop, while loop, do-while loop introduced in Java5.
   
   • It starts with the keyword for like a normal for-loop.
   • Instead of declaring and initializing a loop counter variable, you declare a variable that is the same type as the base type of the array, followed by a colon, which is then followed by the array name.
   • In the loop body, you can use the loop variable you created rather than using an indexed array element.
     
   • It's commonly used to iterate over an array or a Collections class (eg, ArrayList)
   
   Syntax:

   for (type var : array) 
   { 
       statements using var;
   }
   

   is equivalent to:

   for (int i=0; i<arr.length; i++) 
   { 
       type var = arr[i];
       statements using var;
   }
   

   1

   2

   3

   4

   5

   6

   7

   8

   9

   10

   11

   12

   13

   14

   15

   16

   17

   18

   19

   20

   21

   22

   23

   24

   25

   26

   27

   28

   29

   30

   // Java program to illustrate

   // for-each loop

   class For_Each

   {

   public static void main(String[] arg)

   {

   {

   int[] marks = { 125, 132, 95, 116, 110 };

   int highest_marks = maximum(marks);

   System.out.println("The highest score is " + highest_marks);

   }

   }

   public static int maximum(int[] numbers)

   {

   int maxSoFar = numbers[0];

   // for each loop

   for (int num : numbers)

   {

   if (num > maxSoFar)

   {

   maxSoFar = num;

   }

   }

   return maxSoFar;

   }

   }

   הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה

   XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
   Run
   Output:
   

   The highest score is 132
   

Pitfalls of Loops

1. Infinite loop: One of the most common mistakes while implementing any sort of looping is that that it may not ever exit, that is the loop runs for infinite time. This happens when the condition fails for some reason.
   Examples:
   
   1

   2

   3

   4

   5

   6

   7

   8

   9

   10

   11

   12

   13

   14

   15

   16

   17

   18

   19

   20

   21

   22

   23

   24

   //Java program to illustrate various pitfalls.

   public class LooppitfallsDemo

   {

   public static void main(String[] args)

   {

   // infinite loop because condition is not apt

   // condition should have been i>0.

   for (int i = 5; i != 0; i -= 2)

   {

   System.out.println(i);

   }

   int x = 5;

   // infinite loop because update statement

   // is not provided.

   while (x == 5)

   {

   System.out.println("In the loop");

   }

   }

   }

   הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה

   XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
   Run

2. Another pitfall is that you might be adding something into you collection object through loop and you can run out of memory. If you try and execute the below program, after some time, out of memory exception will be thrown.
   
   1

   2

   3

   4

   5

   6

   7

   8

   9

   10

   11

   12

   13

   14

   15

   //Java program for out of memory exception.

   import java.util.ArrayList;

   public class Integer1

   {

   public static void main(String[] args)

   {

   ArrayList<Integer> ar = new ArrayList<>();

   for (int i = 0; i < Integer.MAX_VALUE; i++)

   {

   ar.add(i);

   }

   }

   }

   הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה

   XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
   Run
   Output:

   Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
   at java.util.Arrays.copyOf(Unknown Source)
   at java.util.Arrays.copyOf(Unknown Source)
   at java.util.ArrayList.grow(Unknown Source)
   at java.util.ArrayList.ensureCapacityInternal(Unknown Source)
   at java.util.ArrayList.add(Unknown Source)
   at article.Integer1.main(Integer1.java:9)
   

Method Declaration

• Modifier-: Defines access type of the method i.e. from where it can be accessed in your application. In Java, there 4 type of the access specifiers.
  
  
  
  • public: accessible in all class in your application.
  • protected: accessible within the class in which it is defined and in its subclass(es)
  • private: accessible only within the class in which it is defined.
  • default (declared/defined without using any modifier) : accessible within same class and package within which its class is defined.
• The return type : The data type of the value returned by the the method or void if does not return a value.
• Method Name : the rules for field names apply to method names as well, but the convention is a little different.
• Parameter list : Comma separated list of the input parameters are defined, preceded with their data type, within the enclosed parenthesis. If there are no parameters, you must use empty parentheses ().
• Exception list : The exceptions you expect by the method can throw, you can specify these exception(s).
• Method body : it is enclosed between braces. The code you need to be executed to perform your intended operations.

 max(int x, int y) 

Calling a method

• It completes all the statements in the method
• It reaches a return statement
• Throws an exception