22CS202

JAVA PROGRAMMING
UNIT-1
JAVA FUNDAMENTALS
AN OVERVIEW OF JAVA

WHAT IS JAVA ??
• Programming Language

• High Level Language

• Object –Oriented Language

• Platform- A hardware or software environments in which programs runs.

 HISTORY OF JAVA
• Initially developed by Sun Microsystems Incorporation.
• TEAM NAME: GREEN TEAM
• Led by JAMES GOSLING –in 1991
• Initial Name : Oak

Why JAVA?
• Java was originally designed for interactive television, but it was too advanced
technology for the digital cable television industry at the time.
• However, it was best suited for internet programming.
• Later, Java technology was incorporated by Netscape .
 HISTORY OF JAVA

1) James Gosling, Mike Sheridan, and Patrick Naughton initiated the Java language project in June
1991. The small team of sun engineers called Green Team.
2) Initially it was designed for small, embedded systems in electronic appliances like set-top boxes.
3) Firstly, it was called "Greentalk" by James Gosling, and the file extension was .gt.
4) After that, it was called Oak and was developed as a part of the green project.
Why Java was named as "Oak"?
5) Oak is a symbol of strength and chosen as a national tree of many countries like the U.S.A., France,
Germany, Romania, etc.
6) In 1995, Oak was renamed as "Java" because it was already a trademark by Oak Technologies.
 HISTORY OF JAVA

Why Java Programming named "Java"?

7) The team gathered to choose a new name. The suggested words were "dynamic",
"revolutionary", "Silk", "jolt", "DNA", etc. They wanted something that
• reflected the essence of the technology: revolutionary, dynamic, lively, cool, unique, and easy to
spell, and fun to say.
• According to James Gosling, "Java was one of the top choices along with Silk". Since Java was so
unique, most of the team members preferred Java than other names.
8) Java is an island in Indonesia where the first coffee was produced (called Java
coffee). It is a kind of espresso bean. Java name was chosen by James Gosling while having a
cup of coffee nearby his office.
 HISTORY OF JAVA
9) Notice that Java is just a name, not an acronym.
10)Initially developed by James Gosling at Sun Microsystems (which is now a subsidiary of Oracle
Corporation) and released in 1995.
11) In 1995, Time magazine called Java one of the Ten Best Products of 1995.
JDK 1.0 was released on January 23, 1996.
After the first release of Java, there

• have been many additional features added to the language. Now Java is being
• used in Windows applications, Web applications, enterprise applications, mobile applications, cards, etc.
Each new version adds new features in Java.
 CHARACTERISTICS OF JAVA

1. Simple
❖ Easy to write and more readable and eye catching.
❖ Has concise set of features that makes it easy to learn and use.
❖ Most of the concepts are drew from C++ thus making Java learning simpler.

2. Secure
❖ Cannot harm other system thus making it secure.
❖ Provides a secure means of creating Internet applications.
❖ Provides secure way to access web applications.
 CHARACTERISTICS OF JAVA
3. Portable
❖ Can execute in any environment for which there is a Java run-time system.
❖ (JVM)
❖ Can be run on any platform (Linux,Window,Mac)
❖ Can be transferred over world wide web (e.g. applets)

4. Object-oriented
❖ Java is object-oriented programming language.
❖ Like C++ java provides most of the object oriented features.
❖ Pure OOP Language. (while C++ is semi object oriented)
 CHARACTERISTICS OF JAVA
5. Robust
It uses strong memory management.
❖ There are lack of pointers that avoids security problems.
❖ There is automatic garbage collection in java which runs on the Java Virtual Machine to
get rid of objects which are not being used by a Java application anymore.
❖ There is exception handling and type checking mechanism in java. All these points makes
java robust

6. Multi-threaded
❖ A thread is like a separate program, executing concurrently. We can write Java programs
that deal with many tasks at once by defining multiple threads.
❖ The main advantage of multi-threading is that it doesn't occupy memory for each thread.
It shares a common memory area.
❖ Threads are important for multi-media, Web applications etc.
 CHARACTERISTICS OF JAVA
7. Architecture-neutral
❖ Java is not tied to a specific machine or operating system architecture.
❖ Machine Independent i.e Java is independent of hardware.
❖ Interpreted
❖ Supports cross-platform code through the use of Java bytecode.
❖ Bytecode can be interpreted on any platform by JVM.
8. High performance
❖ Bytecodes are highly optimized.
❖ JVM can executed them much faster.
 CHARACTERISTICS OF JAVA
9. Distributed
❖ Java was designed with the distributed environment.
❖ Java can transmit, run over internet.

10. Dynamic
❖ Java programs carry with them substantial amounts of run-time type information that is
used to verify and resolve accesses to objects at run time.
 JAVA ENVIRONMENT

Three Main Components:

JVM-Java Virtual Machine

JRE-Java Run Time Environment
JDK-Java Development Kit
 JVM(Java Virtual Machine)

 JVM (Java Virtual Machine) is an abstract machine. It is a specification that provides runtime
environment in which java bytecode can be executed .
 When you run the Java program, Java compiler first compiles your Java code to bytecode.
 Then, the JVM translates bytecode into native machine code.
 JRE-JAVA RUNTIME ENVIRONMENT

• JRE (Java Runtime Environment) is a software package that provides Java class libraries, along with Java

Virtual Machine (JVM), and other components to run applications written in Java programming. JRE is the

superset of JVM.
 JDK (Java Development Kit)

•JDK (Java Development Kit) is a software development kit to develop applications in Java. When you
download JDK, JRE is also downloaded, and don't need to download it separately.
•In addition to JRE, JDK also contains number of development tools (compilers, JavaDoc, Java Debugger etc).

• JRE contains JVM and other Java class libraries.

HOW ACTUALLY WORKS
 HOW ACTUALLY WORKS:
JAVA ENVIRONMENT/JAVA ARCHITECTURE

Java programs can typically be developed in five stages:

1. Edit: Use an editor to type the source code (Welcome java)
2. Compile: javac, the Java compiler is used to translate the source code to machine independent,
bytecode Bytecodes are called class file
3. Loading: Class loader loads the bytecodes from class and other libraries file into
main memory
4. Verify: Verifier make sure, whether the bytecodes are valid and do not violate security
restrictions
5. Execute: Java Virtual Machine (uses a combination of interpretation and just in time
compilation to translate bytecodes into machine language Applications are
run on user's machine, i.e., executed by interpreter with java command (java Welcome)
STRUCTURE OF JAVA PROGRAM
FIRST JAVA PROGRAM
 PROGRAM EXPLANATION
❖ class keyword is used to declare a class in java.

❖ public keyword is an access modifier which represents visibility, it means it is visible to all.

❖ static is a keyword, if we declare any method as static, it is known as static method. The core advantage of
static method is that there is no need to create object to invoke the static method. The main method is executed
by the JVM, so it doesn't require to create object to invoke the main method. So it saves memory.
❖ void is the return type of the method, it means it doesn't return any value.

❖ main represents the starting point of the program.

❖ String[] args is used for command line argument.

❖ System.out.println() is used print statement

 EXECUTION OF JAVA PROGRAM

•Java program can be executed using the following means

1.In command prompt
2.IDE

3.Online compilers
Command Prompt Execution
(Refer:https://www.youtube.com/watch?v=zBF1M8dTftk)
1.Download and Install JDK
• (Refer: https://www.oracle.com/java/technologies/javase-downloads.html ) Installed in
C: Program Files Java JDK
2.Save the Source Code in any working space Let Working Space
be
• D:\My Java Programs\Week1
3.Set the Path in Command Prompt
• D:\My Java Programs\Week1> set path = “C:\Program Files\Java\
JDK\Bin”
4.Compile the Source Code
• D:\My Java Programs\Week1> javac Welcome.java
• On successful Compilation Welcome.class (Byte Code) is created
5.Interpret / Execute the Class File (Byte Code)
D:\My Java Programs\Week1> java Welcome
 STEPS FOR COMPILE AND RUN JAVA
PROGRAM

• First Save Java program with same as class name with .java extension.

Example: Sum.java

• Compile: javac Filename.java

 Example : javac Sum.java

• Run by: java Filename

 Example: java sum

 OBJECT ORIENTED PROGRAMMING
• Object Oriented Programming is a paradigm concepts such as class, object, data
inheritance, polymorphism, etc.
Java-
Object
Oriented
 CHARACTERISTICS OF OOP
OBJECT
❖ Object means a real-world entity such as a pen, chair, table, computer, watch, etc.
❖ A Object can be defined as an instance of a class.
❖ Object of the class will have same properties and function as defined in the class
CLASS
Collection of objects is called class. It is a logical entity.
A class can also be defined as a blueprint from which you can create an individual object.
Example of Class and Object
ABSTRACTION
❖ It refers to the act of representing essential feature without including the background details.
❖ It basically hiding unnecessary details from the user.

ENCAPSULATION
❖ The wrapping up of data and methods into single unit.
❖ Data is not accessible outside the class. This can be done access specifiers.
❖ Provides the security that keeps data and methods safe from inadvertent changes.
❖ A java class is the example of encapsulation
INHERITANCE
❖ When one object (derived class) acquires all the properties and behavior's of parent object(base class), it
is known as inheritance.

❖ It provides code reusability

POLYMORPHISM
 Poly refers to many
 The ability to take more than one form.
 In java, we use method overloading and method overriding to achieve polymorphism.
Types of Polymorphism

1. Compile Time Polymorphism (Method Overloading)

2. Run Time Polymorphism(Method Overriding)
SUMMARY OF OOP
 JAVA COMMENTS
• The java comments are statements that are not executed by the compiler and interpreter. The comments can be used to
provide information or explanation about the variable, method, class or any statement.
Types of Java Comments

 Single Line Comment

The single line comment is used to comment only one line.
Syntax:
// This is single line comment

❖ Multi Line Comment

The multi line comment is used to comment multiple lines of code.
Syntax:
/* This is
multi line comment
*/
 DATA TYPES IN JAVA

❖ Data Types in Java Based on the data type of a variable, the operating system allocates
memory and decides what can be stored in the reserved memory.
❖ Therefore, by assigning different data types to variables, you can store integers, decimals, or
characters in these variables.

❖ In java, there are two types of data types

✓ primitive data types

✓ non-primitive data types

DATA TYPES IN JAVA
Data Type and its Range
Boolean Data Type
The Boolean data type is used to store only two possible values: true and false.
This data type is used for simple flags that track true/false conditions.
The Boolean data type specifies one bit of information, but its "size" cannot be defined precisely.
Example:
Boolean one = false;

valid range of values, operators, and operations for boolean variables.

Byte Data Type
The byte data type is an example of a primitive data type. It is an 8-bit signed two's complement integer.
Its value range lies between -128 to 127 (inclusive). Its minimum value is -128 and the maximum value is 127.
Its default value is 0.
The byte data type is used to save memory in large arrays where memory savings is most required. It
saves space because a byte is 4 times smaller than an integer. It can also be used in place of the "int" data type.
Example:
byte a = 10, byte b = -20;

Short Data Type

The short data type is a 16-bit signed two's complement integer. Its value range lies between -32,768 to
32,767 (inclusive). Its minimum value is -32,768 and its maximum value is 32,767. Its default value is 0.
The short data type can also be used to save memory just like the byte data type. A short data type is 2
times smaller than an integer.
Example:
short s = 10000, short r = -5000;
Int Data Type
The int data type is a 32-bit signed two's complement integer. Its value range lies between - 2,147,483,648 (-2^31) to
2,147,483,647 (2^31 -1) (inclusive). Its minimum value is - 2,147,483,648and maximum value is 2,147,483,647. Its default
value is 0.
The int data type is generally used as a default data type for integral values unless there is no problem with memory.
Example:
int a = 100000, int b = -200000;

Long Data Type

The long data type is a 64-bit two's complement integer. Its value-range lies between -9,223,372,036,854,775,808(-
2^63) to 9,223,372,036,854,775,807(2^63 -1)
(inclusive). Its minimum value is - 9,223,372,036,854,775,808and maximum value is 9,223,372,036,854,775,807.
Its default value is 0. The long data type is used when you need a range of values more than those provided by int.
Example:
long a = 100000L, long b = -200000L;
Float Data Type
The float data type is a single-precision 32-bit IEEE 754 floating point. Its value range is unlimited. It is recommended to use a
float (instead of a double) if you need to save memory in large arrays of floating-point numbers. The float data type should never be
used for precise values, such as currency. Its default value is 0.0F.
Example:
float f1 = 234.5f;

Double Data Type

The double data type is a double-precision 64-bit IEEE 754 floating point. Its value range is unlimited. The double data type is
generally used for decimal values just like float. The double data type also should never be used for precise values, such as currency.
Its default value is 0.0d.
Example:
double d1 = 12.3;
Char Data Type
The char data type is a single 16-bit Unicode character. Its value range lies between '\u0000' (or 0) to '\uffff' (or 65,535 inclusive).
The char data type is used to store characters.
Example:
char letterA = 'A';
 VARIABLES

 Java is a statically typed programming language. It means,

all variables must be declared before its use. Java is also a
strictly typed language.
 A variable is a container that holds the value while the
Java program is executed.
 A variable is assigned with a data type.
 Variable is a name of a memory location.
 There are three types of variables in java: local, instance,
and static.
 VARIABLE-NAME
Variable Names:
• Variable names are case sensitive
• A variable's name can be any legal identifier an unlimited
length sequence of Unicode letters and digits, beginning
with a letter, the dollar sign or the underscore character
• Subsequent characters may be letters, digits, dollar signs, or
underscore characters
• White space is not permitted
• keyword or reserved word should not be used as variable
names
• If the name chosen consists of only one word, spell that
word in all lowercase letters. If it consists of more than one
word, capitalize the first letter of each subsequent word
• Example gearRatio and currentGear
• If variable stores a constant value, such as static final int
NUM_GEARS 6 the convention changes slightly,
capitalizing every letter and separating subsequent words
with the underscore character
VARIABLE-TYPE
VARIABLE-VALUES
 VARIABLE DECLARATION

Field / Variable declarations are

composed of three components,
in order:
1. Zero or more modifiers,
such as public or private.
2. The field's type.
3. The field's name.
TYPES OF VARIABLES IN JAVA
 Example

public class VariableDemo {

int data = 50; // instance variable
// static variable
static final int MAXIMUM_DATA = 100;
void method() {
int currentData = 90; // local variable
}
}// end of class
Java-Identifiers
Rules for Naming an Identifiers
 Examples for Identifiers
VALID IDENTIFIERS
INVALID IDENTIFIERS
Examples: Examples:
 TestVariable
 testvariable o Test Variable (We can not include a space in an
identifier)
a
o 123hello (The identifier should not begin with
i numbers)
 Test_Variable o hello+word ( The plus (+) symbol cannot be used)
 _testvariable o a-student ( Hyphen symbol is not allowed)
 $testvariable o hello_&_world (ampersand symbol is not allowed)
 sum_of_array o Java'tpoint (we can not use an apostrophe symbol
 TESTVARIABLE in an identifier)
 jtp123
 JAVA KEYWORDS

❖ Java keywords are also known as reserved words.

❖ Keywords are particular words that act as a key to a code. These are predefined words by Java so they

cannot be used as a variable or object name or class name.

 ARRAY IN JAVA
• Java array is an object which contains elements of a similar data type. Additionally, The elements
of an array are stored in a contiguous memory location. It is a data structure where we store
similar elements. We can store only a fixed set of elements in a Java array.

• Array in Java is index-based, the first element of the array is stored at the 0th index, 2nd element
is stored on 1st index and so on.
 TYPES OF ARRAYS IN JAVA

There are two types of arrays.

 One Dimensional Array

 Multi-Dimensional Array
 One Dimensional Array in Java

Syntax to Declare an Array in Java

• dataType[] arr;
• dataType []arr;
• dataType arr[];

Instantiation of an Array in Java

arrayRefVar=new datatype[size];
 Java Program to illustrate how to declare, instantiate, initialize and traverse
the Java array.

//Program
class Testarray
{
public static void main(String args[]) OUTPUT
{ 10
int a[]=new int[5]; //declaration and instantiation 20
a[0]=10; //initialization 70
a[1]=20; 40
a[2]=70; 50
a[3]=40;
a[4]=50;
//traversing array
for(int i=0;i<a.length;i++) //length is the property of array
System.out.println(a[i]);
}
}
 TWO-DIMENSIONAL ARRAY IN JAVA

 Data is stored in a row and column-based index (also known as matrix form).
SYNTAX
dataType[][] arrayRefVar;
(or)
dataType [][]arrayRefVar;
(or)
dataType arrayRefVar[][];
Example to instantiate Multidimensional Array in Java

 int[][] arr=new int[3][3]; //3 row and 3 column

Example: Matrix Addition
OUTPUT
 ADVANTAGES & DISADVANTAGES

ADVANTAGES

• Code Optimization: It makes the code optimized, we can retrieve or sort the data
efficiently.

• Random access: We can get any data located at an index position.

DISADVANTAGES

• Size Limit: We can store only the fixed size of elements in the array. It doesn't grow its size
at runtime. To solve this problem, collection framework is used in Java which grows
automatically.
Operators
 Operators are the symbols used to perform specific operations. Various
operators can be used for different purposes.
The operators are categorized as:
 Unary
 Arithmetic
 Relational
 Logical
 Ternary
 Assignment
 Bitwise
Unary Operators
Unary operators act upon only one operand and perform operations such
as increment, decrement, negating an expression, or inverting a Boolean value.
Operator Name Description

++ Post increment Increments the value after use

Pre increment Increments the value before use

-- Post increment decrements the value after use

Pre increment decrements the value before use

~ Bitwise complement Flips bits of the value

! Logical negation Inverts the value of a Boolean

Unary Operator Example: ++ and --
Output:
public class OperatorExample
10
{ 12
public static void main(String args[]) 12
{ 10

int x=10;
System.out.println(x++);
System.out.println(++x);
System.out.println(x--);
System.out.println(--x);
}
}
Example: ~ and !
public class OperatorExample
{
public static void main(String args[]) Output:
-11
{
9
int a=10; false
int b=-10; true
boolean c=true;
boolean d=false;
System.out.println(~a);
System.out.println(~b);
System.out.println(!c);
System.out.println(!d);
}}
Example
class Welcome
{
public static void main(String args[])
{
int numOne = 10; int numTwo = 5;
boolean isTrue = true;
System.out.println(numOne++ + " h kj" + ++numOne); //Output will be 10 12
System.out.println(numTwo-- + " " + --numTwo); //Output will be 5 3
System.out.println(!isTrue + " " + ~numOne); //Output will be false -13
}
}
Arithmetic Operators
Arithmetic operators are used to perform basic mathematical operations like addition, subtraction, multiplication, and division.

Operator Description
+ Additive operator (also used for string concatenation)
- Subtractive operator
* Multiplication operator
/ Division operator
% Modulus operator
Example

class Welcome

public static void main(String args[])

int numOne = 10;

int numTwo = 5;

System.out.println(numOne + numTwo); //Output will be 15

System.out.println(numOne - numTwo); //Output will be 5

System.out.println(numOne * numTwo); //Output will be 50

System.out.println(numOne / numTwo); //Output will be 2

System.out.println(numOne % numTwo); //Output will be 0

}
Relational operators
Relational operators are used to compare two values. The result of all the
relational operations is either true or false.

Operator Description
== Equal to
< Less than
> Greater than
<= Less than or equal to
>= Greater than or equal to
!= Not equal to
Example
class Welcome
{
public static void main(String args[])
{
int numOne = 10;
int numTwo = 5;
System.out.println(numOne > numTwo);
}
}
Output:
true
Logical Operators
Logical operators are used to combine two or more relational expressions or
to negate the result of a relational expression.
Operator Name Description
The result will be true only if both
&& AND
expressions are true
The result will be true if any one of the
|| OR
expressions is true
The result will be false if the expression is
! NOT
true and vice versa

Assume A and B to be two relational expressions. The below tables show

the result for various logical operators based on the value of expressions, A
and B.
A B A&&B A||B
A !A
True True True True
True False
True False False True
False True
False True False True
False False False False
Ternary Operator
•The ternary operator is used as a single-line replacement for if-then-
else statements and acts upon three operands.
Syntax:
<condition> ? <value if condition is true> : < value if condition is false>
Example
class Welcome
{
public static void main(String args[])
{
int numOne = 10;
int numTwo = 5;
int min = (numOne < numTwo) ? numOne : numTwo;
System.out.println(min); //Output will be 5
}
}
Here, first the condition (numOne < numTwo) is evaluated. The result is
false and hence, min will be assigned the value numTwo.
Assignment Operator
The assignment operator is used to assign the value on the right-hand side
to the variable on the left-hand side of the operator.

Operator Description
= Assigns the value on the right to the variable on the left
Adds the current value of the variable on the left to the value on the
+=
right and then assigns the result to the variable on the left
Subtracts the value of the variable on the right from the current value of
-=
the variable on left and then assigns the result to the variable on the left
Multiplies the current value of the variable on left to the value on the
*=
right and then assigns the result to the variable on the left
Divides the current value of the variable on left by the value on the
/=
right and then assign the result to the variable on the left
Example
import java.io.*;
class Welcome
{
public static void main(String args[])
{
int numOne = 10; //The value 10 is assigned to numOne
System.out.println(numOne); //Output will be 10
numOne + = 5;
System.out.println(numOne); //Output will be 15
numOne - = 5;
System.out.println(numOne); //Output will be 10
numOne * = 5;
System.out.println(numOne); //Output will be 50
numOne / = 5;
System.out.println(numOne); //Output will be 10
}
}
Bitwise Operators
Bitwise operators are used to perform manipulation of individual bits of a
number. Let us understand how to convert a decimal number to a binary number
and vice versa.
The decimal or the base 10 number system is used in everyday life but the
binary number system is the basis for representing data in computing systems.
Steps to convert a decimal number to a binary number.
•Step 1: Divide the decimal number by 2.
•Step 2: Write the number on the right-hand side. This will be either 1 or 0
•Step 3: Divide the result of the division again by 2 and write the remainder.
•Step 4: Continue this process until the result of the division is 0.
•Step 5: The first remainder that you received isa the least significant bit and
the last remainder is the most significant bit.
Steps to convert the binary number back to a decimal number.
•The decimal number is equal to the sum of binary digits (dn) times their
power of 2 (2n).
Let us take the example of 11001.
•11001 = 1*24+1*23+0*22+0*21+1*20 = 16+8+0+0+1 = 25
Bitwise OR (|)
•It returns bit by bit OR of the input values. If either of the bits is 1, then
it gives 1, else it gives 0.
• E.g. - The output of 10 | 5 is 15.

Bitwise AND (&)

•It returns bit by bit AND of the input values. If both the bits are 1, then it
gives 1, else it gives 0.
• E.g. - The output of 10 & 5 is 0.
Left shift operator (<<)
•It takes two operators and left shifts the bits of the first operand. The
second operand decides the number of places to shift. It fills 0 on voids left as
a result.
•E.g. - The output of 10<<1 is 20 if the numbers are stored in a 32-bit system.
• 10 is represented as 00000000 00000000 00000000 00001010.
•After left shifting by 1 bit, the result becomes 00000000 00000000
00000000 000010100 which is 20.
The 0 that is highlighted is present because of the void.
Similarly, the output of 10<<2 is 40.
Signed Right shift operator (>>)
• It takes two operators and right shifts the bits of the first operand. The second
operand decides the number of places to shift. It fills 0 on voids left as a result of
the first operand being positive else it fills 1.
E.g. – An example of the positive number
• The output of 10>>1 is 5.
• 10 is represented as 00000000 00000000 00000000 00001010.
•After right shifting by 1 bit, the result becomes 00000000 00000000
00000000 00000101 which is 5.
Example of a negative number
• The output of -10>>1 is -5.
• -10 is represented as 11111111 11111111 11111111 11110110.
•After right shifting by 1 bit, the result becomes 11111111 11111111
11111111 11111011 which is -5.
Unsigned Right shift operator (>>>)
•It takes two operators and right shifts the bits of the first operand. The
second operand decides the number of places to shift. It fills 0 on voids left as
a result.
E.g. – An example a of a positive number
• The output of 10>>>1 is 5.

• 10 is represented as 00000000 00000000 00000000 00001010.

•After right shifting by 1 bit, the result becomes 00000000 00000000

00000000 00000101 which is 5.

Example of a negative number

• The output of -10>>>1 is 214783643.

• -10 is represented as 11111111 11111111 11111111 11110110.

• After right shifting by 1 bit, the result becomes 01111111 11111111
11111111 11111011 which is 214783643.
Operator Precedence
The operator precedence represents how two expressions are bound
together. In an expression, it determines the grouping of operators with
operands and decides how an expression will evaluate.
While solving an expression two things must be kept in mind the first is a
precedence and the second is associativity.
Precedence Operator Type Associativity
() Parentheses
[] Array subscript Left to Right
15
· Member selection
++ Unary post-increment
14 Right to left
-- Unary post-decrement
Unary pre-increment
++
Unary pre-decrement
--
Unary plus
+
Unary minus Right to left
-
13 Unary logical negation
!
Unary bitwise complement
~ (type)
Unary type cast
* Multiplication
/ Division Left to right
12
% Modulus
+ Addition
11 Left to right
- Subtraction
<< Bitwise left shift
>> Bitwise right shift with sign extension Left to right
10
>>> Bitwise right shift with zero extension
Precedence Operator Type Associativity
< Relational less than
<= Relational less than or equal
> Relational greater than Left to right
9 >= Relational greater than or equal
instanceof Type comparison (objects only)
== Relational is equal to
8 != Left to right
Relational is not equal to
7 & Bitwise AND Left to right
6 ^ Bitwise exclusive OR Left to right
5 | Bitwise inclusive OR Left to right
4 && Logical AND Left to right
3 || Logical OR Left to right
2 ?: Ternary conditional Right to left
= Assignment Addition
+= assignment
-= Subtraction assignment
Right to left
*= Multiplication assignment
1
/= Division assignment
%= Modulus assignment
Control Statements
 Control Statements
• Java compiler executes the code from top to bottom. The statements in the
code are executed according to the order in which they appear.
• However, Java provides statements that can be used to control the flow of
Java code. Such statements are called control flow statements.
• It is one of the fundamental features of Java, which provides a smooth flow
of program.
Three types of control flow statements.
• Decision Making statements
– if statements
• Simple if statement
• if-else statement
• if-else-if ladder
• Nested if-statement
– switch statement
• Loop statements
– do while loop
– while loop
– for loop
– for-each loop
• Jump statements
– break statement
– continue statement
 Decision Making statements
• Decision-making statements decide which statement to execute and
when.
• It evaluate the Boolean expression and control the program flow
depending upon the result of the condition provided.
 If Statements:
1. If Statement:
The if statement is used to decide whether a particular block of code will
be executed or not based on a certain condition. If the condition is true,
then the code is executed otherwise not.
Syntax:
if(condition)
{
// block of code to be executed if the condition is true
}
Example Program
public class Student
{
public static void main(String[] args)
{
int x = 10;
int y = 12;
if(x+y > 20)
{
System.out.println("x + y is greater than 20");
}
}

Output:
2) if-else statement
If the condition specified is true, the if block is executed. Otherwise, the
else block is executed.
Syntax:
if(condition) {
statement 1; //executes when condition is true
}
else{
statement 2; //executes when condition is false
}
Example Program:
public class Student
{
public static void main(String[] args)
{
int x = 10;
int y = 12;
if(x+y < 10)
{
System.out.println("x + y is less than 10");
}
else
{
System.out.println("x + y is greater than 20");
}
}
}
Output:
x + y is greater than 20
3) if-else-if ladder:
• The if statement is followed by multiple else-if blocks. We can create a decision

tree by using these control statements in Java in which the block where the

condition is true is executed and the rest of the ladder is ignored and not executed.
• If none of the conditions is true, the last else block is executed, if present.

Syntax
if(condition 1)
{
statement 1; //executes when condition 1 is true
}
else if(condition 2)
{
statement 2; //executes when condition 2 is true
}
else
{
statement 2; //executes when all the conditions are false
Example Program:
public class Student
{
public static void main(String[] args)
{
String city = "Delhi"; Output:
if(city == "Meerut") Delhi
{
System.out.println("city is meerut");
}
else if (city == "Noida")
{
System.out.println("city is noida");
}
else if(city == "Agra")
{
System.out.println("city is agra");
}
else
{
System.out.println(city);
} }}
4. Nested if-statement
Java allows us to nest control statements within control statements.
Nested control statements mean an if-else statement inside
other if or else blocks. It is similar to an if-else statement but they are
defined inside another if-else statement.
Syntax:
if(condition 1)
{
statement 1; //executes when condition 1 is true
if(condition 2)
{
statement 2; //executes when condition 2 is true
}
else{
statement 2; //executes when condition 2 is false
}
}
import java.io.*;

public class Student {

public static void main(String[] args) {

String address = "Delhi, India";

if(address.endsWith("India")) {
Output:

if(address.contains("Meerut")) { Delhi
System.out.println("Your city is Meerut");

}else if(address.contains("Noida")) {

System.out.println("Your city is Noida");

}else {

System.out.println(address.split(",")[0]);

}else {

System.out.println("You are not living in India");

} } }
 Switch Statements
• Switch Statements are similar to if-else-if statements. The switch statement
contains multiple blocks of code called cases and a single case is executed
based on the variable which is being switched.
• The switch statement is easier to use instead of if-else-if statements. It also
enhances the readability of the program.
Notes to remember
• Cases cannot be duplicate
• Default statement is executed when any of the case doesn't match the value of
expression. It is optional.
• Break statement terminates the switch block when the condition is satisfied.
It is optional, if not used, next case is executed.
• While using switch statements, we must notice that the case expression will be
of the same type as the variable. However, it will also be a constant value.
Syntax:
switch (expression)
{
case value1:
//code block of case with value1
break;
case value2:
//code block of case with value2
break;
.
.
case valueN:
//code block of case with valueN
break;
default:
//code block of default value
}
Example Program:
import java.io.*; case 5:
public class Sample { System.out.println("Thursday");
public static void main(String[] args) { break;
int weekday = Integer.parseInt(args[0]); case 6:
switch (weekday) { System.out.println("Friday");
case 1: break;
System.out.println("Sunday"); case 7:
break; System.out.println("Saturday");
case 2: break;
System.out.println("Monday"); default:
break; System.out.println("Invalid day");
case 3: }
System.out.println("Tuesday"); }
break; }
case 4: Output:
System.out.println("Wednesday");
If args[0] is 5 then the ouput is
break;
Thursday
 Loop statements
• In programming, sometimes we need to execute the block of code
repeatedly while some condition evaluates to true.
• However, loop statements are used to execute the set of instructions in a
repeated order. The execution of the set of instructions depends upon a
particular condition.
• In Java, we have three types of loops that execute similarly. However, there
are differences in their syntax and condition checking time.
– for loop
– while loop
– do-while loop
while Loop

It’s a entry controlled loop, the condition in the while loop is evaluated,
and if the condition is true, the code within the block is executed. This
repeats until the condition becomes false

Syntax:
false
Boolean Condition
while(condition)

{ true

Body of the loop Body of the loop

}
 Example Program:
import java.io.*;
public class Sample {
public static void main(String[] args) {
int i = 0;
while (i < 5) {
System.out.println("i: " + i);
i = i + 1;
}
}}
Output:
i: 0
i: 1
i: 2
i: 3
i: 4
do.. while Loop

It’s a exit controlled loop, the body of the loop gets executed first
followed by checking the condition. Continues with the body if the
condition is true, else loops gets terminated.

Syntax
Body of the loop
do

{
false
Boolean Condition
Body of the loop

} while(boolean expression); true

 Example Program:
import java.io.*;
public class Sample {
public static void main(String[] args) {
int i = 5;
do {
System.out.println("i: " + i);
i = i + 1;
} while (i < 5);
}
}
Output:
i: 5
for Loop
• The for loop initialize the value before the first step. Then checking the
condition against the current value of variable and execute the loop
statement and then perform the step taken for each execution of loop body.
• For-loops are also typically used when the number of iterations is known
before entering the loop.

Syntax:

for(initialization; condition; increment/decrement)

Body of the loop

}
 Example Program:
import java.io.*;
public class Sample
{
public static void main(String[] args)
{
for (int i = 1; i <= 5; i++)
{
System.out.println("i: " + i);
}
}
}
Output:
i: 1
i: 2
i: 3
i: 4
i: 5
Enhanced For Loop or For Each Loop
Enhanced for loop used along with a
collection of data. Output:
Syntax:
i: 10
for(declaration : expression) {
i: 20
Body of loop
} i: 30
Example Program: i: 40
public class Sample i: 50
{
public static void main(String[] args)
{
int[] numbers = { 10, 20, 30, 40, 50 };
for (int i : numbers)
{
System.out.println("i: " + i);
} } }
 Jump/Branching Statements

• Jump statements are used to transfer the control of the program to the
specific statements. In other words, jump statements transfer the execution
control to the other part of the program. There are two types of jump
statements in Java, i.e., break and continue.
1. Break Statement
• While the execution of program, the break statement will terminate the
iteration or switch case block.
• When a break statement is encountered in a loop, the loop is exited and the
program continues with the statements immediately following the loop.
• When the loops are nested, the break will only terminate the corresponding
loop body.
 Example Program
import java.io.*;
public class Sample
{
public static void main(String[] args)
{
for (int i = 1; i <= 5; i++)
{
if (i == 2)
break;
System.out.println("i: " + i);
}
}}
Output:
i: 1
continue Statement

• The continue statement skips the current iteration of a loop.

• In while and do loops, continue causes the control to go directly to the test-condition
and then continue the iteration process.

• In case of for loop, the increment section of the loop is executed before the test-
condition is evaluated. if (i == 3)

Example Program {
continue;
import java.io.*;
}
public class Sample
System.out.println("i: " + i);
{
} }}
public static void main(String[] args) Output:
{
i: 1
int[] numbers = { 1, 2, 3, 4, 5 };
i: 2
for (int i : numbers)
i: 4
{ i: 5
Class Fundamentals
 Class in Java
•A class is a group of objects which have common properties. It is a
template or blueprint from which objects are created. It is a logical entity. It
cannot be physical.
•A class in Java can contain: Example
 Fields / Variable
 Methods import java.io.*;
 Constructors
 Blocks
class Sample
 Nested class and interface {
Syntax to declare a class: int a,b; //variable declaration
class <class_name> public:
{ void get(); //method1
field / variable; method; void display(); //method2
} }
 Declaring Objects

• The object is a basic building block of an OOPs language. In Java, we

cannot execute any program without creating an object.
• There is various way to create an object in Java that we will discuss in this
section, and also learn how to create an object in Java.
Java provides five ways to create an object.
• Using new Keyword
• Using clone() method
• Using newInstance() method of the Class class
• Using newInstance() method of the Constructor class
• Using Deserialization
Using new Keyword
• Using the new keyword is the most popular way to create an object or
instance of the class.
When we create an instance of the class by using the new keyword, it allocates
memory (heap) for the newly created object and also returns the reference of
that object to that memory. The new keyword is also used to create an array.

Syntax:
ClassName object = new ClassName();
Example Program:
public class CreateObjectExample1
Output:
{
Welcome to javaTpoint
void show()
{
System.out.println("Welcome to javaTpoint");
}
public static void main(String[] args)
{
CreateObjectExample1 obj = new CreateObjectExample1();
obj.show();
}
}
 Declaring Methods
•A method is a block of code or collection of statements or a set of code
grouped together to perform a certain task or operation. It is used to achieve
the reusability of code.
• The method declaration provides information about method attributes, such
as visibility, return-type, name, and arguments. It has six components that
are known as method header
Syntax
return_type method_name(argument_list)
{
//statements;
}
Example:
Example Program:
class sample
{
public int addNumbers(int a, int b) // create a method
{
int sum = a + b; // return value return sum;
}
public static void main(String[] args)
{
int num1 = 25;
int num2 = 15; Output
sample obj = new sample(); // create an object of Main Sum is: 40
int result = obj.addNumbers(num1, num2); // calling method
System.out.println("Sum is: " + result);
}
}
 I/O statements in Java

Java I/O (Input and Output) is used to process the input and produce the
output. Java uses the concept of a stream to make I/O operations fast. The java.io
package contains all the classes required for input and output operations.
Java Scanner Class
• Java Scanner class allows the user to take input from the console. It belongs
to java.util package. It is used to read the input of primitive types like int, double,
long, short, float, and byte. It is the easiest way to read input in a Java program.
Syntax
Scanner object_name=new Scanner(System.in);
Example
Scanner s=new Scanner(System.in);
Methods of Java Scanner Class
Method Description

int nextInt() It is used to scan the next token of the input as an

integer.
float nextFloat() It is used to scan the next token of the input as a float.

double It is used to scan the next token of the input as a double.

nextDouble()

byte nextByte() It is used to scan the next token of the input as a byte.

String nextLine() Advances this scanner past the current line.

Example
import java.util.Scanner;
class Main
{
public static void main(String[] args)
{
Scanner input = new Scanner(System.in); // creates an object of Scanner
System.out.print("Enter your name: ");
String name = input.nextLine(); // takes input from the keyboard
System.out.println("My name is " + name); // prints the name
input.close(); // closes the scanner
} Output
} Enter your name: Kelvin My name is Kelvin
Java BufferedReader Class
•Java BufferedReader class is used to read the text from a character-based input
stream. It can be used to read data line by line by readLine() method.
•It makes the performance fast. It inherits Reader class.
Syntax
BufferedReader Object_name = new BufferedReader(new
InputStreamReader(System.in));
Example
• BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
Example Program:
import java.io.*;
public class BufferedReaderExample
{
public static void main(String args[])throws Exception
{
FileReader fr=new FileReader("D:\\testout.txt");
BufferedReader br=new BufferedReader(fr);
int i;
while((i=br.read())!=-1)
{
System.out.print((char)i); Here, we are assuming that you have
} following data in "testout.txt"
br.close(); file:
fr.close(); Welcome to javaTpoint.
} Output:
} Welcome to javaTpoint.
Topics Covered
1.Constructors
2.this Keyword
3.Overloading Methods
4.Overloading Constructors,
5.Access Control
6.Usage of “static”
7.Usage of “final”
What is a constructor?
• It is a member function which initializes a class.
• A constructor has:
(i) the same name as the class itself

(ii) no return type, Constructor is a special method of a Java class.

• It has no return value of any type, not even void.

• Constructor is automatically called when the object is created; no explicit

call is required
• Every class has a constructor, whether the programmer creates it or not.

• this() and super() keyword must be the first statement in a constructor

• Like methods, constructors can be overloaded.

• Constructors can not be overridden.

• One constructor can invoke another constructor of the same class using the
keyword this().

• Access specifiers/ modifiers can be applied before the constructor’s name to

declare its scope in a class.

• In Java, a constructor can never be static, final, abstract and Synchronized

• Every time an object is created using the new() keyword, at least
one constructor is called.

• It calls a default constructor if there is no constructor available in

the class.

• In such cases, Java compiler provides a default constructor by

default.

There are two types of constructors in Java:

● No-argument (Default) constructor

● Parameterized constructor.
Example1: Constructor
class Rectangle
{
int length; int width;
Rectangle(int x,int y)//constructor method
{
length=x; width=y;
}
int rectArea()
{
return(length*width);
}
}
class RectangleArea
{
public static void main (String args[])
{
Rectangle rect1=new Rectangle(15,10);//calling constructor
int area1=rect1.rectArea();
System.out.println(“Area =” +area1);
}
}
Output:
Area=150
Example 2
class Complex
{
int real;
int imag;
Complex() //No argument or default constructor
{
real=0;
imag=0;
}
Complex(int r,int i) //Parameterized constructor
{
real=r;
imag=i;
}
public static void main(String[] args)
{
Complex c1=new Complex(); //invoked No argument
constructor
System.out.println(c1.real+"+"+c1.imag+"i"); //0+0i
Complex c2=new Complex(2,3); //invoked
parameterized constructor
System.out.println(c2.real+"+"+c2.imag+"i"); //2+3i
}
}
Example3
class complex
{
double real,imag;
complex() //simple or default constructor
{
real=0.0;
imag=0.0;
}
complex(double x,double y) //parameterized constructor
{
real=x;
imag=y;
}
complex add(complex a) //copy constructor
{
complex n=new complex();
n.real=this.real+a.real;
n.imag=this.imag+a.imag;
return n;
}
void display()
{
System.out.println(“The result is”+real+”+i”+imag);
}
}
class comclass
{
public static void main(String args[])
{
complex c1=new complex(10,20); complex c2=new complex(10,20);
complex c1=new complex(); c3=c1.add(c2);
c3.display();
}
}

Output
The result is 20.0+i40.0
This Keyword
• this: to refer current class instance variable

• In Java, this is a reference variable that refers to the current object .

• The “this” keyword can be used to refer current class instance

variable.

• If there is ambiguity between the instance variables and parameters.

• “this” Keyword resolves problem of ambiguity.

Usage of Java this keyword

• this can be used to refer current class instance variable.

• this can be used to invoke the current class method (implicitly)

• this() can be used to invoke the current class constructor.

• this can be passed as an argument in the method call.

• this can be passed as an argument in the constructor call.

• this can be used to return the current class instance from the method.
Example
class Student
{
int rollno; String name; float fee;
Student(int rollno,String name,float fee)
{
this.rollno=rollno;
this.name=name;
this.fee=fee;
}
void display()
{
System.out.println(rollno+" "+name+" "+fee);
}
}
class TestThis2
{
public static void main(String args[])
{
Student s1=new Student(111,"ankit",5000f);
Student s2=new Student(112,"sumit",6000f);
s1.display();
s2.display();
}
}
Output:
111 ankit 5000.0
112 sumit 6000.0
Method Overloading in Java

• If a class has multiple methods having the same name but different
parameters, it is known as Method Overloading.

Advantage of method overloading

• Method overloading increases the readability of the program.

• Different ways to overload the method

There are two ways to overload the method in java

By changing the number of arguments

By changing the data type

Method Overloading: changing no. of arguments

In this example, we have created two methods, first, add() method performs
the addition of two numbers and second add() method performs the addition
of three numbers.
Example
class Adder
{
int add(int a,int b)
{
return a+b;
}
int add(int a,int b,int c)
{
return a+b+c;
}
}
class TestOverloading1
{
public static void main(String[] args)
{
Adder a=new Adder();
System.out.println(a.add(11,11));
System.out.println(a.add(11,11,11));
}
}
Output:
22
33
Method Overloading: changing data type of arguments

In this example, we have created two methods that differ in data type.
The first add method receives two integer arguments and the second
add method receives two double arguments.
Example
class Adder
{
int add(int a, int b)
{
return a+b;
}
double add(double a, double b)
{
 return a+b;
}
}
class TestOverloading
{
public static void main(String[] args)
{
Adder a=new Adder();
System.out.println(a.add(11,11));
System.out.println(a.add(12.3,12.6));
}
}
Output:
22
24.9
Constructor Overloading

Creating two or more constructors with different parameters is called

constructor overloading
Example
class Main
{
String language;
Main() // constructor with no parameter
{
language = "Java";
}
Main(String lang) // constructor with a single parameter
{
language = lang;
}
public void getName()
{
System.out.println("Programming Langauage: " + language);
}
public static void main(String[] args)
{
Main obj1 = new Main(); // call constructor with no parameter
Main obj2 = new Main("Python"); // call constructor with a single
parameter
obj1.getName(); obj2.getName();
}
}
Output
Programming Language: Java Programming
Language: Python
Access Controls / Access Specifier / Access Modifier
Java provides four Access Modifiers to set access levels for classes, variables,
methods, and constructors.

The four access levels are

default: The access level of a default modifier is only within the package. It cannot
be accessed from outside the package No modifiers are needed.

private: The access level of a private modifier is only within the class. It cannot be
accessed from outside the class.

public: The access level of a public modifier is everywhere. It can be accessed from
within the class, outside the class, within the package and outside the package.

protected: The access level of a protected modifier is within the package and
outside the package through child class. If you do not make the child class, it
cannot be accessed from outside the package
Non access modifiers
• Java has seven Non-Access Modifiers. Non-Access Modifiers are used with
classes, methods, variables, constructors. Non-Access Modifiers are used to
provide information to JVM.
Seven Non-Access Modifiers are
• Static: The static keyword in Java is used for memory management mainly. We
can apply static keyword with variables, methods, blocks and nested classes.
The static keyword belongs to the class than an instance of the class

• Final: The final keyword in java is used to restrict the user. The java final

• Keyword: can be used in many contexts. Final can be variable, method and
class
• Abstract: The abstract keyword is used to achieve abstraction in Java. It is a non-access
modifier which is used to create abstract class and method. The role of an abstract class is
to contain abstract methods

• Synchronized: Java programming language provides a very handy way of creating threads
and synchronizing their task by using synchronized blocks to keep shared resources.

• Transient: Java transient keyword is used in serialization. If you define any data member as
transient, it will not be serialized.

• Volatile: Volatile keyword is used to modify the value of a variable (either primitive type or
objects) by different threads. It is also used to make classes thread safe.

• Native: The native keyword is applied to a method to indicate that the method is
implemented in native code using JNI (Java Native Interface). Native is a modifier applicable
only for methods and cannot apply it anywhere else. The methods which are implemented
in C, C++ are called as native methods or foreign
Java Static Keyword

 The static keyword in Java is used for memory management

mainly. We can apply static keywords with variables, methods,
blocks, and nested classes. The static keyword belongs to the class
than an instance of the class.

The static can be:

Variable (also known as a class variable)

Method (also known as a class method)

Java static variable
• If you declare any variable as static, it is known as a static variable.

• The static variable can be used to refer to the common property of

all objects (which is not unique for each object), for example, the
company name of employees, the college name of students, etc.

• The static variable gets memory only once in the class area at the
time of class loading.
Advantages of static variable

• It makes your program memory efficient (i.e., it saves

memory).

• Program of a counter by static variable.

• The static variable will get the memory only once, if an

object changes the value of the static variable, it will retain
its value.
//Java Program to illustrate the use of static variables which is shared with all objects.
class Counter2
{
static int count=0;//will get memory only once and retain its value Counter2(){
count++;//incrementing the value of the static variable
System.out.println(count);
}
public static void main(String args[])
{
//creating objects
Counter2 c1=new Counter2();
Counter2 c2=new Counter2();
12 Counter2 c3=new Counter2();
}
}
Output
1
2
3
Java static method
If you apply a static keyword with any method, it is known as a static
method.

•A static method belongs to the class rather than the object of a class.

•A static method can be invoked without the need for creating an

instance of a class.

•A static method can access static data members and can change their
value of it.
Example of static method
//Java Program to get the cube of a given number using the static method

class Calculate
{
static int cube(int x)
{
return x*x*x;
}
public static void main(String args[])
{
int result=Calculate.cube(5); System.out.println(result);
}
}
Output
125
Final Keyword in Java
•The final keyword in java is used to restrict the user. The java final
keyword can be used in many contexts. The Final can be:

1.variable

2.method

3.class
•The final keyword can be applied to the variables, a final variable that
have no value is called a blank final variable or uninitialized final variable.
•It can be initialized in the constructor only. The blank final variable can be
static also which will be initialized in the static block only.
Java final variable

•If you make any variable final, you cannot change

the value of a final variable (It will be constant).
Example of final variable
There is a final variable AGE, we are going to change the value of this variable,
but it cannot be changed because the final variable once assigned a value can
never be changed.
Example
class Main
{
public static void main(String[] args)
{
final int AGE = 32; // create a final variable
AGE = 45; // try to change the final variable
System.out.println("Age: " + AGE);
}
}
Output:
cannot assign a value to final variable AGE
AGE = 45;
Java final method
If you make any method final, you cannot override it.
Example
class FinalDemo
{
public final void display() // create a final method
{
System.out.println("This is a final method.");
}
}
class Main extends FinalDemo
{
public final void display() // try to override final method
{
System.out.println("The final method is overridden.");
}
public static void main(String[] args)
{
Main obj = new Main();
obj.display();
}
}
•In the above example, we have created a final method named display() inside
the FinalDemo class.
•Here, the Main class inherits the FinalDemo class.
•We have tried to override the final method in the Main class. When we run the
program, we will get a compilation error with the following message.

Output
display() in Main cannot override display() in FinalDemo public final void
display() {
^
overridden method is final