Unit-1

OOP Concepts

Object Oriented Programming is a paradigm that provides many concepts such as

inheritance, data binding, polymorphism etc.

Simula is considered as the first object-oriented programming language. The programming

paradigm where everything is represented as an object is known as truly object-oriented
programming language.

Smalltalk is considered as the first truly object-oriented programming language.

OOPs (Object Oriented Programming System)

Object means a real word entity such as pen, chair, table etc. Object-Oriented Programming is a
methodology or paradigm to design a program using classes and objects. It simplifies the software
development and maintenance by providing some concepts:

o Object
o Class
o Inheritance
o Polymorphism
o Abstraction
o Encapsulation

Object

Any entity that has state and behavior is known as an object. For example: chair, pen, table,
keyboard, bike etc. It can be physical and logical.

Class

Collection of objects is called class. It is a logical entity.

Inheritance

When one object acquires all the properties and behaviours of parent object i.e. known as
inheritance. It provides code reusability. It is used to achieve runtime polymorphism.

JAVA Page 1
PROGRAMMING
 Polymorphism

When one task is performed by different ways i.e. known as polymorphism. For example: to
convince the customer differently, to draw something e.g. shape or rectangle etc.

In java, we use method overloading and method overriding to achieve polymorphism.

Another example can be to speak something e.g. cat speaks meaw, dog barks woof etc.

Abstraction

Hiding internal details and showing functionality is known as abstraction. For example: phone
call, we don't know the internal processing.

In java, we use abstract class and interface to achieve abstraction.

Encapsulation

Binding (or wrapping) code and data together into a single unit is known as encapsulation.
For example: capsule, it is wrapped with different medicines.

A java class is the example of encapsulation. Java bean is the fully encapsulated class because all
the data members are private here.

Benefits of Inheritance

 One of the key benefits of inheritance is to minimize the amount of duplicate code in an
application by sharing common code amongst several subclasses. Where equivalent code
exists in two related classes, the hierarchy can usually be refactored to move the common
code up to a mutual superclass. This also tends to result in a better organization of code and
smaller, simpler compilation units.
 Inheritance can also make application code more flexible to change because classes that
inherit from a common superclass can be used interchangeably. If the return type of a
method is superclass
 Reusability - facility to use public methods of base class without rewriting the same.
 Extensibility - extending the base class logic as per business logic of the derived class.

JAVA Page 2
PROGRAMMING
 Data hiding - base class can decide to keep some data private so that it cannot be
altered by the derived class
Procedural and object oriented programming paradigms

JAVA Page 3
PROGRAMMING
 Java Programming- 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.

For the green team members, it was an advance concept at that time. But, it was
suited for internet programming. Later, Java technology as incorporated by Netscape.

Currently, Java is used in internet programming, mobile devices, games, e-business

solutions etc. There are given the major points that describes 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.

Java Version History

There are many java versions that has 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)

JAVA Page 4
PROGRAMMING
Features of Java
There is given many features of java. They are also known as java buzzwords. The Java Features
given below are simple and easy to understand.
1. Simple
2. Object-Oriented
3. Portable
4. Platform independent
5. Secured
6. Robust
7. Architecture neutral
8. Dynamic
9. Interpreted
10. High Performance
11. Multithreaded
12. Distributed

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. It can also be used to hide program code for specific time.

Types of Java Comments

There are 3 types of comments in java.

1. Single Line Comment

2. Multi Line Comment
3. Documentation Comment

Java Single Line Comment

The single line comment is used to comment only one line.

Syntax:

1. //This is single line comment

JAVA Page 5
PROGRAMMING
 Example:

public class CommentExample1 {

public static void main(String[] args) {
int i=10;//Here, i is a variable
System.out.println(i);
}
}

Output:

10

Java Multi Line Comment

The multi line comment is used to comment multiple lines of code.

Syntax:

/*
This
is
multi line
comment
*/

Example:

public class CommentExample2 {

public static void main(String[] args) {
/* Let's declare and
print variable in java. */
int i=10;
System.out.println(i);
}}

Output:

10

JAVA Page 6
PROGRAMMING
Java Documentation Comment

The documentation comment is used to create documentation API. To create documentation API, you need
to use javadoc tool.

Syntax:

/**
This
is
documentation
comment
*/

Example:

/** The Calculator class provides methods to get addition and subtraction of given 2 numbers.*/
public class Calculator {
/** The add() method returns addition of given numbers.*/
public static int add(int a, int b){return a+b;}
/** The sub() method returns subtraction of given numbers.*/
public static int sub(int a, int b){return a-b;}
}

Compile it by javac tool:

javac Calculator.java

Create Documentation API by javadoc tool:

javadoc Calculator.java

Now, there will be HTML files created for your Calculator class in the current directory. Open the HTML
files and see the explanation of Calculator class provided through documentation comment.

JAVA Page 7
PROGRAMMING
Data Types
Data types represent the different values to be stored in the variable. In java, there are two types of data types:

o Primitive data types

o 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 Example: 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 Page 8
PROGRAMMING
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.

Types of Variable
There are three types of variables in java:

o local variable
o instance variable
o 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.

We will have detailed learning of these variables in next chapters.

Example to understand the types of variables in java

class A{
int data=50;//instance variable
static int m=100;//static variable
void method(){
int n=90;//local variable
}
}//end of class

Constants in Java

A constant is a variable which cannot have its value changed after declaration. It uses the 'final'
keyword.

Syntax
modifier final dataType variableName = value; //global constant

modifier static final dataType variableName = value; //constant within a c

JAVA Page 9
PROGRAMMING
Scope and Life Time of Variables
The scope of a variable defines the section of the code in which the variable is visible. As a
general rule, variables that are defined within a block are not accessible outside that block. The
lifetime of a variable refers to how long the variable exists before it is destroyed. Destroying
variables refers to deallocating the memory that was allotted to the variables when declaring it.
We have written a few classes till now. You might have observed that not all variables are the
same. The ones declared in the body of a method were different from those that were declared
in the class itself. There are three types of variables: instance variables, formal parameters or
local variables and local variables.

Instance variables

Instance variables are those that are defined within a class itself and not in any method or
constructor of the class. They are known as instance variables because every instance of the
class (object) contains a copy of these variables. The scope of instance variables is determined
by the access specifier that is applied to these variables. We have already seen about it earlier.
The lifetime of these variables is the same as the lifetime of the object to which it belongs.
Object once created do not exist for ever. They are destroyed by the garbage collector of Java
when there are no more reference to that object. We shall see about Java's automatic garbage
collector later on.

Argument variables

These are the variables that are defined in the header oaf constructor or a method. The scope of
these variables is the method or constructor in which they are defined. The lifetime is limited
to the time for which the method keeps executing. Once the method finishes execution, these
variables are destroyed.

Local variables

A local variable is the one that is declared within a method or a constructor (not in the header).
The scope and lifetime are limited to the method itself.

One important distinction between these three types of variables is that access specifiers can be
applied to instance variables only and not to argument or local variables.

In addition to the local variables defined in a method, we also have variables that are defined
in bocks life an if block and an else block. The scope and is the same as that of the block itself.

JAVA Page 10
PROGRAMMING
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:

o Unary Operator,
o Arithmetic Operator,
o shift Operator,
o Relational Operator,
o Bitwise Operator,
o Logical Operator,
o Ternary Operator and
o Assignment Operator.

Operators Hierarchy

JAVA Page 11
PROGRAMMING
Expressions
Expressions are essential building blocks of any Java program, usually created to produce a new
value, although sometimes an expression simply assigns a value to a variable. Expressions are
built using values, variables, operators and method calls.

Types of Expressions

While an expression frequently produces a result, it doesn't always. There are three types of
expressions in Java:

 Those that produce a value, i.e. the result of (1 + 1)

 Those that assign a variable, for example (v = 10)
 Those that have no result but might have a "side effect" because an expression can include
a wide range of elements such as method invocations or increment operators that modify
the state (i.e. memory) of a program.

Java Type casting and Type conversion

Widening or Automatic Type Conversion

Widening conversion takes place when two data types are automatically converted. This happens
when:
 The two data types are compatible.
 When we assign value of a smaller data type to a bigger data type.

For Example, in java the numeric data types are compatible with each other but no automatic
conversion is supported from numeric type to char or boolean. Also, char and boolean are not
compatible with each other.

Narrowing or Explicit Conversion

If we want to assign a value of larger data type to a smaller data type we perform explicit type
casting or narrowing.
 This is useful for incompatible data types where automatic conversion cannot be done.
 Here, target-type specifies the desired type to convert the specified value to.



JAVA Page 12
PROGRAMMING
Java Enum

Enum in java is a data type that contains fixed set of constants.

It can be used for days of the week (SUNDAY, MONDAY, TUESDAY, WEDNESDAY,
THURSDAY, FRIDAY and SATURDAY) , directions (NORTH, SOUTH, EAST and WEST)
etc. The java enum constants are static and final implicitly. It is available from JDK 1.5.

Java Enums can be thought of as classes that have fixed set of constants.

Simple example of java enum

class EnumExample1{
public enum Season { WINTER, SPRING, SUMMER, FALL }

public static void main(String[] args) {

for (Season s : Season.values())
System.out.println(s);
}}
Output:
WINTER
SPRING
SUMMER
FALL

Control Flow Statements

The control flow statements in Java allow you to run or skip blocks of code when special
conditions are met.

The “if” Statement

The “if” statement in Java works exactly like in most programming languages. With the help of
“if” you can choose to execute a specific block of code when a predefined condition is met. The
structure of the “if” statement in Java looks like this:

if (condition) {
// execute this code
}

JAVA Page 13
PROGRAMMING
The condition is Boolean. Boolean means it may be true or false. For example you may put a
mathematical equation as condition. Look at this full example:

Creating a Stand-Alone Java Application

1. Write a main method that runs your program. You can write this method anywhere. In this
example, I'll write my main method in a class called Main that has no other methods. For
example:
2. public class Main
3. {
4. public static void main(String[] args)
5. {
6. Game.play();
7. }}
8. Make sure your code is compiled, and that you have tested it thoroughly.
9. If you're using Windows, you will need to set your path to include Java, if you haven't
done so already. This is a delicate operation. Open Explorer, and look inside
C:\ProgramFiles\Java, and you should see some version of the JDK. Open this folder, and
then open the bin folder. Select the complete path from the top of the Explorer window, and
press Ctrl-C to copy it.

Next, find the "My Computer" icon (on your Start menu or desktop), right-click it, and select
properties. Click on the Advanced tab, and then click on the Environment variables button.
Look at the variables listed for all users, and click on the Path variable. Do not delete the
contents of this variable! Instead, edit the contents by moving the cursor to the right end,
entering a semicolon (;), and pressing Ctrl-V to paste the path you copied earlier. Then go
ahead and save your changes. (If you have any Cmd windows open, you will need to close
them.)

10. If you're using Windows, go to the Start menu and type "cmd" to run a program that
brings up a command prompt window. If you're using a Mac or Linux machine, run the
Terminal program to bring up a command prompt.
11. In Windows, type dir at the command prompt to list the contents of the current directory.
On a Mac or Linux machine, type ls to do this.

JAVA Page 14
PROGRAMMING
 12. Now we want to change to the directory/folder that contains your compiled code. Look at
the listing of sub-directories within this directory, and identify which one contains your code.
Type cd followed by the name of that directory, to change to that directory. For example, to
change to a directory called Desktop, you would type:

cd Desktop

To change to the parent directory, type:

cd ..

Every time you change to a new directory, list the contents of that directory to see where to go
next. Continue listing and changing directories until you reach the directory that contains
your .class files.

13. If you compiled your program using Java 1.6, but plan to run it on a Mac, you'll need to
recompile your code from the command line, by typing:

javac -target 1.5 *.java

14. Now we'll create a single JAR file containing all of the files needed to run your program.

Arrays
Java provides a data structure, the array, which stores a fixed-size sequential collection of
elements of the same type. An array is used to store a collection of data, but it is often more useful
to think of an array as a collection of variables of the same type.

Instead of declaring individual variables, such as number0, number1, ..., and number99, you
declare one array variable such as numbers and use numbers[0], numbers[1], and ..., numbers[99]
to represent individual variables.

This tutorial introduces how to declare array variables, create arrays, and process arrays using
indexed variables.

Declaring Array Variables:

To use an array in a program, you must declare a variable to reference the array, and you must
specify the type of array the variable can reference. Here is the syntax for declaring an array
variable:

dataType[] arrayRefVar; // preferred way.

or
dataType arrayRefVar[]; // works but not preferred way.
Note: The style dataType[] arrayRefVar is preferred. The style dataType arrayRefVar[]
comes from the C/C++ language and was adopted in Java to accommodate C/C++ programmers.

Example:

JAVA Page 15
PROGRAMMING
The following code snippets are examples of this syntax:

double[] myList; // preferred way.

or
double myList[]; // works but not preferred way.

Creating Arrays:

You can create an array by using the new operator with the following syntax:

arrayRefVar = new dataType[arraySize];

The above statement does two things:

 It creates an array using new dataType[arraySize];

 It assigns the reference of the newly created array to the variable arrayRefVar.

Declaring an array variable, creating an array, and assigning the reference of the array to the
variable can be combined in one statement, as shown below:

dataType[] arrayRefVar = new dataType[arraySize];

Alternatively you can create arrays as follows:

dataType[] arrayRefVar = {value0, value1, ..., valuek};

The array elements are accessed through the index. Array indices are 0-based; that is, they start
from 0 to arrayRefVar.length-1.

Example:
Following statement declares an array variable, myList, creates an array of 10 elements of
double type and assigns its reference to myList:

double[] myList = new double[10];

Following picture represents array myList. Here, myList holds ten double values and the indices
are from 0 to 9.

JAVA Page 16
PROGRAMMING
Processing Arrays:
When processing array elements, we often use either for loop or for each loop because all of the
elements in an array are of the same type and the size of the array is known.

Example:
Here is a complete example of showing how to create, initialize and process arrays:

public class TestArray

{
public static void main(String[] args) {
double[] myList = {1.9, 2.9, 3.4, 3.5};
// Print all the array elements
for (int i = 0; i < myList.length; i++) {
System.out.println(myList[i] + " ");
}
// Summing all elements
double total = 0;
for (int i = 0; i < myList.length; i++) {
total += myList[i];
}
System.out.println("Total is " + total);
// Finding the largest element
double max = myList[0];
for (int i = 1; i < myList.length; i++) {
if (myList[i] > max) max = myList[i];
}
System.out.println("Max is " + max);
}
}

JAVA Page 17
PROGRAMMING
This would produce the following result:

1.9
2.9
3.4
3.5
Total is 11.7
Max is 3.5
public class TestArray {
public static void main(String[] args) {
double[] myList = {1.9, 2.9, 3.4, 3.5};
// Print all the array elements
for (double element: myList) {
System.out.println(element);
}}}

Java Console Class

The Java Console class is be used to get input from console. It provides methods to read texts and
passwords.

If you read password using Console class, it will not be displayed to the user.

The java.io.Console class is attached with system console internally. The Console class is
introduced since 1.5.

Let's see a simple example to read text from console.

1. String text=System.console().readLine();
2. System.out.println("Text is: "+text);

Java Console Example

import java.io.Console;
class ReadStringTest{
public static void main(String args[]){
Console c=System.console();
System.out.println("Enter your name: ");
String n=c.readLine();
System.out.println("Welcome "+n); } }
JAVA Page 18
PROGRAMMING
 Output

Enter your name: Nakul Jain

Welcome Nakul Jain

Constructors

Constructor in java is a special type of method that is used to initialize the object.

Java constructor is invoked at the time of object creation. It constructs the values i.e. provides data
for the object that is why it is known as constructor.

There are basically two rules defined for the constructor.

1. Constructor name must be same as its class name

2. Constructor must have no explicit return type

Types of java constructors

There are two types of constructors:

1. Default constructor (no-arg constructor)

2. Parameterized constructor

Java Default Constructor

A constructor that have no parameter is known as default constructor.

Syntax of default constructor:

1. <class_name>(){}

Example of default constructor

In this example, we are creating the no-arg constructor in the Bike class. It will be invoked at
the time of object creation.
class Bike1{
Bike1(){System.out.println("Bike is created");}
public static void main(String args[]){
Bike1 b=new Bike1();
}}
Output: Bike is created

JAVA Page 19
PROGRAMMING
 Example of parameterized constructor
In this example, we have created the constructor of Student class that have two parameters. We
can have any number of parameters in the constructor.
class Student4{
int id;
String name;

Student4(int i,String n){

id = i;
name = n;
}
void display(){System.out.println(id+" "+name);}

public static void main(String args[]){

Student4 s1 = new Student4(111,"Karan");
Student4 s2 = new Student4(222,"Aryan");
s1.display();
s2.display();
}}

Output:

111 Karan
222 Aryan

Constructor Overloading in Java

Constructor overloading is a technique in Java in which a class can have any number of
constructors that differ in parameter lists.The compiler differentiates these constructors by
taking into account the number of parameters in the list and their type.

Example of Constructor Overloading

class Student5{
int id;
String name;
int age;
Student5(int i,String n){
id = i;
name = n;
}
Student5(int i,String n,int a){
id = i;
name = n;
age=a;
}
void display(){System.out.println(id+" "+name+" "+age);}

public static void main(String args[]){

Student5 s1 = new Student5(111,"Karan");
Student5 s2 = new Student5(222,"Aryan",25);
s1.display();
JAVA Page 20
PROGRAMMING
s2.display();
}}

Output:

111 Karan 0
222 Aryan 25
Java Copy Constructor

There is no copy constructor in java. But, we can copy the values of one object to another like
copy constructor in C++.

There are many ways to copy the values of one object into another in java. They are:

o By constructor
oBy assigning thevalues of one object into another
oBy clone() method of Object class

In this example, we are going to copy the values of one object into another using java
constructor.
class Student6{
int id;
String name;
Student6(int i,String n){
id = i;
name = n;
}

Student6(Student6 s){
id = s.id;
name =s.name;
}
void display(){System.out.println(id+" "+name);}

public static void main(String args[]){

Student6 s1 = new Student6(111,"Karan");
Student6 s2 = new Student6(s1);
s1.display();
s2.display();
}}

Output:

111 Karan
111 Karan

JAVA Page 21
PROGRAMMING
Java -Methods
A Java method is a collection of statements that are grouped together to perform an operation.
When you call the System.out.println() method, for example, the system actually executes several
statements in order to display a message on the console.

Now you will learn how to create your own methods with or without return values, invoke a
method with or without parameters, and apply method abstraction in the program design.

Creating Method
Considering the following example to explain the syntax of a method −

Syntax

public static int methodName(int a, int b) {

// body
}
Here,

 public static − modifier

 int − return type

 methodName − name of the method

 a, b − formal parameters

 int a, int b − list of parameters

Method definition consists of a method header and a method body. The same is shown in the
following syntax −

Syntax

modifier returnType nameOfMethod (Parameter List) {

// method body
}
The syntax shown above includes −

 modifier − It defines the access type of the method and it is optional to use.

 returnType − Method may return a value.

 nameOfMethod − This is the method name. The method signature consists of the method
name and the parameter list.

JAVA Page 22
PROGRAMMING
  Parameter List − The list of parameters, it is the type, order, and number of parameters
of a method. These are optional, method may contain zero parameters.

 method body − The method body defines what the method does with the statements.
Call by Value and Call by Reference in Java
There is only call by value in java, not call by reference. If we call a method passing a value, it
is known as call by value. The changes being done in the called method, is not affected in the
calling method.

Example of call by value in java

In case of call by value original value is not changed. Let's take a simple example:
class Operation{
int data=50;
void change(int data){
data=data+100;//changes will be in the local variable only
}
public static void main(String args[]){
Operation op=new Operation();
System.out.println("before change "+op.data);
op.change(500);
System.out.println("after change "+op.data);
}
}
Output:before change 50
after change 50

In Java, parameters are always passed by value. For example, following program prints
i = 10, j = 20.
// Test.java
class Test {
// swap() doesn't swap i and j
public static void swap(Integer i, Integer j) {
Integer temp = new Integer(i);
i = j;
j = temp;
}
public static void main(String[] args) {
Integer i = new Integer(10);
Integer j = new Integer(20);
swap(i, j);
System.out.println("i = " + i + ", j = " + j);

JAVA Page 23
PROGRAMMING
 }
}

Static Fields and Methods

The static keyword in java is used for memory management mainly. We can apply java static
keyword with variables, methods, blocks and nested class. The static keyword belongs to the class
than instance of the class.

The static can be:

1. variable (also known as class variable)

2. method (also known as class method)
3. block
4. nested class

Java static variable

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

o The static variable can be used to refer the common property of all objects (that is not unique for
each object) e.g. company name of employees,college name of students etc.

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

Advantage of static variable

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

Understanding problem without static variable

1. class Student{
2. int rollno;
3. String name;
4. String college="ITS";
5. }

Example of static variable

//Program of static variable
class Student8{
int rollno;

JAVA Page 24
PROGRAMMING
 String name;
static String college ="ITS";
Student8(int r,String n){
rollno = r;
name = n;
}
void display (){System.out.println(rollno+" "+name+" "+college);}
public static void main(String args[]){
Student8 s1 = new Student8(111,"Karan");
Student8 s2 = new Student8(222,"Aryan");

s1.display();
s2.display();
}}
Output:111 Karan ITS
222 Aryan ITS

Java static method

If you apply static keyword with any method, it is known as static method.

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

o A static method can be invoked without the need for creating an instance of a class.
o static method can access static data member and can change the value of it.

Example of static method

//Program of changing the common property of all objects(static field).

class Student9{
int rollno;
String name;
static String college = "ITS";
static void change(){
college = "BBDIT";
}
Student9(int r, String n){
rollno = r;
name = n;

JAVA Page 25
PROGRAMMING
 }
void display (){System.out.println(rollno+" "+name+" "+college);}
public static void main(String args[]){
Student9.change();
Student9 s1 = new Student9 (111,"Karan");
Student9 s2 = new Student9 (222,"Aryan");
Student9 s3 = new Student9 (333,"Sonoo");
s1.display();
s2.display();
s3.display();
}}
Output:111 Karan BBDIT
222 Aryan BBDIT
333 Sonoo BBDIT

Java static block

o Is used to initialize the static data member.

o It is executed before main method at the time of class loading.

Example of static block

class A2{
static{System.out.println("static block is invoked");}
public static void main(String args[]){
System.out.println("Hello main");
}}
Output: static block is invoked
Hello main

Access Control

Access Modifiers in java

There are two types of modifiers in java: access modifiers and non-access modifiers.

The access modifiers in java specifies accessibility (scope) of a data member, method, constructor
or class.

There are 4 types of java access modifiers:

JAVA Page 26
PROGRAMMING
 1. private
2. default
3. protected
4. public

private access modifier

The private access modifier is accessible only within class.

Simple example of private access modifier

In this example, we have created two classes A and Simple. A class contains private data
member and private method. We are accessing these private members from outside the class, so
there is compile time error.
class A{
private int data=40;
private void msg(){System.out.println("Hello java");} }
public class Simple{
public static void main(String args[]){
A obj=new A();
System.out.println(obj.data);//Compile Time Error
obj.msg();//Compile Time Error
}}

2) default access modifier

If you don't use any modifier, it is treated as default bydefault. The default modifier is
accessible only within package.

Example of default access modifier

In this example, we have created two packages pack and mypack. We are accessing the A class
from outside its package, since A class is not public, so it cannot be accessed from outside the
package.
//save by A.java
package pack;
class A{
void msg(){System.out.println("Hello");}
}

//save by B.java
package mypack;
import pack.*;

JAVA Page 27
PROGRAMMING
class B{
public static void main(String args[]){
A obj = new A();//Compile Time Error
obj.msg();//Compile Time Error } }

In the above example, the scope of class A and its method msg() is default so it cannot be
accessed from outside the package.

3) protected access modifier

The protected access modifier is accessible within package and outside the package but through
inheritance only.

The protected access modifier can be applied on the data member, method and constructor. It can't
be applied on the class.

Example of protected access modifier

In this example, we have created the two packages pack and mypack. The A class of pack package
is public, so can be accessed from outside the package. But msg method of this package is declared
as protected, so it can be accessed from outside the class only through inheritance.

//save by A.java
package pack;
public class A{
protected void msg(){System.out.println("Hello");} }
//save by B.java
package mypack;
import pack.*;
class B extends A{
public static void main(String args[]){
B obj = new B();
obj.msg();
}}
Output:Hello

4) public access modifier

The public access modifier is accessible everywhere. It has the widest scope among all other
modifiers.

JAVA Page 28
PROGRAMMING
Example of public access modifier
//save by A.java
package pack;
public class A{
public void msg(){System.out.println("Hello");} }
//save by B.java
package mypack;
import pack.*;
class B{
public static void main(String args[]){
A obj = new A();
obj.msg();
}}
Output:Hello

Understanding all java access modifiers

Let's understand the access modifiers by a simple table.

Access within within outside package by outside

Modifier class package subclass only package

Private Y N N N

Default Y Y N N

Protected Y Y Y N

Public Y Y Y Y

this keyword in java

Usage of java this keyword

Here is given the 6 usage of java this keyword.

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

2. this can be used to invoke current class method (implicitly)
3. this() can be used to invoke current class constructor.
JAVA Page 29
PROGRAMMING
 4. this can be passed as an argument in the method call.
5. this can be passed as argument in the constructor call.
6. this can be used to return the current class instance from the method.

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
112 sumit 6000

Difference between constructor and method in java

Java Constructor Java Method

Constructor is used to initialize the state of an object. Method is used to expose behaviour
of an object.

Constructor must not have return type. Method must have return type.

Constructor is invoked implicitly. Method is invoked explicitly.

The java compiler provides a default constructor if you Method is not provided by compiler in
don't have any constructor. any case.

Constructor name must be same as the class name. Method name may or may not be

JAVA Page 30
PROGRAMMING
 same as class name.

There are many differences between constructors and methods. They are given belo

Constructor Overloading in Java

Constructor overloading is a technique in Java in which a class can have any number of
constructors that differ in parameter lists.The compiler differentiates these constructors by
taking into account the number of parameters in the list and their type.

Example of Constructor Overloading

class Student5{
int id; String
name; int
age;
Student5(int i,String n){
id = i;
name = n;
}
Student5(int i,String n,int a){
id = i;
name = n;
age=a;
}
void display(){System.out.println(id+" "+name+" "+age);}

public static void main(String args[]){

Student5 s1 = new Student5(111,"Karan");
Student5 s2 = new Student5(222,"Aryan",25);
s1.display();
s2.display();
}
}

Output:

JAVA PROGRAMMING Page 31

 111 Karan 0
222 Aryan 25

Method Overloading in java

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

If we have to perform only one operation, having same name of the methods increases the
readability of the program.

Method Overloading: changing no. of arguments

In this example, we have created two methods, first add() method performs addition of two
numbers and second add method performs addition of three numbers.

In this example, we are creating static methods so that we don't need to create instance for calling
methods.

class Adder{
static int add(int a,int b){return a+b;}
static int add(int a,int b,int c){return a+b+c;}
}
class TestOverloading1{
public static void main(String[] args){
System.out.println(Adder.add(11,11));
System.out.println(Adder.add(11,11,11));
}}

Output:

22
33

Method Overloading: changing data type of arguments

In this example, we have created two methods that differs in data type. The first add method
receives two integer arguments and second add method receives two double arguments.

JAVA Page 32
PROGRAMMING
Recursion in Java
Recursion in java is a process in which a method calls itself continuously. A method in java that
calls itself is called recursive method.

Java Recursion Example 1: Factorial Number

public class RecursionExample3 {

static int factorial(int n){
if (n == 1)
return 1;
else
return(n * factorial(n-1));
}}
public static void main(String[] args) {
System.out.println("Factorial of 5 is: "+factorial(5));
}}

Output:

Factorial of 5 is: 120

Java Garbage Collection

In java, garbage means unreferenced objects.

Garbage Collection is process of reclaiming the runtime unused memory automatically. In other
words, it is a way to destroy the unused objects.

To do so, we were using free() function in C language and delete() in C++. But, in java it is
performed automatically. So, java provides better memory management.

Advantage of Garbage Collection

o It makes java memory efficient because garbage collector removes the unreferenced
objects from heap memory.
o It is automatically done by the garbage collector(a part of JVM) so we don't need to make
extra efforts.

gc() method

JAVA Page 33
PROGRAMMING
 The gc() method is used to invoke the garbage collector to perform cleanup processing. The
gc() is found in System and Runtime classes.

public static void gc(){}

Simple Example of garbage collection in java

public class TestGarbage1{
public void finalize(){System.out.println("object is garbage collected");}
public static void main(String args[]){
TestGarbage1 s1=new TestGarbage1();
TestGarbage1 s2=new TestGarbage1();
s1=null;
s2=null;
System.gc();
}}
object is garbage collected
object is garbage collected
Java String
string is basically an object that represents sequence of char values. An array of characters works
same as java string. For example:

1. char[] ch={'j','a','v','a','t','p','o','i','n','t'};
2. String s=new String(ch);

ssame as:

1. String s="javatpoint";
2. Java String class provides a lot of methods to perform operations on string such as
compare(), concat(), equals(), split(), length(), replace(), compareTo(), intern(), substring()
etc.
3. The java.lang.String class
implements Serializable, Comparable and CharSequence interfaces.

CharSequence Interface

JAVA Page 34
PROGRAMMING
 The CharSequence interface is used to represent sequence of characters. It is implemented by String,
StringBuffer and StringBuilder classes. It means, we can create string in java by using these 3
classes.

The java String is immutable i.e. it cannot be changed. Whenever we change any
string, a new instance is created. For mutable string, you can use StringBuffer and StringBuilder
classes.
There are two ways to create String object:
1. By string literal
2. By new keyword

String Literal

Java String literal is created by using double quotes. For Example:

1. String s="welcome";

Each time you create a string literal, the JVM checks the string constant pool first. If the string
already exists in the pool, a reference to the pooled instance is returned. If string doesn't exist in the
pool, a new string instance is created and placed in the pool. For example:

1. String s1="Welcome";
2. String s2="Welcome";//will not create new instance

By new keyword
1. String s=new String("Welcome");//creates two objects and one reference variable

In such case, JVM will create a new string object in normal (non pool) heap memory and the literal
"Welcome" will be placed in the string constant pool. The variable s will refer to the object in heap
(non pool).

Java String Example

public class StringExample{
public static void main(String args[]){
String s1="java";//creating string by java string literal
char ch[]={'s','t','r','i','n','g','s'};
String s2=new String(ch);//converting char array to string
String s3=new String("example");//creating java string by new keyword
System.out.println(s1);
System.out.println(s2);
System.out.println(s3);
}}
java

JAVA Page 35
PROGRAMMING
strings
example
Immutable String in Java

In java, string objects are immutable. Immutable simply means unmodifiable or unchangeable.

Once string object is created its data or state can't be changed but a new string object is created.

Let's try to understand the immutability concept by the example given below:

class Testimmutablestring{
public static void main(String args[]){
String s="Sachin";
s.concat(" Tendulkar");//concat() method appends the string at the end
System.out.println(s);//will print Sachin because strings are immutable objects
}}
Output:Sachin
class Testimmutablestring1{
public static void main(String args[]){
String s="Sachin";
s=s.concat(" Tendulkar");
System.out.println(s);
} } Output:Sachin Tendulkar

JAVA Page 36
PROGRAMMING
 Inheritance in Java
Inheritance in java is a mechanism in which one object acquires all the properties and behaviors
of parent object. Inheritance represents the IS-A relationship, also known as parent-
child relationship.

Why use inheritance in java

o For Method Overriding (so runtime polymorphism can be achieved).
o For Code Reusability.

Syntax of Java Inheritance

1. class Subclass-name extends Superclass-name
2. {
3. //methods and fields
4. }

The extends keyword indicates that you are making a new class that derives from an existing
class. The meaning of "extends" is to increase the functionality.

class Employee{
float salary=40000;
}
class Programmer extends Employee{
int bonus=10000;
public static void main(String args[]){
Programmer p=new Programmer();
System.out.println("Programmer salary is:"+p.salary);
System.out.println("Bonus of Programmer is:"+p.bonus);
}}

Programmer salary is:40000.0

JAVA Page 37
PROGRAMMING
 Bonus of programmer is:10000

Types of inheritance in java

Single Inheritance Example

File: TestInheritance.java

class Animal{
void eat(){System.out.println("eating...");}
}
class Dog extends Animal{
void bark(){System.out.println("barking...");}
}
class TestInheritance{
public static void main(String args[]){
Dog d=new Dog();
d.bark();
d.eat();
}}
Output:
barking...
eating...

Multilevel Inheritance Example

File: TestInheritance2.java

class Animal{
void eat(){System.out.println("eating...");}
}
class Dog extends Animal{
void bark(){System.out.println("barking...");}
}
class BabyDog extends Dog{
void weep(){System.out.println("weeping...");}
}
class TestInheritance2{

JAVA Page 38
PROGRAMMING
public static void main(String args[]){
BabyDog d=new BabyDog();
d.weep();
d.bark();
d.eat();
}}

Output:

weeping...
barking...
eating...

Hierarchical Inheritance Example

File: TestInheritance3.java

class Animal{
void eat(){System.out.println("eating...");}
}
class Dog extends Animal{
void bark(){System.out.println("barking...");}
}
class Cat extends Animal{
void meow(){System.out.println("meowing...");}
}
class TestInheritance3{
public static void main(String args[]){
Cat c=new Cat();
c.meow();
c.eat();
//c.bark();//C.T.Error
}}

Output:

meowing...
eating...

JAVA Page 39
PROGRAMMING
Member access and Inheritance

A subclass includes all of the members of its super class but it cannot access those members of
the super class that have been declared as private. Attempt to access a private variable would
cause compilation error as it causes access violation. The variables declared as private, is only
accessible by other members of its own class. Subclass have no access to it.

super keyword in java

The super keyword in java is a reference variable which is used to refer immediate parent class
object.

Whenever you create the instance of subclass, an instance of parent class is created implicitly
which is referred by super reference variable.

Usage of java super Keyword

1. super can be used to refer immediate parent class instance variable.

2. super can be used to invoke immediate parent class method.

3. super() can be used to invoke immediate parent class constructor.

super is used to refer immediate parent class instance variable.

class Animal{
String color="white";
}
class Dog extends Animal{
String color="black";
void printColor(){
System.out.println(color);//prints color of Dog class
System.out.println(super.color);//prints color of Animal class
}
}
class TestSuper1{
public static void main(String args[]){
Dog d=new Dog();

JAVA Page 40
PROGRAMMING
 d.printColor();
}}

Output:

black
white

Final Keyword in Java

The final keyword in java is used to restrict the user. The java final keyword can be used in many context.
Final can be:

1. variable

2. method

3. class

The final keyword can be applied with the variables, a final variable that have no value it is called 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.

Object class in Java

The Object class is the parent class of all the classes in java by default. In other words, it is the
topmost class of java.

The Object class is beneficial if you want to refer any object whose type you don't know. Notice
that parent class reference variable can refer the child class object, know as upcasting.

Let's take an example, there is getObject() method that returns an object but it can be of any type
like Employee,Student etc, we can use Object class reference to refer that object. For example:

1. Object obj=getObject();//we don't know what object will be returned from this method

The Object class provides some common behaviors to all the objects such as object can be
compared, object can be cloned, object can be notified etc.

Method Overriding in Java

If subclass (child class) has the same method as declared in the parent class, it is known
as method overriding in java.

JAVA Page 41
PROGRAMMING
 Usage of Java Method Overriding
o Method overriding is used to provide specific implementation of a method that is already
provided by its super class.
o Method overriding is used for runtime polymorphism

Rules for Java Method Overriding

1. method must have same name as in the parent class
2. method must have same parameter as in the parent class.
3. must be IS-A relationship (inheritance).

Example of method overriding

Class Vehicle{
void run(){System.out.println("Vehicle is running");}
}
class Bike2 extends Vehicle{
void run(){System.out.println("Bike is running safely");}
public static void main(String args[]){
Bike2 obj = new Bike2();
obj.run();
}

Output:Bike is running safely

1. class Bank{
int getRateOfInterest(){return 0;}
}
class SBI extends Bank{
int getRateOfInterest(){return 8;}
}
class ICICI extends Bank{
int getRateOfInterest(){return 7;}
}
class AXIS extends Bank{
int getRateOfInterest(){return 9;}
}
class Test2{
public static void main(String args[]){
SBI s=new SBI();
ICICI i=new ICICI();
AXIS a=new AXIS();
System.out.println("SBI Rate of Interest: "+s.getRateOfInterest());
System.out.println("ICICI Rate of Interest: "+i.getRateOfInterest());
System.out.println("AXIS Rate of Interest: "+a.getRateOfInterest());
}}

Output:
SBI Rate of Interest: 8

JAVA Page 42
PROGRAMMING
 ICICI Rate of Interest: 7
AXIS Rate of Interest: 9

Abstract class in Java

A class that is declared with abstract keyword is known as abstract class in java. It can have abstract
and non-abstract methods (method with body). It needs to be extended and its method implemented.
It cannot be instantiated.

Example abstract class

1. abstract class A{}

abstract method
1. abstract void printStatus();//no body and abstract

Example of abstract class that has abstract method

abstract class Bike{
abstract void run();
}
class Honda4 extends Bike{
void run(){System.out.println("running safely..");}
public static void main(String args[]){
Bike obj = new Honda4();
obj.run();
}
1. }
running safely..
Interface in Java
An interface in java is a blueprint of a class. It has static constants and abstract methods.

The interface in java is a mechanism to achieve abstraction. There can be only abstract methods
in the java interface not method body. It is used to achieve abstraction and multiple inheritance in
Java.

Java Interface also represents IS-A relationship.

It cannot be instantiated just like abstract class.

There are mainly three reasons to use interface. They are given below.
o It is used to achieve abstraction.
o By interface, we can support the functionality of multiple inheritance.
o It can be used to achieve loose coupling.

JAVA Page 43
PROGRAMMING
 Internal addition by compiler

Understanding relationship between classes and interfaces

//Interface declaration: by first user

interface Drawable{
void draw();
}
//Implementation: by second user
class Rectangle implements Drawable{
public void draw(){System.out.println("drawing rectangle");}
}
class Circle implements Drawable{
public void draw(){System.out.println("drawing circle");}
}
//Using interface: by third user
class TestInterface1{
public static void main(String args[]){
Drawable d=new Circle();//In real scenario, object is provided by method e.g. getDrawable()
d.draw();
}}
Output:drawing circle

Multiple inheritance in Java by interface

interface Printable{

JAVA Page 44
PROGRAMMING
void print();
}
interface Showable{
void show();
}
class A7 implements Printable,Showable{
public void print(){System.out.println("Hello");}
public void show(){System.out.println("Welcome");}
public static void main(String args[]){
A7 obj = new A7();
obj.print();
obj.show();
}}

Output:Hello
Welcome
Abstract class Interface
1) Abstract class can have abstract Interface can have only abstract methods. Since
and non-abstract methods. Java 8, it can have default and static methods
also.
2) Abstract class doesn't support Interface supports multiple inheritance.
multiple inheritance.
3) Abstract class can have final, non- Interface has only static and final variables.
final, static and non-static variables.
4) Abstract class can provide the Interface can't provide the implementation of
implementation of interface. abstract class.
5) The abstract keyword is used to The interface keyword is used to declare
declare abstract class. interface.
6) Example: Example:
public abstract class Shape{ public interface Drawable{
public abstract void draw(); void draw();
} }

Java Inner Classes

Java inner class or nested class is a class which is declared inside the class or interface.

We use inner classes to logically group classes and interfaces in one place so that it can be more
readable and maintainable.

Syntax of Inner class

1. class Java_Outer_class{
2. //code
3. class Java_Inner_class{
4. //code
5. }}

JAVA Page 45
PROGRAMMING
 Advantage of java inner classes

There are basically three advantages of inner classes in java. They are as follows:

1) Nested classes represent a special type of relationship that is it can access all the members
(data members and methods) of outer class including private.

2) Nested classes are used to develop more readable and maintainable code because it
logically group classes and interfaces in one place only.

3) Code Optimization: It requires less code to write.

Difference between nested class and inner class in Java

Inner class is a part of nested class. Non-static nested classes are known as inner classes.

Types of Nested classes

There are two types of nested classes non-static and static nested classes.The non-static nested
classes are also known as inner classes.

o Non-static nested class (inner class)

1. Member inner class
2. Anonymous inner class
3. Local inner class
o Static nested class

Java Package
A java package is a group of similar types of classes, interfaces and sub-packages.

Package in java can be categorized in two form, built-in package and user-defined package.

There are many built-in packages such as java, lang, awt, javax, swing, net, io, util, sql etc.

Advantage of Java Package

1) Java package is used to categorize the classes and interfaces so that they can be easily
maintained.

2) Java package provides access protection.

3) Java package removes naming collision.

package mypack;
public class Simple{
public static void main(String args[]){
System.out.println("Welcome to package");
}}

JAVA Page 46
PROGRAMMING
How to compile java package

If you are not using any IDE, you need to follow the syntax given below:

javac -d directory javafilename

How to run java package program

To Compile: javac -d . Simple.java

To Run: java mypack.Simple

Using fully qualified name

Example of package by import fully qualified name

//save by A.java
package pack;
public class A{
public void msg(){System.out.println("Hello");}
}

//save by B.java package mypack;

class B{
public static void main(String args[])
{
pack.A obj = new pack.A();//using fully qualified name obj.msg();
}
}
Output:Hello

Exception Handling
JAVA Page 47
PROGRAMMING
The exception handling in java is one of the powerful mechanism to handle the runtime errors so that normal
flow of the application can be maintained.

What is exception

In java, exception is an event that disrupts the normal flow of the program. It is an object which is thrown at
runtime.

Advantage of Exception Handling

The core advantage of exception handling is to maintain the normal flow of the application. Exception normally
disrupts the normal flow of the application that is why we use exception handling.
Types of Exception

There are mainly two types of exceptions: checked and unchecked where error is considered as unchecked
exception. The sun microsystem says there are three types of exceptions:
1. Checked Exception
2. Unchecked Exception
3. Error

Difference between checked and unchecked exceptions

1) Checked Exception: The classes that extend Throwable class except RuntimeException and Error
are known as checked exceptions e.g.IOException, SQLException etc. Checked exceptions are
checked at compile-time.
2) Unchecked Exception: The classes that extend RuntimeException are known as unchecked
exceptions e.g. ArithmeticException, NullPointerException, ArrayIndexOutOfBoundsException
etc. Unchecked exceptions are not checked at compile-time rather they are checked at runtime.
3) Error: Error is irrecoverable e.g. OutOfMemoryError, VirtualMachineError, AssertionErroretc.

JAVA Page 48
PROGRAMMING
Hierarchy of Java Exception classes

Checked and UnChecked Exceptions

JAVA Page 49
PROGRAMMING
Java try block

Java try block is used to enclose the code that might throw an exception. It must be used within the method.

Java try block must be followed by either catch or finally block.

Syntax of java try-catch

1. try{
2. //code that may throw exception
3. }catch(Exception_class_Name ref){} Syntax of try-finally block
1. try{
2. //code that may throw exception
3. }finally{}

Java catch block

Java catch block is used to handle the Exception. It must be used after the try block only. You can use multiple catch
block with a single try.
Problem without exception handling

Let's try to understand the problem if we don't use try-catch block.

public class Testtrycatch1{

public static void main(String args[]){ int data=50/0;//may throw exception System.out.println("rest of the
code...");
}}
Output:
Exception in thread main java.lang.ArithmeticException:/ by zero

As displayed in the above example, rest of the code is not executed (in such case, rest of the code... statement is not
printed).

There can be 100 lines of code after exception. So all the code after exception will not be executed.

Solution by exception handling

Let's see the solution of above problem by java try-catch block.

public class Testtrycatch2{

JAVA Page 50
PROGRAMMING
 public static void main(String args[]){
try{
int data=50/0;
}catch(ArithmeticException e){System.out.println(e);} System.out.println("rest of the code...");
}}
1. Output:
Exception in thread main java.lang.ArithmeticException:/ by zero
rest of the code...

Now, as displayed in the above example, rest of the code is executed i.e. rest of the code... statement is printed.

Java Multi catch block

If you have to perform different tasks at the occurrence of different Exceptions, use java multi catch block.

Let's see a simple example of java multi-catch block.

1. public class TestMultipleCatchBlock{

2. public static void main(String args[]){
3. try{
4. int a[]=new int[5]; 5. a[5]=30/0;
6. }
7. catch(ArithmeticException e){System.out.println("task1 is completed");}
8. catch(ArrayIndexOutOfBoundsException e){System.out.println("task 2 completed"); 9. }
10. catch(Exception e){System.out.println("common task completed");
11. }
12. System.out.println("rest of the code..."); 13. } }

Output:task1 completed
rest of the code...

Java nested try example

Let's see a simple example of java nested try block.

class Excep6{
public static void main(String args[]){
try{ try{
System.out.println("going to divide");
int b =39/0;
}catch(ArithmeticException e){System.out.println(e);}

try{

JAVA Page 51
PROGRAMMING
 int a[]=new int[5]; a[5]=4;
}catch(ArrayIndexOutOfBoundsException e){System.out.println(e);} System.out.println("other
statement);
}catch(Exception e){System.out.println("handeled");} System.out.println("normal flow..");
} 1. }
Java finally block

Java finally block is a block that is used to execute important code such as closing connection, stream etc.

Java finally block is always executed whether exception is handled or not. Java finally block follows try or catch
block.

Usage of Java finally

Case 1
Let's see the java finally example where exception doesn't occur. class TestFinallyBlock{
public static void main(String args[]){
try{
int data=25/5; System.out.println(data);
}
catch(NullPointerException e){System.out.println(e);} finally{System.out.println("finally block is
always executed");} System.out.println("rest of the code...");
}
}
Output:5
finally block is always executed
rest of the code...

Java throw keyword

The Java throw keyword is used to explicitly throw an exception.

We can throw either checked or uncheked exception in java by throw keyword. The throw keyword is mainly used
to throw custom exception. We will see custom exceptions later.

The syntax of java throw keyword is given below.

1. throw exception;

JAVA Page 52
PROGRAMMING
Java throw keyword example

In this example, we have created the validate method that takes integer value as a parameter. If the age is less than
18, we are throwing the ArithmeticException otherwise print a message welcome to vote.

1. public class TestThrow1{

static void validate(int age){
if(age<18)
throw new ArithmeticException("not valid");
else
System.out.println("welcome to vote");
}
public static void main(String args[]){ validate(13);
System.out.println("rest of the code...");
} }

Output:

Exception in thread main java.lang.ArithmeticException:not valid

Java throws keyword

The Java throws keyword is used to declare an exception. It gives an information to the programmer that there may
occur an exception so it is better for the programmer to provide the exception handling code so that normal flow can
be maintained.

Exception Handling is mainly used to handle the checked exceptions. If there occurs any unchecked exception such
as NullPointerException, it is programmers fault that he is not performing check up before the code being used.

Syntax of java throws

1. return_type method_name() throws exception_class_name{
2. //method code 3. }
4.

Java throws example

Let's see the example of java throws clause which describes that checked exceptions can be propagated by
throws keyword.

import java.io.IOException;
class Testthrows1{
void m()throws IOException{
throw new IOException("device error");//checked exception

JAVA Page 53
PROGRAMMING
 }
void n()throws IOException{ m();
}
void p(){
try{ n();
}catch(Exception e){System.out.println("exception handled");}
}
public static void main(String args[]){ Testthrows1 obj=new Testthrows1(); obj.p();
System.out.println("normal flow..."); } } Output:

exception handled
normal flow...
Java Custom Exception

If you are creating your own Exception that is known as custom exception or user-defined exception. Java custom
exceptions are used to customize the exception according to user need.

By the help of custom exception, you can have your own exception and message. Let's see a simple example of java
custom exception.
class InvalidAgeException extends Exception{ InvalidAgeException(String s){
super(s);
}}
class TestCustomException1{
static void validate(int age)throws InvalidAgeException{
if(age<18)
throw new InvalidAgeException("not valid");
else
System.out.println("welcome to vote");
}
public static void main(String args[]){
try{ validate(13);
}catch(Exception m){System.out.println("Exception occured: "+m);}

System.out.println("rest of the code...");

}}

Output:Exception occured: InvalidAgeException:not valid rest of the code...

JAVA Page 54
PROGRAMMING
 Multithreading

Multithreading in java is a process of executing multiple threads simultaneously.

Thread is basically a lightweight sub-process, a smallest unit of processing. Multiprocessing and multithreading,
both are used to achieve multitasking.

But we use multithreading than multiprocessing because threads share a common memory area. They don't allocate
separate memory area so saves memory, and context-switching between the threads takes less time than process.

Java Multithreading is mostly used in games, animation etc.

Advantages of Java Multithreading

1) It doesn't block the user because threads are independent and you can perform multiple operations at
same time.

2) You can perform many operations together so it saves time.

3) Threads are independent so it doesn't affect other threads if exception occur in a single thread.

Life cycle of a Thread (Thread States)

A thread can be in one of the five states. According to sun, there is only 4 states in thread life cycle in java new,
runnable, non-runnable and terminated. There is no running state.

But for better understanding the threads, we are explaining it in the 5 states.

The life cycle of the thread in java is controlled by JVM. The java thread states are as follows:
1. New
2. Runnable
3. Running
4. Non-Runnable (Blocked)
5. Terminated

JAVA Page 55
PROGRAMMING
How to create thread

There are two ways to create a thread:

1. By extending Thread class

2. By implementing Runnable interface.

Thread class:

Thread class provide constructors and methods to create and perform operations on a thread.Thread class
extends Object class and implements Runnable interface.

Commonly used Constructors of Thread class:

o Thread()
o Thread(String name)
o Thread(Runnable r)
o Thread(Runnable r,String name)

JAVA Page 56
PROGRAMMING
Commonly used methods of Thread class:

1. public void run(): is used to perform action for a thread.

2. public void start(): starts the execution of the thread.JVM calls the run() method on the thread.
3. public void sleep(long miliseconds): Causes the currently executing thread to sleep (temporarily cease
execution) for the specified number of milliseconds.
4. public void join(): waits for a thread to die.
5. public void join(long miliseconds): waits for a thread to die for the specified miliseconds.
6. public int getPriority(): returns the priority of the thread.
7. public int setPriority(int priority): changes the priority of the thread.
8. public String getName(): returns the name of the thread.
9. public void setName(String name): changes the name of the thread.
10. public Thread currentThread(): returns the reference of currently executing thread.
11. public int getId(): returns the id of the thread.
12. public Thread.State getState(): returns the state of the thread.
13. public boolean isAlive(): tests if the thread is alive.
14. public void yield(): causes the currently executing thread object to temporarily pause and allow other
threads to execute.
15. public void suspend(): is used to suspend the thread(depricated).
16. public void resume(): is used to resume the suspended thread(depricated).
17. public void stop(): is used to stop the thread(depricated).
18. public boolean isDaemon(): tests if the thread is a daemon thread.
19. public void setDaemon(boolean b): marks the thread as daemon or user thread.
20. public void interrupt(): interrupts the thread.
21. public boolean isInterrupted(): tests if the thread has been interrupted.
22. public static boolean interrupted(): tests if the current thread has been interrupted.

Runnable interface:

The Runnable interface should be implemented by any class whose instances are intended to be executed
by a thread. Runnable interface have only one method named run().
1. public void run(): is used to perform action for a thread.

Starting a thread:

start() method of Thread class is used to start a newly created thread. It performs following tasks:
o A new thread starts(with new callstack).
o The thread moves from New state to the Runnable state.
o When the thread gets a chance to execute, its target run() method will run.

JAVA Page 57
PROGRAMMING
Java Thread Example by extending Thread class

class Multi extends Thread{

public void run(){ System.out.println("thread is running...");
}
public static void main(String args[]){ Multi t1=new Multi();
t1.start();
}}
Output:thread is running...

Java Thread Example by implementing Runnable interface

class Multi3 implements Runnable{ public void run(){ System.out.println("thread is running...");

}
public static void main(String args[]){ Multi3 m1=new Multi3();
Thread t1 =new Thread(m1); t1.start();
}}
Output:thread is running...

Priority of a Thread (Thread Priority):

Each thread have a priority. Priorities are represented by a number between 1 and 10. In most cases,
thread schedular schedules the threads according to their priority (known as preemptive scheduling). But
it is not guaranteed because it depends on JVM specification that which scheduling it chooses.

3 constants defined in Thread class:

1. public static int MIN_PRIORITY

2. public static int NORM_PRIORITY
3. public static int MAX_PRIORITY

Default priority of a thread is 5 (NORM_PRIORITY). The value of MIN_PRIORITY is 1 and the value
of MAX_PRIORITY is 10.

Example of priority of a Thread: class TestMultiPriority1 extends Thread{ public void run(){
System.out.println("running thread name is:"+Thread.currentThread().getName());
System.out.println("running thread priority is:"+Thread.currentThread().getPriority());
}
public static void main(String args[]){

JAVA Page 58
PROGRAMMING
 TestMultiPriority1 m1=new TestMultiPriority1(); TestMultiPriority1 m2=new TestMultiPriority1();
m1.setPriority(Thread.MIN_PRIORITY); m2.setPriority(Thread.MAX_PRIORITY); m1.start();
m2.start();
}}
Output:running thread name is:Thread-0 running thread priority is:10
running thread name is:Thread-1 running thread priority is:1

Java synchronized method

If you declare any method as synchronized, it is known as synchronized method. Synchronized method is used to
lock an object for any shared resource.
When a thread invokes a synchronized method, it automatically acquires the lock for that object and releases it when
the thread completes its task.

Example of inter thread communication in java

Let's see the simple example of inter thread communication.

class Customer{
int amount=10000;
synchronized void withdraw(int amount){ System.out.println("going to withdraw...");
if(this.amount<amount){
System.out.println("Less balance; waiting for deposit...");
try{wait();}catch(Exception e){}
}
this.amount-=amount; System.out.println("withdraw completed...");
}
synchronized void deposit(int amount){ System.out.println("going to deposit..."); this.amount+=amount;
System.out.println("deposit completed... "); notify();
}
}
class Test{
public static void main(String args[]){ final Customer c=new Customer(); new Thread(){
public void run(){c.withdraw(15000);}
}.start();
new Thread(){

JAVA Page 59
PROGRAMMING
 public void run(){c.deposit(10000);}
}
start();
}}
Output: going to withdraw...
Less balance; waiting for deposit...
going to deposit...
deposit completed...
withdraw completed
ThreadGroup in Java

Java provides a convenient way to group multiple threads in a single object. In such way, we can suspend, resume or
interrupt group of threads by a single method call.

Note: Now suspend(), resume() and stop() methods are deprecated.

Java thread group is implemented by java.lang.ThreadGroup class. Constructors of ThreadGroup class

There are only two constructors of ThreadGroup class.

ThreadGroup(String name) ThreadGroup(ThreadGroup parent, String name)

Let's see a code to group multiple threads.

1. ThreadGroup tg1 = new ThreadGroup("Group A");

2. Thread t1 = new Thread(tg1,new MyRunnable(),"one");
3. Thread t2 = new Thread(tg1,new MyRunnable(),"two");
4. Thread t3 = new Thread(tg1,new MyRunnable(),"three");

Now all 3 threads belong to one group. Here, tg1 is the thread group name, MyRunnable is the class that implements
Runnable interface and "one", "two" and "three" are the thread names.

Now we can interrupt all threads by a single line of code only.

1. Thread.currentThread().getThreadGroup().interrupt();

Exploring java.net and java.text

JAVA Page 60
PROGRAMMING
 java.net
The term network programming refers to writing programs that execute across multiple devices
(computers), in which the devices are all connected to each other using a network.
The java.net package of the J2SE APIs contains a collection of classes and interfaces that provide the
low-level communication details, allowing you to write programs that focus on solving the problem at
hand.
The java.net package provides support for the two common network protocols −

 TCP − TCP stands for Transmission Control Protocol, which allows for reliable communication
between two applications. TCP is typically used over the Internet Protocol, which is referred to as
TCP/IP.
 UDP − UDP stands for User Datagram Protocol, a connection-less protocol that allows for
packets of data to be transmitted between applications.
This chapter gives a good understanding on the following two subjects −

 Socket Programming − This is the most widely used concept in Networking and it has been
explained in very detail.
 URL Processing − This would be covered separately.

java.text

The java.text package is necessary for every java developer to master because it has a lot of classes that is helpful in
formatting such as dates, numbers, and messages.

java.text Classes
The following are the classes available for java.text package [table]
Class|Description
SimpleDateFormat|is a concrete class that helps in formatting and parsing of dates. [/table]

JAVA Page 61
PROGRAMMING
Applets

Applet is a special type of program that is embedded in the webpage to generate the dynamic
content. It runs inside the browser and works at client side.

Advantage of Applet
There are many advantages of applet. They are as follows:

o It works at client side so less response time.

o Secured
o It can be executed by browsers running under many plateforms, including Linux,
Windows, Mac Os etc.

Drawback of Applet
o Plugin is required at client browser to execute applet.

Lifecycle of Java Applet Hierarchy of Applet

1. Applet is initialized.
2. Applet is started.
3. Applet is painted.
4. Applet is stopped.
5. Applet is destroyed.

Lifecycle methods for Applet:

The java.applet.Applet class 4 life cycle methods and java.awt.Component class provides 1 life
cycle methods for an applet.

java.applet.Applet class

For creating any applet java.applet.Applet class must be inherited. It provides 4 life cycle methods
of applet.

1. public void init(): is used to initialized the Applet. It is invoked only once.
2. public void start(): is invoked after the init() method or browser is maximized. It is used
to start the Applet.
3. public void stop(): is used to stop the Applet. It is invoked when Applet is stop or
browser is minimized.
4. public void destroy(): is used to destroy the Applet. It is invoked only once.

JAVA Page 62
PROGRAMMING
 java.awt.Component class

The Component class provides 1 life cycle method of applet.

1. public void paint(Graphics g): is used to paint the Applet. It provides Graphics class
object that can be used for drawing oval, rectangle, arc etc.

Simple example of Applet by html file:

To execute the applet by html file, create an applet and compile it. After that create an html file
and place the applet code in html file. Now click the html file.

1. //First.java
import java.applet.Applet;
import java.awt.Graphics;
public class First extends Applet{
public void paint(Graphics g){
g.drawString("welcome",150,150);
}
}

Simple example of Applet by appletviewer tool:

To execute the applet by appletviewer tool, create an applet that contains applet tag in comment
and compile it. After that run it by: appletviewer First.java. Now Html file is not required but it is
for testing purpose only.

1. //First.java
import java.applet.Applet;
import java.awt.Graphics;
public class First extends Applet{
public void paint(Graphics g){
g.drawString("welcome to applet",150,150);
}
}
/*
<applet code="First.class" width="300" height="300">
</applet>
*/

JAVA Page 63
PROGRAMMING
To execute the applet by appletviewer tool, write in command prompt:

c:\>javac First.java
c:\>appletviewer First.java

Difference between Applet and Application programming

JAVA Page 64
PROGRAMMING
 Parameter in Applet
We can get any information from the HTML file as a parameter. For this purpose, Applet class
provides a method named getParameter(). Syntax:

1. public String getParameter(String parameterName)

Example of using parameter in Applet:

1. import java.applet.Applet;
2. import java.awt.Graphics;
3. public class UseParam extends Applet
4. {
5. public void paint(Graphics g)
6. {
7. String str=getParameter("msg");
8. g.drawString(str,50, 50);
9. } }
myapplet.html
1. <html>
2. <body>
3. <applet code="UseParam.class" width="300" height="300">
4. <param name="msg" value="Welcome to applet">
5. </applet>
6. </body>
7. </html>

JAVA Page 65
PROGRAMMING
Network programming in java
UDP Sockets

• Since UDP is a connectionless protocol; there is no virtual stream between the

hosts so streams are not used for IO.
• UDP applications are not thought of in terms of clients and servers, but rather in
terms of senders and receivers.
• For conversational applications both ends (sender and receiver) will be changing states from
sender to receiver and back again
• Many UDP based applications are simple send a request then receive the data (sender’s
perspective), like a DNS request. The receiver’s perspective is to ‘listen’ for a request, send
the response, listen for more requests.
 DatagramPacket Class
• UDP sockets send and receive Datagrams
• Constructors: two for receiving, four for sending
• DatagramPacket( byte[ ] buff , int len)
• Constructs a DatagramPacket for receiving packets of length len.
• DatagramPacket(byte[] buf, int off, int len)
• Constructs a DatagramPacket for receiving packets of length len, specifying an
offset of off bytes into the buffer.
• DatagramPacket((byte[] buf, int len, InetAddress addr, int port)
• Constructs a datagram packet for sending packets of length len to the
specified port number on the specified host.
• DatagramPacker(byte[] buf, int off, int len, InetAddress addr, int port)
• Constructs a datagram packet for sending packets of length len with offset off
to the specified port number on the specified host.
• DatagramPacket(byte[] buf, int off, int len, SocketAddress addr)
• Constructs a datagram packet for sending packets of length len with offset off
to the specified port number on the specified host.
DatagramPacket Class
• DatagramPacket(byte[] buf, int len, SocketAddress addr)
• Constructs a datagram packet for sending packets of length len to the
specified port number on the specified host.

Getter methods Setter methods

getAddress( setAddress(InetAddress
) iaddr)
getData( ) setData(byte[ ] buf)
getLength( ) setData(byte[] buf, int offset,
getOffset( ) int length)
getPort( ) setLength(int len)
getSocketAd setPort(int port)
dress( ) setSocketAddress(SocketAd
dress saddr)
 DatagramSocket Class – UDP Sockets

• Constructors
• DatagramSocket()
• Constructs a datagram socket and binds it to any available port on the local host.
• DatagramSocket(DatagramSocketImpl impl)
• Creates an unbound datagram socket with the specified DatagramSocketImpl.
• DatagramSocket(int port)
• Constructs a datagram socket and binds it to the specified port on the local host.
• DatagramSocket(int port, InetAddress iaddr)
• Creates a datagram socket, bound to the specified local address.
• DatagramSocket(SocketAddress bindaddr)
• Creates a datagram socket, bound to the specified local socket address.
DatagramSocket Class – operational Methods

• Operational (void) Methods

• bind(SocketAddress addr)
• connect(InetAddress address, int port)
• connect(SocketAddress addr)
• disconnect( )
• receive(DatagramPacket p)
• send(DatagramPacket p)
• close( )
DatagramSocket Class – getter methods
Getter Methods:
DatagramChannel getChannel( )
InetAddress getInetAddress( )
boolean getBroadcast( )
InetAddress getLocalAddress( )
int getLocalPort( )
SocketAddress getLocalSocketAddress( )
SocketAddress getRemoteSocketAddress( )
int getPort( )
int getReceiveBufferSize( )
int getSendBufferSize( )
boolean getReuseAddress( )
int getSoTimeout( )
int getTrafficClass( )
DatagramSocket Class – setter methods

Setter Methods:
void setBroadcast( boolean on)
static void setDatagramSocketImplFactory
(DatagramSocketImplFactory fac)
void serReceiveBufferSize(int size)
void setReuseAddress(boolean on)
void setSevdBufferSize(int size)
void setSoTimeout(int timeout)
void setTrafficClass(int tc)
DatagramSocket Class – test methods

Test Methods:
boolean isBound( )
boolean isClosed( )
boolean isConnected( )
Datagram Sockets Examples

• See examples on web site

 URL Class

• RFC 2396
• essentially a “pointer” to a resource on the World Wide Web
• different services use slightly different formats
• file://ftp.yoyodyne.com/pub/files/foobar.txt
• http://www.yahoo.com/index.html
• ftp://[email protected]
• news:rec.gardening
• gopher://gopher.banzai.edu:1234/
 URL Class - Constructors
• URL(String spec)
• Creates a URL object from the String representation.
• URL(String protocol, String host, int port, String file)
• Creates a URL object from the specified protocol, host, port number, and file.
• URL(String protocol, String host, int port, String file, URLStreamHandler handler)
• Creates a URL object from the specified protocol, host, port number, file, and handler.
• URL(String protocol, String host, String file)
• Creates a URL from the specified protocol name, host name, and file name.

• URL(URL context, String spec)

• Creates a URL by parsing the given spec within a specified context
• URL(URL context, String spec, URLStreamHandler handler)
• Creates a URL by parsing the given spec with the specified handler within a specified
context.
URL Class - Methods
Getters
String getAuthority( )
Object getContent( )
Object getContent(Classes[ ] classes)
int getDefaultPort( )
String getFile( )
String getHost( )
String getPath( )
int getPort( )
String getProtocol( )
String getQuery( )
String getRef( )
String getUserInfo( )
URL Class - Methods

Setters
set(String protocol, String host, int port, String file, String ref)

set(String protocol, String host, int port, String authority, String userInfo, String path,
String query,
String ref)

setURLStreamHandlerFactory(URLStreamHandlerFactory fac)
URL Class – Utility methods

int hashCode( )
URLConnection openConnection( )
InputStream openStream( )
boolean sameFile(URL other)
String toExternalForm( )
String toString( )
boolean equals(Object obj)
URL Class - example

• see ReadURL example on web site

ServerSocket
• Used as the main connection point for some service you wish to
provide.
• Once created, it listens for connection requests then queues the
request for disposition
• On Unix/Linux you must be root to use
ServerSocket – Life cycle
• A new ServerSocket is created on a particular port using a
ServerSocket( ) constructor.
• The ServerSocket listens for incoming connection attempts on that port
using its accept( ) method. accept( ) blocks until a client attempts to
make a connection, at which point accept( ) returns a Socket object
connecting the client and the server.
• Depending on the type of server, either the Socket's getInputStream( )
method, getOutputStream( ) method, or both are called to get input
and output streams that communicate with the client.
• The server and the client interact according to an agreed-upon
protocol until it is time to close the connection.
• The server, the client, or both close the connection.
• The server returns to step 2 and waits for the next connection.
ServerSockets - threads
• Simultaneous requests are held in a queue, as each request is removed from the queue and
processed new connections requests can be added to the queue. Connection requests received
while the queue is full will be blocked.
• Some clients use multiple retries in this case as queue space will usually open up pretty quickly.
• For simple protocols (DayTime) the queue can usually handle all of the requests without
problem
• For more complex protocols (HTTP) use a thread to process each connection. Threads have less
overhead than spawning an entire child process.
ServerSocket - Constructors
• public ServerSocket(int port) throws IOException, BindException

• public ServerSocket(int port, int queueLength) throws IOException, BindException

• public ServerSocket(int port, int queueLength, InetAddress bindAddress) throws IOException

ServerSocket – methods

• accept( ) – accepts a connection request and creates a socket to the

remote user
• close( ) – close the server socket and wait for next connection request
ServerSocket - example

ServerSocket server = new ServerSocket(5776);

while (true)
{ Socket connection = server.accept( );
OutputStreamWriter out =
new OutputStreamWriter(connection.getOutputStream( ));
out.write("You've connected to this server. Bye-bye now.\r\n");
connection.close( );
}
Server Sockets - problems
• You are not root
• Port is already in use
Java Sockets Programming
• The package java.net provides support for sockets programming (and
more).

• Typically you import everything defined in this package with:

import java.net.*;

Java Socket Programming 24

Classes
InetAddress

Socket

ServerSocket

DatagramSocket

DatagramPacket

Java Socket Programming 25

InetAddress class
• static methods you can use to create new InetAddress
objects.
• getByName(String host)
• getAllByName(String host)
• getLocalHost()

InetAddress x = InetAddress.getByName(
“cse.unr.edu”);
Throws UnknownHostException

Java Socket Programming 26

Sample Code: Lookup.java
• Uses InetAddress class to lookup hostnames found on
command line.

> java Lookup cse.unr.edu www.yahoo.com

cse.unr.edu:134.197.40.9
www.yahoo.com:209.131.36.158

Java Socket Programming 27

 try {

InetAddress a = InetAddress.getByName(hostname);

System.out.println(hostname + ":" +
a.getHostAddress());

} catch (UnknownHostException e) {

System.out.println("No address found for " +

hostname);

Java Socket Programming

Socket class
• Corresponds to active TCP sockets only!
• client sockets
• socket returned by accept();

• Passive sockets are supported by a different class:

• ServerSocket

• UDP sockets are supported by

• DatagramSocket

Java Socket Programming 29

JAVA TCP Sockets
• java.net.Socket
• Implements client sockets (also called just “sockets”).
• An endpoint for communication between two machines.
• Constructor and Methods
• Socket(String host, int port): Creates a stream socket and connects it to the specified port number
on the named host.
• InputStream getInputStream()
• OutputStream getOutputStream()
• close()

• java.net.ServerSocket
• Implements server sockets.
• Waits for requests to come in over the network.
• Performs some operation based on the request.
• Constructor and Methods
• ServerSocket(int port)
• Socket Accept(): Listens for a connection to be made to this socket and accepts it. This method
blocks until a connection is made.

Java Socket Programming 30

Sockets

Client socket, welcoming socket (passive) and connection socket (active)

Java Socket Programming 31

Socket Constructors
• Constructor creates a TCP connection to a named TCP
server.
• There are a number of constructors:

Socket(InetAddress server, int port);

Socket(InetAddress server, int port,

InetAddress local, int localport);

Socket(String hostname, int port);

Java Socket Programming 32

Socket Methods
void close();
InetAddress getInetAddress();
InetAddress getLocalAddress();
InputStream getInputStream();
OutputStream getOutputStream();

• Lots more (setting/getting socket options, partial

close, etc.)

Java Socket Programming 33

Socket I/O
• Socket I/O is based on the Java I/O support
• in the package java.io

• InputStream and OutputStream are abstract classes

• common operations defined for all kinds of InputStreams,
OutputStreams…

Java Socket Programming 34

 InputStream Basics
// reads some number of bytes and
// puts in buffer array b
int read(byte[] b);

// reads up to len bytes

int read(byte[] b, int off, int len);

Both methods can throw IOException.

Both return –1 on EOF.

Java Socket Programming 35

OutputStream Basics
// writes b.length bytes
void write(byte[] b);

// writes len bytes starting

// at offset off
void write(byte[] b, int off, int len);

Both methods can throw IOException.

Java Socket Programming 36

ServerSocket Class
(TCP Passive Socket)
• Constructors:

ServerSocket(int port);

ServerSocket(int port, int backlog);

ServerSocket(int port, int backlog,

InetAddress bindAddr);

Java Socket Programming 37

 ServerSocket Methods
Socket accept();

void close();

InetAddress getInetAddress();

int getLocalPort();

throw IOException, SecurityException

Java Socket Programming 38

 Socket programming with TCP
keyboard monitor

Example client-server app:

• client reads line from standard

inFromUser
input
input (inFromUser stream) , stream

sends to server via socket Client

Process Input stream:
(outToServer stream) process sequence of bytes
• server reads line from socket output stream: into process
• server converts line to sequence of bytes
uppercase, sends back to client out of process

inFromServer
outToServer
• client reads, prints modified line output
stream
input
stream
from socket (inFromServer
stream)
client TCP
clientSocket
socket TCP
socket

to network from network

Java Socket Programming 39

Client/server socket interaction: TCP
Server (running on hostid) Client
create socket,
port=x, for
incoming request:
welcomeSocket =
ServerSocket()

TCP create socket,

wait for incoming
connection request connection setup connect to hostid, port=x
connectionSocket = clientSocket =
welcomeSocket.accept() Socket()

send request using

read request from clientSocket
connectionSocket

write reply to
connectionSocket read reply from
clientSocket
close
connectionSocket close
clientSocket
Java Socket Programming 40
 TCPClient.java
import java.io.*;
import java.net.*;

class TCPClient {
public static void main(String argv[]) throws Exception
{
String sentence;
String modifiedSentence;

BufferedReader inFromUser =
new BufferedReader(new InputStreamReader(System.in));

Socket clientSocket = new Socket("hostname", 6789);

DataOutputStream outToServer =
new DataOutputStream(clientSocket.getOutputStream());
TCPClient.java
BufferedReader inFromServer =
new BufferedReader(new
InputStreamReader(clientSocket.getInputStream()));

sentence = inFromUser.readLine();

outToServer.writeBytes(sentence + '\n');

modifiedSentence = inFromServer.readLine();

System.out.println("FROM SERVER: " + modifiedSentence);

clientSocket.close();
}
}
Java Socket Programming 42
 TCPServer.java
import java.io.*;
import java.net.*;
class TCPServer {
public static void main(String argv[]) throws Exception
{
String clientSentence;
String capitalizedSentence;

ServerSocket welcomeSocket = new ServerSocket(6789);

while(true) {

Socket connectionSocket = welcomeSocket.accept();

BufferedReader inFromClient = new BufferedReader(new

InputStreamReader(connectionSocket.getInputStream()));
 TCPServer.java

DataOutputStream outToClient =
new DataOutputStream(connectionSocket.getOutputStream());

clientSentence = inFromClient.readLine();

capitalizedSentence = clientSentence.toUpperCase() + '\n';

outToClient.writeBytes(capitalizedSentence);

}
}
}

Java Socket Programming 44

Sample Echo Server
TCPEchoServer.java

Simple TCP Echo server.

Based on code from:

TCP/IP Sockets in Java

Java Socket Programming 45

UDP Sockets
• DatagramSocket class

• DatagramPacket class needed to specify the payload

• incoming or outgoing

Java Socket Programming 46

Socket Programming with UDP
• UDP
• Connectionless and unreliable service.
• There isn’t an initial handshaking phase.
• Doesn’t have a pipe.
• transmitted data may be received out of order, or lost

• Socket Programming with UDP

• No need for a welcoming socket.
• No streams are attached to the sockets.
• the sending hosts creates “packets” by attaching the IP destination
address and port number to each batch of bytes.
• The receiving process must unravel to received packet to obtain the
packet’s information bytes.

Java Socket Programming 47

JAVA UDP Sockets
• In Package java.net
• java.net.DatagramSocket
• A socket for sending and receiving datagram packets.
• Constructor and Methods
• DatagramSocket(int port): Constructs a datagram socket and binds it to the specified
port on the local host machine.
• void receive( DatagramPacket p)
• void send( DatagramPacket p)
• void close()

Java Socket Programming 48

DatagramSocket Constructors
DatagramSocket();

DatagramSocket(int port);

DatagramSocket(int port, InetAddress a);

All can throw SocketException or SecurityException

Java Socket Programming 49

Datagram Methods
void connect(InetAddress, int port);

void close();

void receive(DatagramPacket p);

void send(DatagramPacket p);

Lots more!

Java Socket Programming 50

Datagram Packet
• Contain the payload
• (a byte array

• Can also be used to specify the destination address

• when not using connected mode UDP

Java Socket Programming 51

DatagramPacket Constructors
For receiving:

DatagramPacket( byte[] buf, int len);

For sending:

DatagramPacket( byte[] buf, int len

InetAddress a, int port);

Java Socket Programming 52

DatagramPacket methods
byte[] getData();
void setData(byte[] buf);

void setAddress(InetAddress a);

void setPort(int port);

InetAddress getAddress();
int getPort();

Java Socket Programming 53

Example: Java client (UDP)
keyboard monitor

inFromUser
input
stream

Client
Process
Input: receives
process
packet (TCP
received “byte
Output: sends
stream”)
packet (TCP sent

receivePacket
sendPacket
“byte stream”) UDP UDP
packet packet

client UDP
clientSocket
socket UDP
socket

to network from network

Java Socket Programming 54

Client/server socket interaction: UDP
Server (running on hostid) Client

create socket, create socket,

port=x, for clientSocket =
incoming request: DatagramSocket()
serverSocket =
DatagramSocket()
Create, address (hostid, port=x,
send datagram request
using clientSocket
read request from
serverSocket

write reply to
serverSocket
specifying client read reply from
host address, clientSocket
port umber close
clientSocket

Java Socket Programming 55

UDPClient.java
import java.io.*;
import java.net.*;
class UDPClient {
public static void main(String args[]) throws Exception
{
BufferedReader inFromUser =
new BufferedReader(new InputStreamReader(System.in));
DatagramSocket clientSocket = new DatagramSocket();
InetAddress IPAddress =
InetAddress.getByName("hostname");
byte[] sendData = new byte[1024];
byte[] receiveData = new byte[1024];
String sentence = inFromUser.readLine();
sendData = sentence.getBytes();
UDPClient.java
DatagramPacket sendPacket =
new DatagramPacket(sendData, sendData.length,
IPAddress, 9876);
clientSocket.send(sendPacket);
DatagramPacket receivePacket =
new DatagramPacket(receiveData, receiveData.length);
clientSocket.receive(receivePacket);
String modifiedSentence =
new String(receivePacket.getData());
System.out.println("FROM SERVER:" + modifiedSentence);

clientSocket.close();
}
}

Java Socket Programming 57

 UDPServer.java
import java.io.*;
import java.net.*;

class UDPServer {
public static void main(String args[]) throws Exception
{
DatagramSocket serverSocket = new
DatagramSocket(9876);
byte[] receiveData = new byte[1024];
byte[] sendData = new byte[1024];
while(true)
{
DatagramPacket receivePacket =
new DatagramPacket(receiveData, receiveData.length);
serverSocket.receive(receivePacket);
String sentence = new String(receivePacket.getData());
 UDPServer.java
InetAddress IPAddress = receivePacket.getAddress();
int port = receivePacket.getPort();
String capitalizedSentence = sentence.toUpperCase();
sendData = capitalizedSentence.getBytes();
DatagramPacket sendPacket =
new DatagramPacket(sendData, sendData.length, IPAddress, port);
serverSocket.send(sendPacket);

}
}
}

Java Socket Programming 59

Sample UDP code
UDPEchoServer.java

Simple UDP Echo server.

Test using nc as the client (netcat):

> nc –u hostname port

Java Socket Programming 60

Socket functional calls
• socket (): Create a socket
• bind(): bind a socket to a local IP address and port #

• listen(): passively waiting for connections

• connect(): initiating connection to another socket
• accept(): accept a new connection

• Write(): write data to a socket

• Read(): read data from a socket
• sendto(): send a datagram to another UDP socket
• recvfrom(): read a datagram from a UDP socket

• close(): close a socket (tear down the connection)

Java Socket Programming 61

Java URL Class
• Represents a Uniform Resource Locator
• scheme (protocol)
• hostname
• port
• path
• query string

Java Socket Programming 62

Parsing
• You can use a URL object as a parser:

URL u = new URL(“http://www.cs.unr.edu/”);

System.out.println(“Proto:” + u.getProtocol());

System.out.println(“File:” + u.getFile());

Java Socket Programming 63

URL construction
• You can also build a URL by setting each part individually:

URL u = new URL(“http”,

www.cs.unr.edu,80,”/~mgunes/”);

System.out.println(“URL:” + u.toExternalForm());

System.out.println(“URL: “ + u);

Java Socket Programming 64

Retrieving URL contents
• URL objects can retrieve the documents they refer to!
• actually this depends on the protocol part of the URL.
• HTTP is supported
• File is supported (“file://c:\foo.html”)
• You can get “Protocol Handlers” for other protocols.

• There are a number of ways to do this:

Object getContent();
InputStream openStream();
URLConnection openConnection();

Java Socket Programming 65

Getting Header Information
• There are methods that return information extracted from
response headers:
String getContentType();
String getContentLength();
long getLastModified();

Java Socket Programming 66

URLConnection
• Represents the connection (not the URL itself).

• More control than URL

• can write to the connection (send POST data).
• can set request headers.

• Closely tied to HTTP

For more detail contact us Java Socket Programming 67

 Broadcasting to Multiple Recipients
In addition to DatagramSocket, which lets programs send packets to
one another, java.net includes a class called MulticastSocket. This
kind of socket is used on the client-side to listen for packets that the
server broadcasts to multiple clients.

Let's rewrite the quote server so that it broadcasts DatagramPackets

to multiple recipients. Instead of sending quotes to a specific client
that makes a request, the new server now needs to broadcast quotes
at a regular interval. The client needs to be modified so that it
passively listens for quotes and does so on a MulticastSocket.

This example is comprised of three classes which are modifications of

the three classes from the previous
example: MulticastServer, MulticastServerThread,
and MulticastClient. This discussion highlights the interesting parts of
these classes.
Here is the new version of the server's main program.
The differences between this code and the previous version, QuoteServer,
are shown in bold:

import java.io.*; public class MulticastServer { public static void main(String[]

args) throws IOException { new MulticastServerThread().start(); } }

Basically, the server got a new name and creates

a MulticastServerThread instead of a QuoteServerThread. Now let's look at
the MulticastServerThread which contains the heart of the server. Here's its
class declaration:

public class MulticastServerThread extends QuoteServerThread { // ... }

The only method explicitly implemented in MulticastServerThread is its run method.
The differences between this run method and the one in QuoteServerThread are
shown in bold:
public void run() {
while (moreQuotes)
{
try {
byte[] buf = new byte[256]; // don't wait for request...just send a quote
String dString = null;
if (in == null) dString = new Date().toString();
else dString = getNextQuote();
buf = dString.getBytes();
InetAddress group = InetAddress.getByName("203.0.113.0");
DatagramPacket packet; packet = new DatagramPacket(buf, buf.length, group,
4446);
socket.send(packet);
try { sleep((long)Math.random() * FIVE_SECONDS); }
catch (InterruptedException e) { } }
catch (IOException e) { e.printStackTrace();
moreQuotes = false; } }
socket.close(); }
The interesting change is how the DatagramPacket is constructed, in
particular, the InetAddress and port used to construct the DatagramPacket.
Recall that the previous example retrieved the InetAddress and port number
from the packet sent to the server from the client. This was because the
server needed to reply directly to the client.

Now, the server needs to address multiple clients. So this time both
the InetAddress and the port number are hard-coded.
The hard-coded port number is 4446 (the client must have
a MulticastSocket bound to this port). The hard-coded InetAddress of
the DatagramPacket is "203.0.113.0" and is a group identifier (rather than the
Internet address of the machine on which a single client is running). This
particular address was arbitrarily chosen from the reserved for this purpose.
To listen to port number 4446, the new client program just created
its MulticastSocket with that port number. To become a member of the "203.0.113.0"
group, the client calls the MulticastSocket's joinGroup method with
the InetAddress that identifies the group. Now, the client is set up to
receive DatagramPackets destined for the port and group specified. Here's the
relevant code from the new client program (which was also rewritten to passively
receive quotes rather than actively request them). The bold statements are the ones
that interact with the MulticastSocket:

MulticastSocket socket = new MulticastSocket(4446);

InetAddress group = InetAddress.getByName("203.0.113.0");
socket.joinGroup(group);
DatagramPacket packet;
for (int i = 0; i < 5; i++)
{ byte[] buf = new byte[256];
packet = new DatagramPacket(buf, buf.length);
socket.receive(packet);
String received = new String(packet.getData());
System.out.println("Quote of the Moment: " + received); } socket.leaveGroup(group);
 Overview of the Java Chat Application
Chat application in Java
It uses TCP socket communication .We have a server as well as a client.Both
can be run in the same machine or different machines.If both are running in the
machine , the adress to be given at the client side is local host address.If both
are running in different machines , then in the client side we need to specify the
ip address of machine in which server application is running.
Let us inspect the server code first.

The ChatSocketServer.java is the server application.It simply creates a

serverSocket on port 3339.Once a new connection comes , it accepts that
connection and Socket object will be created for that connection.Now two
threads will be created .One thread is for reading from the socket and the other
is writing to socket.If the connection is terminated from client side , the server
also exits.
ChatSocketServer.java
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketException;
public class ChatSocketServer {
private ServerSocket severSocket = null;
private Socket socket = null;
private InputStream inStream = null;
private OutputStream outStream = null;
public ChatSocketServer() {
}
public void createSocket() {
try {
ServerSocket serverSocket = new ServerSocket(3339);
while (true) {
socket = serverSocket.accept();
inStream = socket.getInputStream();
outStream = socket.getOutputStream();
System.out.println("Connected");
createReadThread();
createWriteThread();
}
} catch (IOException io) {
io.printStackTrace();
}
}
 //System.arraycopy();
public void createReadThread() {
} catch (SocketException se) {
Thread readThread = new Thread() {
System.exit(0);
public void run() {
} catch (IOException i) {
while (socket.isConnected()) {
i.printStackTrace();
try {
}
byte[] readBuffer = new byte[200];
}
int num = inStream.read(readBuffer);
}
if (num > 0) {
};
byte[] arrayBytes = new byte[num];
readThread.setPriority(Thread.MAX_PRIORITY);
System.arraycopy(readBuffer, 0, arrayBytes, 0, num);
readThread.start();
String recvedMessage = new String(arrayBytes, "UTF-8");
}
System.out.println("Received message :" +
public void createWriteThread() {
recvedMessage);
Thread writeThread = new Thread() {
} else {
public void run() {
notify();
}
;
while (socket.isConnected()) {
try { } catch (IOException i) {
BufferedReader inputReader = new BufferedReader(new i.printStackTrace();
InputStreamReader(System.in)); } catch (InterruptedException ie) {
sleep(100); ie.printStackTrace();
String typedMessage = inputReader.readLine(); }
if (typedMessage != null && typedMessage.length() > 0) { }
synchronized (socket) { }
outStream.write(typedMessage.getBytes("UTF-8")); };
sleep(100); writeThread.setPriority(Thread.MAX_PRIORITY);
} writeThread.start();
}/* else { }
notify(); public static void main(String[] args) {
}*/ ChatSocketServer chatServer = new ChatSocketServ
; chatServer.createSocket();
//System.arraycopy(); }
}
The ChatSocketClient.java simply creates socket connection with the
specified address on port 3339.Once a connection is established, two
threads are creating.One for reading from the socket and other for
writing to socket.Once the server disconnects the connection, the client
exists itself.
ChatSocketClient.java
public void createSocket() {
import java.io.*;
try {
import java.net.Socket;
socket = new Socket("localHost", 3339);
import java.net.SocketException;
System.out.println("Connected");
import java.net.UnknownHostException;
inStream = socket.getInputStream();
outStream = socket.getOutputStream();
public class ChatSocketClient {
createReadThread();
private Socket socket = null;
createWriteThread();
private InputStream inStream = null;
} catch (UnknownHostException u) {
private OutputStream outStream = null;
u.printStackTrace();
} catch (IOException io) {
public ChatSocketClient() {
io.printStackTrace();
}
}
}
 try {
public void createReadThread() { byte[] readBuffer = new byte[200];
Thread readThread = new Thread() { int num = inStream.read(readBuffer);
public void run() { if (num > 0) {
while (socket.isConnected()) { byte[] arrayBytes = new byte[num];
System.arraycopy(readBuffer, 0, arrayBytes, 0, num);
String recvedMessage = new String(arrayBytes, "UTF-8");
System.out.println("Received message :" +
recvedMessage);
}/* else {
// notify();
}*/
;
//System.arraycopy();
}catch (SocketException se){
System.exit(0);
} catch (IOException i) {
i.printStackTrace();
}
}
}
};
readThread.setPriority(Thread.MAX_PRIORITY);
readThread.start();
 try {
BufferedReader inputReader = new BufferedReader(new
public void createWriteThread() { InputStreamReader(System.in));
Thread writeThread = new Thread() { sleep(100);
public void run() { String typedMessage = inputReader.readLine();
while (socket.isConnected()) { if (typedMessage != null && typedMessage.length() > 0) {
synchronized (socket) {
outStream.write(typedMessage.getBytes("UTF-8"));
sleep(100);
}
}
;
//System.arraycopy();
} catch (IOException i) {
i.printStackTrace();
} catch (InterruptedException ie) {
ie.printStackTrace();
}
}
}
};
writeThread.setPriority(Thread.MAX_PRIORITY);
writeThread.start();
}
 Output of ChatSocketServer.java
public static void main(String[] args) throws Exception {
Connected
ChatSocketClient myChatClient = new ChatSocketClient();
myChatClient.createSocket();
Received message :haai
/*myChatClient.createReadThread();
myChatClient.createWriteThread();*/
I am server
}
}
who are u ?
Output
Received message :i am client …How r u ?
Run the ChatSocketServer.java and then the
ChatSocketClient.java.Once both hot connected, connected
Output of ChatSocketClient,java
message will be displayed on the console.Now type messages on
Connected
each console and press enter button.Messages will be transmitted
throgh socket.
haai

Received message :I am server

Received message :who are u ?

i am client …How r u ?