Quick Tour of JAVA

What is Java ?

Java
- Java is not just a programming language but it is a complete
platform for object oriented programming.
What is JRE?

JRE
- The JRE is a collection of software that allows a computer
system to run a Java application. The software collection
consists of the Java Virtual Machines (JVMs) that interpret
Java bytecode into machine code, standard class libraries,
user interface toolkits and a verity of utilities
- Java standard class libraries which provide Application
Programming Interface and JVM together form JRE (Java
Runtime Environment).
What is JDK?

JDK
- The JDK is a programming environment for compiling,
debugging and running Java application, Java Beans, and
Java applet. The JDK includes the JRE with addition of the
Java Programming language and additional development
tool
- JDK (Java development kit) provides all the needed
support for software development in Java.
Java Virtual Machine (JVM)
Runs the Byte Code.
Makes Java platform independent.
Handles Memory Management.
 How Java works?
Java compilers convert your code from human readable to
something called "bytecode" in the Java world.

"Bytecode" is interpreted by a JVM, which operates much

like a physical CPU to actually execute the compiled code.

Just-in-time (JIT) compiler is a program that turns

Java bytecode into instructions that can be sent directly to
the processor.
How Java works ?
Basic Java syntax
Data Types in Java
Data types define the nature of a value
We need different data-types to handle real-world information
Name Size (in bits) Range
long 64 -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807
int 32 2,147,483,648 to 2,147,483,647
Short 16 32,768 to 32,767
byte 8 128 to 127
double 64 4.9e324 to 1.8e+308
float 32 1.4e045 to 3.4e+038
char 16 0 to 65,536
boolean ?? true/false
Naming Convention of Variables
Can start with a letter, an underscore(_), or a dollar sign ($)
Cannot start with a number.
long _LongNumber = 9999999;
String firstName = ' John";
float $Val = 2.3f;
int i, index = 2;
double gamma = 1.2;
boolean value2 = false;
Operators
Provide a way to perform different operations on
variables
Categories of Java Operators
Assignment Operators =
Arithmetic Operators - + * / %
Relational Operators > < >= <= == !=
Logical Operators && || & | ^
Unary Operators + - ++ -- !
Assignment and Arithmetic Operators
Used to assign a value to a variable
Syntax
<variable> = <expression>
Assignment Operator =

Java provides eight Arithmetic operators:

for addition, subtraction, multiplication, division, modulo
(or remainder), increment (or add 1), decrement (or
subtract 1), and negation.
Relational Operators
Used to compare two values.
Binary operators, and their operands are
numeric expressions.
Relational Operators > < >= <= == !=
 Logical Operators
Return a true or false value based on the state
of the variables
There are six logical operators
Conditional AND Conditional OR AND OR NOT Exclusive OR

Logical Operators && || & | ! ^

Static versus Non-static Variables
Static variables are shared across all the objects
of a class
There is only one copy
Non-Static variables are not shared
There is a separate copy for each individual live
object.
Static variables cannot be declared within
a method.
Statements & Blocks

A simple statement is a command terminated by a semi-colon:

name = ' Fred";
A block is a compound statement enclosed in curly brackets:
{
namel = ' Fred"; name2 = ' Bill";
}
Blocks may contain other blocks.
Flow of Control

Java executes one statement after the other in the

order they are written.
Many Java statements are flow control statements:
Alternation:
if, if else, switch
Looping:
for, while, do while
Java Basic Constructs

Ifelse
Switch Statement
For Loop
While Loop
Do...While Loop
If else Syntax

if ( <condition> )
{
// Execute these statements if <condition> is TRUE
}
else
{
// Execute these statements if < condition> is FALSE
}
switch Syntax

switch (expression)
{
case cond1:
block_1;
break;

case cond2:
block_2;
break;
...
default:
block_default;
}
For Syntax

for (initialization; condition; increment/decrement)

{
statement 1;
statement 2; . .
}

Sample:
for( int i=0; i<5; i++ )
{
System.out.println(i);
}
For loop - Working

For(int i=0; i<5; i++){

Statement 1;
Statement 2;
}
While Syntax

while (condition)
{
statement 1;
statement 2; . .
}

Sample:
int i=0;
while (i<5)
{
System.out.println(i);
i++;
}
While Loop - Working

int i=0;
while(i < 5){
Statement 1;
Statement 2;
i++;
}
Do While Syntax

do
{
statement 1;
statement 2; . .
} while (condition) ;

Sample:
int i=0;
do
{
System.out.println(i);
i++;
} while (i<5);
Do While Loop - Working

int i=0;
do{
Statement 1;
Statement 2;
i++;
} while(i < 5)
Arrays

An array is a list of similar things.

An array has a fixed:
name
type
length
These must be declared when the array is created.
Array size cannot be changed during the execution of the
code.
Example of an Array

int array [] = new int[5];

for(int i=0; i<5 ; i++) 5 array[4]

4
{ 3
array[3]

array[2]

array[i] = i+1; 2 array[1]

array[0]
1
}
Java Methods and Classes
Java Philosophy on object oriented programming?
Basic element of object-oriented programming in Java includes classes, Objects,
inheritance and interfaces
Class: Abstractions are one of the fundamental ways in which people handle
complexity. A class models an abstraction by defining the properties and behaviors
for the object represented by the abstraction.
Constructor: The main purpose of constructor is to set the initial state of object
when the object is created using the new operator
Inheritance can be defined as the process where one class acquires the
properties(methods and field) of another class. The class which inherits the
properties of other is known as subclass (child, derived class) and class whose
properties are inherited is known as superclass (base, parent class)
extends keyword is used to inherit the properties of a call
Interface: An interface defines a contract by specifying prototype of method and
not their implementation. Interface having incomplete method should not declared
as abstract as interface is by virtue abstract
An Example class
package com. alabs.entity ; // package

public class Car{ //class declaration

String name;
String color;
float weight;
...
public void move(){ // method

...
}
}
Methods

A method is a named sequence of code that can be

invoked by other Java code.
A method takes some parameters, performs some
computations and then optionally returns a value (or
object).

Ex:
public float convert_to _Celsius( float temp) {
return(((temp * 9.0f) / 5.0f) + 32.0f );
}
Methods

Methods have five components:

Modifiers Value to be
Name of the
Method
returned
The return type
The method name return_type method_name (arg1, arg2, arg3)
{
The parameter list in Body of the
Method

parenthesis Any Number of

} Parameters
The method body,
enclosed between braces
Modifiers

public: any method (in any class) can access the

field.
protected: any method in the same package or any
derived class can access the field.
private: only methods within the class can access the
field.
default is that only methods in the same package
can access the field.
Java Constructors
Constructor

A constructor :
is used in the creation of an object.
is a special method with no return type.
must have the same name as the class it is in.
is used to initialize the object.
if not defined will initialize all instance variables to default value.
Constructor
Constructor
public class Class2 { public class Class1 {

public static void main(String[] args) {

int x;
Class2 ob = new Class2();
int y;
System.out.println("Value of x when
public Class2() { constructor is called: " + ob.x);
x = 10; System.out.println("Value of y when
y = 11; constructor is called: " + ob.y);
} }
}
}
This keyword

this is a keyword used to reference the current

object within an instance method or a
constructor.
Constructor Overloading
public class Class2 {
int x, y; public class Class1 {
public Class2() {
x = 10; public static void main(String[] args)
y = 11; {
}
public Class2(int z) { Class2 ob = new Class2();
x = z; Class2 ob = new Class2(5);
y = z;
}}
}
Java Review (Packages)
What is Package?

A Java package is a mechanism for

organizing Java classes into namespaces
Programmers use packages to organize classes
belonging to the same category
Classes in the same package can access each
other's package-access members
Advantage of a Package

Programmers can easily determine that these

classes are related
Programmers know where to find files of similar
types
The names won't conflict
You can have define access of the types within
the package
Naming Convention of a Package

Package names are written in all lower case

Companies use their reversed Internet
domain name to begin their package names
for example, com.example.mypackage for a package
named mypackage created by a programmer at example.com
Naming Convention of a Package
If the domain name contains -
i. a hyphen or a special character
ii. if the package name begins with a digit, illegal character reserved Java
keyword such as "int
In this event, the suggested convention is to add an underscore
Legalizing Package Names
Domain Name Package Name Prefix
hyphenated-name.example.org org.example.hyphenated_name
example.int int_.example
123name.example.com com.example._123name
Package

Project package com.myproject;

src

com
classes
myproject
com
MyClass.java
myproject

MyClass.class
Inheritance
Inheritance

The child classes inherits all the attributes of the

parent class
They also have their distinctive attributes
Class Animal {
// Type : Not Human
// Lives : On Land
// Gives Birth :
}

Class Aquatic extends Animal {

// Lives : In Water
// Gives Birth :
}
package com.alabs.animal;

public class Animal {

public String Type = "Not Human";

package com.alabs.animal;
public String Lives = "on Land";
public class Aquatic extends Animal{
public void fun(){
String Lives = "In Water";
}
public void fun(){
} System.out.println("defined here");
}
}
package com.alabs.animal;
public class Main {

public static void main(String[] args) {

Aquatic ob = new Aquatic();

System.out.println(ob.Type);
System.out.println(ob.Lives);

ob.fun();
}}
Super keyword

super is a keyword used to refer to the

variable or method or constructor of the
immediate parent class.
Method Overloading
Method Overloading

The overloaded function must differ either by

the number of arguments or operands or
data types.
The same function name is used for various
instances of function call
Method Overloading

package com.alabs.animal;

public class Animal {

public void fun(){

System.out.println("Without
Parameters"); package com.alabs.animal;
} } public class Aquatic extends Animal{
public void fun(int num){
System.out.println ("The number
passed is : " + num);
}
}
Method Overloading
package com.alabs.animal;
public class Main {
public static void main(String[] args) {
Aquatic ob = new Aquatic();
//without Parameters, defined in class Animal
ob.fun();
//with Parameter, overloaded function in class Aquatic
ob.fun(10);
}
}
Method Overriding
Method Overriding

The implementation in the subclass overrides (replaces) the

implementation in the superclass
It is done by providing a method that has same
1. name, same
2. parameters, and same
3. return type as the method in the parent class
Method Overriding

package com.alabs.animal;
public class Animal {
int fun(int a, int b){
int c = a + b;
return c; package com.alabs.animal;
} public class Aquatic extends Animal{
} int fun(int a, int b){
System.out.println {"um by super class: " +
super.fun(a, b));
int c = a * b;
return c;
}
}
Method Overriding
package com.alabs.animal;

public class Main {

public static void main(String[] args) {

Aquatic ob = new Aquatic();

System.out.println{"Product by derived class : "+ ob.fun{2,3));

}
}
Abstract Class
Abstract Class

abstract class Shape

class Circle class Triangle

extends extends
class Rectangle extends Shape
Shape Shape
What is an Abstract Class?

A class that is declared abstract

Ex - abstract class Demo

It may or may not use abstract
methods
What is an Abstract Method ?

A method that is declared abstract

A method that is declared without an

implementation
Ex - abstract void add(int x, int y);
Example
public abstract class Shape {

//Abstract method i.e no implementation

abstract void Area();
}

public class Rectangle extends Shape public class Circle extends Shape {
{ @Override
@Override
void Area() { void Area() {
Double area = length * width; Double area = 3.14 * radius*radius;
}} }}
Interface
Interface

Interfaces are declared using

the interface keyword
Interface can contain :
method signature
(no implementation)
constant declarations
(variable declarations that are declared to be both static and final)
Interface

A class that implements an interface must implement

all of the methods described in the interface
implements

Interface Class
abstract Method1(); abstract Method1();

abstract Method2(); abstract Method2();

abstract Method3(); abstract Method3();

How to create an Interface

public interface Demo_interface {

int add(int value1, int value2);

void print(int sum); Demo_interface

} int add(int value1, intvalue2);

void print(int sum);

How to implement the Interface
public class Class1 implements Demo_interface {
@Override Demo_interface
public int add(int value1, int value2) {
int add(int value1, intvalue2);
int sum = value1 + value2;
void print(int sum);
return sum;
}
@Override
public void print(int sum) { Class1
System.out.println("The sum is : " + sum);
public int add(int value1, int value2);
}
} public void print(int sum);
Using it in the main class
public class Execute {

public static void main(String[] args) {

Class1 ob = new Class1();

Execute
Int sum = ob.add(10, 10); ob

sum = ob.add(10,10);
ob.print(sum);
} ob.print(sum);

}
Input and Output
Input and Output

Input is the data given by the user to the program.

Output is the data what we receive from the program in the
form of result.
Stream represents flow of data i.e. sequence of data.
To give input we use InputStream and to receive output we use
OutputStream.
How input is read from Keyboard?

connected to send data to

System.in InputStream
BufferedReader
Reader

It represents It reads data from It reads data from

keyboard. To read keyboard and InputStreamReader and
data from keyboard send that data to stores data in buffer. It has
it should be got methods so that data
connected to BufferedReader. can be easily accessed.
InputStreamReader
Reading Input from console

Input can be given either from file or keyboard.

Input can be read from console in 3 ways.

BufferedReader
StringTokenizer
Scanner
BufferedReader

BufferedReader bufferedreader = new

BufferedReader(new InputStreamReader(System.in));

int age = bufferedreader.read();

Methods
String name = bufferedreader.readLine();

int read()
String readLine()
StringTokenizer

It can be used to accept multiple inputs from console

in single line where as BufferedReader accepts only
one input from a line.
It uses delimiter(space, comma) to make the
input into tokens.
StringTokenizer

BufferedReader bufferedreader = new BufferedReader(new

InputStreamReader(System.in));
String input = bufferedreader.readLine();

StringTokenizer tokenizer = new StringTokenizer(input, ",");

String name = tokenizer.nextToken();
int age=Integer.parseInt(tokenizer.nextToken()); delimiter
Scanner

It accepts multiple inputs from file or keyboard and divides

into tokens.
It has methods to different types of input( int, float, string,
long, double, byte) where tokenizer does not have.

Scanner scanner = new Scanner(System.in);

int rollno = scanner.nextInt();
String name = scanner.next();
Writing output to console

The output can be written to console in 2 ways:

print(String)-
System.out.print("hello");
write(int)-
int input='i';
System.out.write(input);
System.out.write('/n');
Enums in Java
Enums

Enums helps to relate the variables Select one

with related constants so that it will Sunday
be flexible to work. Monday
Tuesday
Wednesday
We use enum keyword. Thursday
Friday
E.g: enums can be used in dropdown Saturday
boxes.
Why we need to use Enum?
Enum is type-safe i.e any constants can not be
assigned to that variables outside the enum
definition.

Adding new constants will be easy without disturbing

already present code.

You can also assign different constants to variables

other than default values.
How to declare an Enum?

Declaring an enum is similar to class.

Should be declared outside the class in which it has to be used or in an
interface.

variables which will be assigned constant values

enum Colors{
Red, Green, Blue, White, Yellow
}
name of enum 0 1 2 3 4(default constants assigned)
Simple program for Enum
enum Colors_enum{red , green , blue , white , yellow}
public class Main {
public static void main(String args[]) {
Colors_enum colors[]=Colors_enum.values();
for(Colors_enum c:colors)
{
System.out.println(c);
}
}
}
How to assign constants to Enum by user
public class Main {
public static void main(String args[]) {
enum Chocolates{ Chocolates favouritechoco=Chocolates.dairymilk;
dairymilk(20) , switch(favouritechoco)
kitkat(10) , {
munch(5); case dairymilk: System.out.println(Dairy Milk);
int cost; break;
Choloclates(int cost) case kitkat: System.out.println(Kitkat);
break;
{ case munch: System.out.println(Munch);
this.cost=cost; break;
} }
} }
}
Array List
ArrayList class

The ArrayList class is a concrete implementation of

the List interface.
Allows duplicate elements.
A list can grow or shrink dynamically where as
array size is fixed once it is created.
If your application does not require insertion or deletion
of elements, the most efficient data structure is the
array
ArrayList class

Java.util.ArrayList size: 5

elementData
0 1 2 3 4

Ravi Rajiv Megha Sunny Atif

Methods in ArrayList

boolean add(Object e) Iterator iterator()

void add(int index, Object ListIterator listIterator()
element)
boolean addAll(Collection c)
int indexOf()
Object get(int index) int lastIndexOf()
Object set(int index,Object
element) int index(Object element)
int size()
Object remove(int index) void clear()
ArrayList - Insertion
// Create an arraylist ArrayList();
ArrayList arraylist = new

// Adding elements
arraylist.add("Rose");
arraylist.add("Lilly");
arraylist.add("Jasmine");
arraylist.add("Rose");
//removes element at index 2
arraylist.remove(2);
How to trace the elements of ArrayList?

Iterator
ListIterator
For-each loop
Enumeration
Iterator

Iterator is an interface Iterator Methods

that is used to traverse
through the elements
of collection. boolean hasNext()
It traverses only in element next()
forward direction with void remove ()
the help of methods.
Displaying Items using Iterator

Iterator iterator = arraylist.iterator();

while (iterator.hasNext()) {
Object object = iterator.next();
System.out.print(object + " ");
}
ListIterator

ListIterator is an ListIterator Methods

interface that traverses boolean hasNext()

through the elements
element next()
of the collection.
void remove ()
It traverses in both
forward and reverse boolean
direction. hasPrevious()
element previous()
Displaying Items using ListIterator

// To modify objects we use ListIterator

ListIterator listiterator =
arraylist.listIterator();

while (listiterator.hasNext()) {
Object object = listiterator.next();
System.out.print(+ object + );
}
For-each loop

Its action similar to for loop. It traces through all

the elements of array or arraylist.
No need to mention size of Arraylist.
for ( String s : arraylist_name)

Keyword type of data name of arraylist

stored in arraylist
Enumeration

Enumeration is an Enumeration Methods

interface whose action
is similar to iterator. boolean
But the difference is hasMoreElement()
that it have no method element
for deleting an element nextElement()
of arraylist.
Displaying Items using Enumeration

Enumeration enumeration =
Collections.enumeration(arraylist);

while (enumeration.hasMoreElements()) {
Object object = enumeration.nextElement();
System.out.print(object + " ");
}
Hash Maps
HashMap Class
The HashMap is a class which is used to perform operations such
as inserting, deleting, and locating elements in a Map .
The Map is an interface maps keys to the elements.
Maps are unsorted and unordered.
Map allows one null key and multiple null values
HashMap < K, V >

key value associated with key

key act as indexes and can be any objects.
Methods in HashMap
Object put(Object key, Object value)

Enumeration keys()
Enumeration elements()
Object get(Object keys)

boolean containsKey(Object key)

boolean containsValue(Object key)

Object remove(Object key)

int size()
String toString()
HashMap Class
Key Value

0 Ravi
Rajiv
Megha
Sunny
HashMap ..
..
..

Atif
HashMap - Insertion

// Create a hash map

HashMap hashmap = new HashMap();

// Putting elements
hashmap.put("Ankita", 9634.58);
hashmap.put("Vishal", 1283.48);
hashmap.put("Gurinder", 1478.10);
hashmap.put("Krishna", 199.11);
HashMap - Display
// Get an iterator
Iterator iterator = hashmap.entrySet().iterator();

// Display elements
while (iterator.hasNext()) {
Map.Entry entry = (Map.Entry) iterator.next();
System.out.print(entry.getKey() + ": ");
System.out.println(entry.getValue());
}
Hashtable
Hashtable Class

Hashtable is a class which is used to perform

operations such as inserting, deleting, and
locating elements similar to HashMap .
Similar to HashMap it also have key and value.
It does not allow null keys and null values.
The only difference between them is Hashtable
is synchronized where as HashMap is not by
default.
Methods in Hashtable
Object put(Object key, Object value)

Enumeration keys()
Enumeration elements()
Object get(Object keys)

boolean containsKey(Object key)

boolean containsValue(Object key)

Object remove(Object key)

int size()
String toString()
Hashtable - Insertion

// Create a hash table

Hashtable hashtable = new
Hashtable();
// Putting elements
hashtable.put("Ankita", 9634.58);
hashtable.put("Vishal", 1283.48);
hashtable.put("Gurinder", 1478.10);
hashtable.put("Krishna", 199.11);
Hashtable - Display
// Using Enumeration
Enumeration enumeration = hashtable.keys();
// Display elements
while (enumeration.hasMoreElements()) {
String key = enumeration.nextElement().toString();

String value = hashtable.get(key).toString();

System.out.println(key + ":"+value);
}
Exceptions
What is Exception Handling?

Exception is the one that stops the execution

of the program unexpectedly.
The process of handling these exceptions is
called Exception Handling.
Exception Classes

Object
1
Throwable Exception Compile enforced
Exception

2
Error Runtime
Exceptions
Types of Exception

Run-time Exceptions.
Compile Enforced Exception
Run-Time Exceptions

Are also called as Unchecked Exception.

These exceptions are handled at run-time i.e by JVM
after they have occurred by using try and catch
block.
Eg:
ArrayIndexOutOfBoundsException,
ArithmeticException
NullPointerException
Complier-enforced Exceptions

Are also called as Checked Exceptions.

These exceptions are handled by java complier
before they occur by using throws keyword.
Eg: IOException,
FileNotFoundException
Exception Handling Mechanism

Exception can be handled in 3 ways:

try block
Catch block
Finally block
Try and Catch block

try
{
//code where you think exception would occur
}

catch(Exception_Class reference)
{
//Catch the exception and displays that exception
}
Try Catch example

public class Try_Catch {

public static void main(String[] args) {
int y=0;
try {
System.out.println(5/y);
}
catch(Exception e) {
System.out.println(Divide By Zero Exception);
}
}
}
 Multiple Catches
try
{
//statements
When there is a chance }
of getting different
types of exceptions we catch(Exception_Class reference)
{
use multiple catch //statements for one type of exception
block for a try block. }
catch(Exception_Class reference)
{
//statements for other type of exception
}
Multiple- Catch Example
package com.alabs.exception.multiplecatch;
catch(ArrayIndexOutOfBoundsException
class Multiple_Catch {
arrayexception)
int n;
int array[]=new int[3]; {
Multiple_Catch(int n) System.out.println(arrayexception);
{
try{ }
if(n==0)
System.out.println(5/n);
else{
catch(ArithmeticException divideexception)
array[3]=n; System.out.println(array); {
}
} System.out.println(divideexception);
}
}
}
Multiple- Catch Example
package com.alabs.exception.multiplecatch;
class Main {

public static void main(String[] args)

{

Multiple_Catch multiplecatch1= new Multiple_Catch(0);

Multiple_Catch multiplecatch2= new Multiple_Catch(5);

}
}
What is throw keyword?
throw is a keyword which is used to call the sub class of an
exception class.

This keyword is also used to throw the exception occurred in try

block to catch block.

try{
throw new Exception_class(message);
}
catch(Exception_class reference){
//statements
}
 Example using throw keyword
package com.alabs.exception.throwkeyword;
public class Student {

Student(int studentid, String name){ package com.alabs.exception.throwkeyword;

try{ public class Main {

if(studentid==0)
public static void main(String[] args) {
throw new Exception("id can not be zero");
else Student student1 = new Student(0,"STUDENT1");
System.out.println("The id of "+name+" Student student2 = new Student(1,"STUDENT2");
is:"+studentid);
} }
catch (Exception e) {
System.out.println(e); }
}
}
}
What is throws keyword?

throws is a keyword applied to methods for

which an exception has raised during its
execution.

returntype method_name throws Exception_Class

{
// statements
}
 Example using throws keyword

package com.alabs.throwskeyword;
public class GiveInput {
package com.alabs.throwskeyword;
void takeInput() throws IOException public class Main {
{
BufferedReader reader=new public static void main(String[] args) throws
BufferedReader(new IOException {
InputStreamReader(System.in));
GiveInput input=new GiveInput();
System.out.println("Enter your name"); input.takeInput();
String name=reader.readLine();
}
System.out.println("Your name is: "+name); }
}
}
Uses of finally keyword

When we want a set of statements to be executed

even after an exception has occurred then we use
finally block.
finally
{
//statements that needs to be executed after
exception
}
User-defined Exceptions

Across built-in exceptions user can also

define his own exceptions.
It can be done by defining a class that extends
Exception class and creating a constructor of
the class (user-defined) with string argument
to print that message when exception occurs.
Advantages of Exception

The program will still execute even if an exception

arises i.e finally block.
If you can't handle the exception JVM will handle the
exception if we use throws keyword.
We can differentiate the exceptions that have
occurred.
Errors and Error Handling

Design-time error: These are the errors that occur while

designing the programs.
Eg: Syntax errors

These errors will be shown with a red mark in eclipse IDE so

that you can easily find and correct it.
Errors and Error Handling

Logical error: These are the errors done by programmer. The

programs with these errors will run but does not produce
desired results.
Eg: getting division of two numbers as output but expected is
multiplication of numbers.

These errors can be rectified by understanding the logic and

checking whether it is works out correctly or not.
Thanks..!