UNIT I
What is Java
Java is a programming language and a platform.
Java is a high level, robust, secured and object-oriented programming language.
Platform: Any hardware or software environment in which a program runs is known as a
platform. Since Java has its own runtime environment (JRE) and API, it is called platform
Web reference : https://docs.oracle.com/javase/tutorial/tutorialLearningPaths.html
Where it is used?
According to Sun, 3 billion devices run java. There are many devices where Java is currently
used. Some of them are as follows:
1. Desktop Applications such as acrobat reader, media player, antivirus etc.
2. Web Applications such as irctc.co.in, javatpoint.com etc.
3. Enterprise Applications such as banking applications.
4. Mobile
5. Embedded System
6. Smart Card
7. Robotics
8. Games etc
Java Platforms / Editions
There are 4 platforms or editions of Java:
1) Java SE (Java Standard Edition)
It is a java programming platform. It includes Java programming APIs such as java.lang,
java.io, java.net, java.util, java.sql, java.math etc. It includes core topics like OOPs, String,
Regex, Exception, Inner classes, Multithreading, I/O Stream, Networking, AWT, Swing,
Reflection, Collection etc.
2) Java EE (Java Enterprise Edition)
It is an enterprise platform which is mainly used to develop web and enterprise applications.
It is built on the top of Java SE platform. It includes topics like Servlet, JSP, Web Services,
EJB, JPA etc.
3) Java ME (Java Micro Edition)
It is a micro platform which is mainly used to develop mobile applications.
4) JavaFx
It is used to develop rich internet applications. It uses light-weight user interface API.
History of Java
The history of java starts from Green Team. Java team members (also known as Green
Team), initiated a revolutionary task to develop a language for digital devices such as set-top
boxes, televisions etc.
Currently, Java is used in internet programming, mobile devices, games, e-business solutions
etc. There are given the major points that describe the 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) Originally designed for small, embedded systems in electronic appliances like set-top
boxes.
3) Firstly, it was called "Greentalk" by James Gosling and file extension was .gt.
4) After that, it was called Oak and was developed as a part of the Green project.
Why "Oak" name
Why Oak? Oak is a symbol of strength and chosen as a national tree of many countries like
U.S.A., France, Germany, Romania etc.
In 1995, Oak was renamed as "Java" because it was already a trademark by Oak
Technologies.
Why "Java" name
Why had they choosen java name for java language? 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.
Java is an island of Indonesia where first coffee was produced (called java coffee).
Java originally developed by James Gosling at Sun Microsystems (which is now a subsidiary
of Oracle Corporation) and released in 1995.
JDK 1.0 released in (January 23, 1996).
Java Version History
There are many java versions that have been released. Current stable release of Java is Java
SE 8.
1. JDK Alpha and Beta (1995)
2. JDK 1.0 (23rd Jan, 1996)
3. JDK 1.1 (19th Feb, 1997)
4. J2SE 1.2 (8th Dec, 1998)
5. J2SE 1.3 (8th May, 2000)
6. J2SE 1.4 (6th Feb, 2002)
7. J2SE 5.0 (30th Sep, 2004)
8. Java SE 6 (11th Dec, 2006)
9. Java SE 7 (28th July, 2011)
10. Java SE 8 (18th March, 2014)
11. Java SE 9 (17th October, 2017
JDK, JRE and JVM
JVM
JVM (Java Virtual Machine) is an abstract machine. It is a specification that provides runtime
environment in which java byte code can be executed.
JVMs are available for many hardware and software platforms. JVM, JRE and JDK are
platform dependent because configuration of each OS differs. But, Java is platform
independent.
The JVM performs following main tasks:
Loads code
Verifies code
Executes code
Provides runtime environment
JRE
JRE is an acronym for Java Runtime Environment. It is used to provide runtime environment.
It is the implementation of JVM. It physically exists. It contains set of libraries + other
files that JVM uses at runtime.
JDK
JDK is an acronym for Java Development Kit. It physically exists. It contains
JRE + development tools.
Simple Program of Java
Requirement:
For executing any java program, you need to
Install the JDK if you don't have installed it, download the JDK and install it.
Set path of the jdk/bin directory. (scroll down to refer : how to set path in java )
Create the java program
Compile and run the java program
Example 1:Simple.java
class Simple
public static void main(String args[])
System.out.println("Hello Java");
Compile by: javac Simple.java
Run by: java Simple
Output: Hello Java
Understanding first java program
Let's see what is the meaning of class, public, static, void, main, String[], System.out.println()
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 startup of the program.
String[] args is used for command line argument.
System.out.println() is used print statement.
Valid java main method signature
Subscript notation in java array can be used after type, before variable or after
variable
public static void main(String[] args)
public static void main(String []args)
public static void main(String args[])
We can provide var-args support to main method by passing 3 ellipses (dots)
public static void main(String... args)
We change sequence of the modifiers, method prototype is not changed.
static public void main(String[] args)
public static final void main(String[] args)
final public static void main(String[] args)
Invalid java main method signature
public void main(String[] args)
static void main(String[] args)
public void static main(String[] args)
abstract public static void main(String[] args)
How to set path in Java
The path is required to be set for using tools such as javac, java etc.
If you are saving the java source file inside the jdk/bin directory, path is not required to be set
because all the tools will be available in the current directory.
But If you are having your java file outside the jdk/bin folder, it is necessary to set path of
JDK.
There are 2 ways to set java path:
1. To set the path of JDK, you need to follow following steps:
Open command prompt
copy the path of jdk/bin directory
write in command prompt: set path=copied_path
For Example:
set path=C:\Program Files\Java\jdk1.6.0_23\bin
2. For setting the permanent path of JDK, you need to follow these steps:
Go to MyComputer properties -> advanced tab -> environment variables -> new tab
of user variable ->
variable name is path
variable value is path of bin folder
(for Example : C:\Program Files\Java\jdk1.6.0_23\bin )
then click ok -> ok -> ok
Java version can be known
C:\ java –version
Java buzzwords
Simple
Platform independent
Portable
Secured
Dynamic
Distributed
Robust
Multithreaded
High performance
Architecture neutral
Variables and Data Types in Java
Variable is a name of memory location. There are three types of variables in java: local,
instance and static.
There are two types of data types in java: primitive and non-primitive.
Variable
Variable is name of reserved area allocated in memory. In other words, it is a name of
memory location
Example : int data=50; //Here data is variable
Types of Variable
There are three types of variables in java:
local variable
instance variable
static variable
1) Local Variable
A variable which is declared inside the method is called local variable.
2) Instance Variable
A variable which is declared inside the class but outside the method, is called instance
variable . It is not declared as static.
3) Static variable
A variable that is declared as static is called static variable. It cannot be local.
class A
int data=50; //instance variable
static int m=100; //static variable
void method(){
int n=90; //local variable
} //end of class
Data Types in Java
Data types represent the different values to be stored in the variable. In java, there are two
types of data types:
Primitive data types
Non-primitive data types
Data Type Default Value Default size
Boolean False 1 bit
Char '\u0000' 2 byte
Byte 0 1 byte
Short 0 2 byte
Int 0 4 byte
Long 0L 8 byte
Float 0.0f 4 byte
Double 0.0d 8 byte
Java Variable Example1: Add Two Numbers
class Simple{
public static void main(String[] args) {
int a=10;
int b=10;
int c=a+b;
System.out.println(c);
} }
Output:
20
Java Variable Example2: Widening (Type casting)
class Simple{
public static void main(String[] args)
{ int a=10;
float f=a;
System.out.println(a);
System.out.println(f); } }
Output:
10
10.0
Java Variable Example3: Narrowing (Typecasting)
class Simple {
public static void main(String[] args)
{ float f=10.5f;
//int a=f;//Compile time error
int a=(int)f;
System.out.println(f);
System.out.println(a); } }
Output:
10.5
10
Java Variable Example: Adding Lower Type
class Simple {
public static void main(String[] args) {
byte a=10;
byte b=10;
//byte c=a+b;//Compile Time Error: because a+b=20 will be int
byte c=(byte)(a+b);
System.out.println(c);
} }
Output: 20
Operators in JAVA
Operator in java is a symbol that is used to perform operations. For example: +, -, *, / etc.
There are many types of operators in java which are given below:
Unary Operator,
Arithmetic Operator,
shift Operator,
Relational Operator,
Bitwise Operator,
Logical Operator,
Ternary Operator and
Assignment Operator.
Java Unary Operator Example: ++ and --
class OperatorExample {
public static void main(String args[]) {
int x=10;
System.out.println(x++); //10 (11)
System.out.println(++x); //12
System.out.println(x--); //12 (11)
System.out.println(--x); //10
} }
Output:
10
12
12
10
Java AND Operator Example: Logical && and Bitwise &
The logical && operator doesn't check second condition if first condition is false. It checks
second condition only if first one is true.
The bitwise & operator always checks both conditions whether first condition is true or false.
class OperatorExample {
public static void main(String args[]) {
int a=10;
int b=5;
int c=20;
System.out.println(a<b&&a<c); //false && true = false
System.out.println(a<b&a<c); //false & true = false
} }
Output:
false
false
Java OR Operator Example: Logical || and Bitwise |
The logical || operator doesn't check second condition if first condition is true. It checks
second condition only if first one is false.
The bitwise | operator always checks both conditions whether first condition is true or false.
class OperatorExample {
public static void main(String args[]) {
int a=10;
int b=5;
int c=20;
System.out.println(a>b||a<c);//true || true = true
System.out.println(a>b|a<c);//true | true = true
// || (logical or) vs | (bitwise or)
System.out.println(a>b||a++<c); //true || true = true
System.out.println(a); //10 because second condition is not checked
System.out.println(a>b|a++<c); //true | true = true
System.out.println(a); //11 because second condition is checked
} }
Output:
true
true
true
10
true
11
Java Ternary Operator Example
class OperatorExample{
public static void main(String args[]){
int a=2;
int b=5;
int min=(a<b)?a:b;
System.out.println(min);
} }
Output:
2
Java Control Flow Statements
Decision-making statements
If or if-else or if - else if or nested if or switch
Looping statements
Iterative based (for or for each or label for)
Event based (while or do-while)
Branching statements (break, continue, return)
Java for Loop
The Java for loop is used to iterate a part of the program several times. If the number of
iteration is fixed, it is recommended to use for loop.
There are three types of for loop in java.
Simple For Loop
For-each or Enhanced For Loop
Labeled For Loop
Simple for Loop
The syntax of simple for Loop in Java is:
for (initialization; testExpression; update)
{
// codes inside for loop's body
}
How for loop works?
1. The initialization expression is executed only once.
2. Then, the test expression is evaluated. Here, test expression is a boolean expression.
3. If the test expression is evaluated to true,
o Codes inside the body of for loop is executed.
o Then the update expression is executed.
o Again, the test expression is evaluated.
o If the test expression is true, codes inside the body of for loop is executed and
update expression is executed.
o This process goes on until the test expression is evaluated to false.
4. If the test expression is evaluated to false, for loop terminates.
for Loop Flowchart
Example: WAJP that prints first 10 natural numbers
public class ForExample
{
public static void main(String[] args) {
for(int i=1;i<=10;i++)
{ System.out.print(i+” “);
} } }
Output :
1 2 3 4 5 6 7 8 9 10
Java For-each Loop
The for-each loop is used to traverse array or collection in java, i.e. loop is implemented
based on number of elements in an array or collection
Syntax:
for(Type var:array){
//code to be executed
Example:
public class ForEachExample {
public static void main(String[] args) {
int arr[]={112,23,144,56,78};
for(int i:arr){
System.out.print(i + “ “);
} } }
Output:
112 23 144 56 78
Java Labelled For Loop
We can have name of each for loop. To do so, we use label before the for loop. It is useful if
we have nested for loop so that we can break/continue specific for loop.
Normally, break and continue keywords breaks/continues the inner most for loop only.
Syntax:
labelname:
for(initialization;condition;incr/decr) {
//code to be executed }
Example:
public class LabeledForExample {
public static void main(String[] args) {
aa:
for(int i=1;i<=3;i++){
bb:
for(int j=1;j<=3;j++){
if(i==2&&j==2){
break aa;
System.out.println(i+" "+j);
} } } }
Output:
1 1
1 2
1 3
2 1
Java Infinitive For Loop
for(;;) {
//code to be executed }
Example:
public class ForExample {
public static void main(String[] args) {
for(;;){
System.out.println("welcome"); } } }
Output:
Welcome
Welcome
Welcome
Press Ctrl+c to exit
How to read input in java
Command line argument
Joption pane
Scanner class
Datainput stream
Inputstream class
Command line argument: The java command-line argument is an argument i.e. passed
at the time of running the java program. The arguments passed from the console can be
received in the java program and it can be used as an input. We can pass N – number of
arguments from the command prompt.
Example 1 :Displays command line entered single message .
class CmdLineExam
{ public static void main(String args[]) {
System.out.println("Your argument is: "+args[0]);
} }
# compile by > javac CmdLineExam.java
#run by > java CmdLineExam Naresh
Output: Your argument is: Naresh
Example 2 : Displays command line entered single message .
class CmdLineExam
{ public static void main(String args[]) {
System.out.println("Your first argument is: "+args[0]);
System.out.println("Your second argument is: "+args[1]); } }
# compile by > javac CmdLineExam.java
# run by > java CmdLineExam Naresh Kumar
Output: Your first argument is: Naresh
Output: Your second argument is: Kumar
Example 3: Write a Java program that performs addition of two number and print the
result.
class add
{ public static void main(String arg[]) {
int x,y,s;
x=Integer.parseInt(ar[0]); //converts string type into integer format
y=Integer.parseInt(ar[1]); //converts string type into integer format
s=x+y;
System.out.println("sum of " + x + " and " + y +" is " +s); } }
# compile by > javac add.java
# run by > java add 20 30
Output: sum of 20 and 30 is 50
Example 3: Write a Java program that prints n natural number.
class PrintnNatural
{ public static void main(String arg[]) {
int n;
n=Integer.parseInt(ar[0]); //converts string type into integer format
System.out.print("Natural number is : " );
for(int i=0;i<=n;i++)
System.out.print(“ “+i); //print the value in sequence order
} }
# compile by > javac PrintnNatural.java
# run by > java PrintnNatural 10
Output: Natural number is : 1 2 3 4 5 6 7 8 9 10
THIS Keyword: is a reference variable in Java that refers to the current object.
Used to resolve naming conflict
It can be used to refer instance variable of current class
It can be used to invoke or initiate current class constructor
It can be passed as an argument in the method call
It can be passed as argument in the constructor call
It can be used to return the current class instance
class Account{
int a;
int b;
public void setData(int a ,int b){
a = a;
b = b;
}
public void showData(){
System.out.println("Value of A ="+a);
System.out.println("Value of B ="+b);
}
public static void main(String args[]){
Account obj = new Account();
obj.setData(2,3);
obj.showData();
}
}
Output : Value of A= 0
Value of B=0
In the above example, parameters (formal arguments) and instance variables are same.
Compiler will be in confusion, unable to identify local variable and instance variable ,so
didn’t assign the values to a ,b .To avoid conflict, we are using this keyword to distinguish
local variable and instance variable .So make a modification in the code , append line # 6 & 7
with "this" keyword.
this.a=a;
this.b=b;
Garbage collection : is a program that runs in the background(JVM) and picks up or
clear memory space occupied by dead objects(ie.free the memory automatically).Java uses
garbage collector for its memory management
