Java Overview:
• Java developed by James Gosling at Sun Microsystems and released in
1995.
• Java is a high-level, class-based, object-oriented programming language.
• The Java Runtime Environment, or JRE, is a software layer that runs on top
of a computer’s operating system software and provides the class libraries
and other resources that a specific Java program requires to run.
• Java Runtime Environment (JRE) includes JVM, class libraries, and other
supporting files.
o JRE = JVM + Core Java API libraries
o JDK = JRE + development tools like compilers
• Java Virtual Machine (JVM): The JVM is like a translator. It takes the Java code
and translates it into instructions that the computer's operating system can
understand.
o JVM then interprets this bytecode and converts it into machine code
(specific to the computer you're running the program on).
o Bytecode is an intermediate code generated by the compiler and
interpreted by JVM into machine code.
➢ Compilation: Source code → Bytecode(through compiler)
➢ Interpretation: Bytecode → Machine code (through JVM)
Java Features
• The basic features that make Java a powerful, object-oriented, and
popular programming language are:
1. Platform Independence
2. Object Oriented
3. Both Compiled and Interpreted
4. Java is Robust
5. JAVA Language Security Features
6. Java is Multithreaded
Java Programming Constructs:
Variables:
• Variables are containers for storing data values.
• In other words, variable is a name refer to a memory location used
to store values.
• Java declares its variables in the following manner:
Primitive Data Types:
• Primitive data types are the basic building blocks of any
programming language.
• There are eight primitive data types in Java, as follows:
Non-Primitive Data Types
Non-primitive data types are called reference types because they refer to
objects.
The main differences between primitive and non-primitive data types are:
• Primitive types in Java are predefined and built into the language,
while non-primitive types are created by the programmer (except
for String).
• Non-primitive types can be used to call methods to perform certain
operations, whereas primitive types cannot.
• Primitive types start with a lowercase letter (like int), while non-
primitive types typically starts with an uppercase letter (like String).
• Primitive types always hold a value, whereas non-primitive types can
be null.
• Examples of non-primitive types are Strings, Arrays, Classes etc.
Literals
• Literal is a value assigned to variables or constant.
• Literals can be
o numeric
o boolean
o character
o string notations or
o null literals.
➢ Numeric Literals can be represented in
o binary,
o decimal,
o octal, or
o hexadecimal notations.
Binary literals are a combination of 0’s Octal literals must be prefixed with a
and 1’s. zero and only digits from 0 to 7 are
Binary literals must be prefixed with allowed.
0b or 0B (zerob or zeroB). For example,
For example,
int x = 011;//value in x is 9
int bin1 = 0b1010001; // value in bin1
will be 81
Hexadecimal literals are prefixed with Integer literals are of type int, by
0x or 0X; the digits 0 through 9 and a default. To define them as long, we can
through f (or A through F) are only place a suffix of L or l after the number.
allowed. Example:
Example: long l = 2345678998L;
int y = 0x0001; //value in y is 1
Floating literals are of type double, by default. To define them as float literals,
we need to attach the suffix F or f. For double literals, D or d are suffixed at the
end; however, it is optional.
Example:
float f = 23.6F;
double d = 23.6;
➢ Boolean Literals: Boolean literals can only have two values: true or
false. By default, it takes the value false.
Examples:
booleanisJavaFun = true;
booleanisTired = false;
➢ char literals: is single character is enclosed in single quotes.
Example:
char sample = 'A';
char example = 'a';
➢ String literals: consist of zero or more characters within double
quotes.
Example:
String s = "This is a String Literal";
➢ Null Literal: Null literal is used to represent the null reference
(absence of a value for an object).
Example:
String name = null; // Null literal
Operators
• Operator in Java is a symbol that is used to perform operations.
• An operator performs an action on one or more operands.
• Java provides below operators.
1) Binary Operator
2) Unary Operators
3) Ternary Operators
1. Binary Operator:
• Assignment Operator:
• Arithmetic Operator:
• Relational Operator:
• Logical Operator:
➢ Assignment Operator:
• Assignment Operator is used to assign a value to any variable.
• It has right-to-left associativity, i.e. value given on the right-hand
side of the operator is assigned to the variable on the left.
• Below are assignment operators available in Java.
1. =, Assign.
2. += , Add and assign.
3. -= , Subtract and assign.
4. *= , Multiply and assign.
5. /= , Divide and assign.
6. %= , Modulo and assign.
Example:
➢ Arithmetic Operator:
• Arithmetic Operators are used to perform simple arithmetic
operations.
1. * : Multiplication
2. / : Division
3. % : Modulo
4. + : Addition
5. – : Subtraction
➢ Relational Operator:
• Relational operators in Java return either true or false as a Boolean
type.
• Relational operators compare values and return Boolean results:
1) == , Equal to.
2) != , Not equal to.
3) < , Less than.
4) <= , Less than or equal to.
5) > , Greater than.
6) >= , Greater than or equal to.
➢ Logical Operator:
• Logical Operators are primarily used in decision-making and control
flow, allowing multiple conditions to be combined or negated.
o Logical AND (&&):
o Logical OR (||):
o Logical NOT (!):
1. Logical AND (&&):
• Returns true only if both conditions are true.
• If either condition is false, the result is false.
2. Logical OR (||):
• Returns true if at least one condition is true.
• If both conditions are false, the result is false.
3. Logical NOT (!):
• Reverses the boolean value of an expression.
• If a condition is true,makes it false, and vice versa.
Example:
2. Unary Operator:
• Unary operators, as the name suggest, are applied to only one
operand.
• They are as follows: ++, - -, !, and ~.
➢ Increment and Decrement Operators:
• Increment and decrement operators can be applied to all integers
and floating-point types. They can be used either in prefix (– –x, ++x)
or postfix (x– –, x++) mode.
Prefix Increment/Decrement Operation
int x = 2;
int y = ++x; // x = 3, y = 3
Postfix Increment/Decrement Operation
int x = 2;
int y = x++; // x == 3, y == 2
➢ Boolean logical not (!):
• Inverts the boolean value of an operand.
boolean flag = true;
System.out.println(!flag); // Output: false
➢ Bitwise logical not (~):
• Inverts all bits of the operand (works with integers).
int num = 5; // Binary: 00000000 00000000 00000000 00000101
int result = ~num; // Binary: 11111111 11111111 11111111 11111010
(Decimal: -6)
3. Ternary Operator:
• The ternary operator (? :) consists of three operands.
• The operator decides which value will be assigned to the variable.
• It’s a one-liner replacement for the if -else statement
• We can use the ternary operator in place of if-else conditions.
Syntax:
variable = (condition) ? expression1 : expression2
• The above statement states that if the condition is true,
expression1 gets executed, else the expression2 gets executed and
the final result stored in a variable.
Example:
package First_Package;
public class New_class {
public static void main(String[] args) {
int marks = 75;
String grade;
grade = (marks >= 40) ? "Pass" : "Fail";
System.out.println("Result: " + grade);
}
}
Flow of Control
• Control flow statements are used to control the flow of execution of
a program based on certain conditions.
• The four categories of control flow statements available in Java are:
1) Conditional statement
2) Loops
3) Exception
4) Branch.
1. Conditional Statements:
• The two conditional statements provided by Java are:
a) If…else
b) Switch-case
a) If…else:
• It is commonly used when you have multiple conditions to evaluate.
• You can have n number of else if (){} statements in your program, as
per your requirement.
Syntax:
if (condition1)
{
// Lines of code
}
else if(condition2)
{
// Lines of code
}
………
else
{
// Lines of code
}
Example:
package First_Package;
public class First_Program {
public static void main(String[] args) {
int number=5;
if(number > 0)
{
System.out.println(number + " is positive");
}
else if (number < 0)
{
System.out.println(number + " is negative");
}
else
{
System.out.println("The Number is Zero");
}
}
}
• The if...else condition can also be nested as shown.
if (condition)
{
if (condition)
{
//Lines of code
}
}
b) Switch-case:
• Java has a shorthand for multiple if statement—the switch-case
statement.
• Here is how we can write the above program using a switch-case:
Syntax:
switch (x)
{
case 0:
// Lines of code
doSomething0();
break;
case 1:
// Lines of code
doSomething1();
break;
...
case n:
// Lines of code
doSomethingN();
break;
default:
doSomethingElse();
}
Example:
package First_Package;
public class First_Program {
public static void main(String[] args) {
int day=3; // Input: day of the week (1 = Monday, 2 = Tuesday, etc.)
switch (day)
{
case 1:
System.out.println("Monday");
break;
case 2:
System.out.println("Tuesday");
break;
case 3:
System.out.println("Wednesday");
break;
case 4:
System.out.println("Thursday");
break;
case 5:
System.out.println("Friday");
break;
case 6:
System.out.println("Saturday");
break;
case 7:
System.out.println("Sunday");
break;
default:
System.out.println("Invalid day");
}
}
}
2. Loops:
• The purpose of loop statements is to execute Java statements many
times.
• There are three types of loops in Java—
a) For,
b) While, and
c) Do-while.
a) For Loop:
• The for loop groups the following three common parts together into
one statement:
a) Initialization
b) Condition
c) Increment or decrement
Syntax:
for(initialization; condition; increment/decrement)
{
//statement or code to be executed
}
Example:
b) While Loop:
• The while loop is used to repeatedly execute a block of statements
until the specified condition is true.
• Once the condition becomes false, the loop automatically stops.
Syntax:
while (condition)
{
//code to be executed
Increment / decrement
}
Example:
c) Do-while Loop:
• A do-while loop is also used to repeatedly execute a block of
statements. But, in a do-while loop the condition is evaluated at the
end of the iteration. So the do-while will execute at least once and
after that depending upon the condition.
Syntax:
do{
//code to be executed
}while (condition);
Example:
for-each Loop:
• The for-each loop in Java also called the enhanced for loop which
was introduced in Java 5.
• It provides an alternative approach to traverse the array or
collection in Java.
• The advantage of the for-each loop is that it makes the code more
readable.
• The drawback of the enhanced for loop is that it cannot traverse the
elements in reverse order.
• Here, you do not have the option to skip any element because it
does not work on an index basis.
Syntax:
for (type variableName: arrayName)
{
// Statements to repeat
}
Example:
package First_Package;
public class New_class {
public static void main(String[] args) {
int[] numbers = {10, 20, 30, 40, 50};
for (int num : numbers)
{
System.out.println(num);
}
}
}
3. Branching Mechanism:
• Java supports two types of branching statements
1) break
2) continue
a) break Statement:
• The break statement is used to jump out of a loop.
• In other words, break is used to exit from the loop or switch case.
• When break statement is encountered inside a loop, the loop is
immediately terminated and the Program control moves to the next
statement after the loop.
Syntax:
break;
Example:
package First_Package;
public class First_Program {
public static void main(String[] args) {
for (int i = 1; i<= 10; i++)
{
if (i == 5)
{
break;
}
System.out.println("i = " + i);
}
System.out.println("Loop exited.");
}
}
b) Continue Statement:
• Continue statement is used to skip the current iteration and
continues with the next iteration in the loop.
• We can use Java continue statement in all types of loops such as for
loop, while loop and do-while loop.
Syntax:
continue;
Example:
package First_Package;
public class First_Program {
public static void main(String[] args) {
for(int i=1; i<=5 ; i++)
{
if(i == 3)
{
continue;
}
System.out.println("i = " + i);
}
}
