History of Java

Java was originally designed for interactive television, but it was too advanced technology for
the digital cable television industry at the time. The history of Java starts with the Green Team.
Java team members (also known as Green Team), initiated this project to develop a language for
digital devices such as set-top boxes, televisions, etc. However, it was best suited for internet
programming. Later, Java technology was incorporated by Netscape.

The principles for creating Java programming were "Simple, Robust, Portable, Platform-
independent, Secured, High Performance, Multithreaded, Architecture Neutral, Object-Oriented,
Interpreted, and Dynamic". Java was developed by James Gosling, who is known as the father of
Java, in 1995. James Gosling and his team members started the project in the early '90s.

Currently, Java is used in internet programming, mobile devices, games, e-business solutions, etc.
Following are given significant points that describe the history of Java.

1) James Gosling, Mike Sheridan, and Patrick Naughton initiated the Java language project in
June 1991. The small team of sun engineers called Green Team.

2) Initially it was designed for small, embedded systems in electronic appliances like set-top
boxes.

3) Firstly, it was called "Greentalk" by James Gosling, and the file extension was .gt.

4) After that, it was called Oak and was developed as a part of the Green project.
Why Java was named as "Oak"?

5) Why Oak? Oak is a symbol of strength and chosen as a national tree of many countries like the
U.S.A., France, Germany, Romania, etc.

6) In 1995, Oak was renamed as "Java" because it was already a trademark by Oak Technologies.

Why Java Programming named "Java"?

7) Why had they chose the name Java for Java language? The team gathered to choose a new name.
The suggested words were "dynamic", "revolutionary", "Silk", "jolt", "DNA", etc. They wanted
something that reflected the essence of the technology: revolutionary, dynamic, lively, cool,
unique, and easy to spell, and fun to say.

According to James Gosling, "Java was one of the top choices along with Silk". Since Java was so
unique, most of the team members preferred Java than other names.

8) Java is an island in Indonesia where the first coffee was produced (called Java coffee). It is a
kind of espresso bean. Java name was chosen by James Gosling while having a cup of coffee
nearby his office.

Java Version History

Many java versions have been released till now. The current stable release of Java is Java SE 10.

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 Mar 2014)
11. Java SE 9 (21st Sep 2017)
12. Java SE 10 (20th Mar 2018)
13. Java SE 11 (September 2018)
14. Java SE 12 (March 2019)
15. Java SE 13 (September 2019)
16. Java SE 14 (Mar 2020)
17. Java SE 15 (September 2020)
18. Java SE 16 (Mar 2021)
19. Java SE 17 (September 2021)
20. Java SE 18 (Released in March 2022)

Since Java SE 8 release, the Oracle corporation follows a pattern in which every even version is
release in March month and an odd version released in September month.
 OBJECT-ORIENTED PROGRAMMING
Object-oriented programming (OOP) is a programming paradigm based on the concept of
“objects”, which may contain data, in the form of fields, often known as attributes; and code,
in the form of procedures, often known as methods.
List of object-oriented programming languages

Ada 95 Fortran 2003 PHP since v4, greatly enhanced in v5

BETA Graphtalk Python

C++ IDLscript Ruby

C# J# Scala

COBOL Java Simula

Cobra LISP Smalltalk

ColdFusion Objective-C Tcl

Common Lisp Perl since v5

Abstraction
Abstraction is one of the key concepts of object-oriented programming (OOP) languages.
Its main goal is to handle complexity by hiding unnecessary details from the user. This en-
ables the user to implement more complex logic on top of the provided abstraction without
understanding about all the hidden complexity.
For example, people do not think of a car as a set of tens of thousands of individual parts.
They think of it as a well-defined object with its own unique behavior. This abstraction allows
people to use a car to drive to the desired location without worrying about the complexity of
the parts that form the car. They can ignore the details of how the engine, transmission, and
braking systems work. Instead, they are free to utilize the object as a whole.

A powerful way to manage abstraction is through the use of hierarchical classifications.

This allows us to layer the semantics of complex systems, breaking them into more manage-
able pieces.
• Hierarchical abstractions of complex systems can also be applied to computer
programs.
• The data from a traditional process-oriented program can be transformed by abstraction
into its component objects.
• A sequence of process steps can become a collection of messages between these
objects.
• Thus, each of these objects describes its own unique behavior.
• We can treat these objects as concrete entities that respond to messages telling them
to do something.
Objects And Classes
Object
Objects have states and behaviors. Example: A dog has states - color, name, breed as well
as behaviors – wagging the tail, barking, eating. An object is an instance of a class.
Class
A class can be defined as a template/blueprint that describes the behavior/state that the
object of its type support.
Objects in Java
If we consider the real-world, we can find many objects around us, cars, dogs, humans,
etc. All these objects have a state and a behavior.
If we consider a dog, then its state is - name, breed, color, and the behavior is - barking,
wagging the tail, running.
If we compare the software object with a real-world object, they have very similar char-
acteristics.
Software objects also have a state and a behavior. A software object’s state is stored in
fields and behavior is shown via methods.
So in software development, methods operate on the internal state of an object and the
object-to-object communication is done via methods.
Classes in Java
A class is a blueprint from which individual objects are created.

Following is an example of a class.

public class Dog {
String breed;
int age;
String color;
void barking()
{
}
}
A class can contain any of the following variable types.
• Local variables − Variables defined inside methods, constructors or blocks are called
local variables. The variable will be declared and initialized within the method and
the variable will be destroyed when the method has completed.
• Instance variables − Instance variables are variables within a class but outside
any method. These variables are initialized when the class is instantiated. Instance
variables can be accessed from inside any method, constructor or blocks of that
particular class.
• Class variables − Class variables are variables declared within a class, outside any
method, with the static keyword.
A class can have any number of methods to access the value of various kinds of methods.
In the above example, barking(), hungry() and sleeping() are methods.
Encapsulation
Encapsulation is the mechanism that binds together code and the data it manipulates, and
keeps both safe from outside interference and misuse.
• In Java, the basis of encapsulation is the class. There are mechanisms for hiding the
complexity of the implementation inside the class.
• Each method or variable in a class may be marked private or public.
• The public interface of a class represents everything that external users of the class
need to know, or may know.
• The private methods and data can only be accessed by code that is a member of the
class.
• Therefore, any other code that is not a member of the class cannot access a private
method or variable.
• Since the private members of a class may only be accessed by other parts of program
through the class’ public methods, we can ensure that no improper actions take
place.
Inheritance
Inheritance is the process by which one object acquires the properties of another object.

For example, a Dog is part of the classification Mammal, which in turn is part of the Ani-
mal class. Without the use of hierarchies, each object would need to define all of its charac-
teristics explicitly. However, by use of inheritance, an object need only define those qualities
that make it unique within its class. It can inherit its general attributes from its parent. Thus,
inheritance makes it possible for one object to be a specific instance of a more general case.
Polymorphism
Polymorphism (from Greek, meaning “many forms”) is a feature that allows one interface
to be used for a general class of actions. The specific action is determined by the exact nature
of the situation.
For eg, a dog’s sense of smell is polymorphic. If the dog smells a cat, it will bark and run
after it. If the dog smells its food, it will salivate and run to its bowl. The same sense of smell
is at work in both situations. The difference is what is being smelled, that is, the type of data
being operated upon by the dog’s nose.
Consider a stack (which is a last-in, first-out LIFO list). We might have a program that re-
quires three types of stacks. One stack is used for integer values, one for floating-point values,
and one for characters. The algorithm that implements each stack is the same, even though
the data being stored differs.
 CHARACTERISTICS OF JAVA
Simple :
• Java is Easy to write and more readable.
• Java has a concise, cohesive set of features that makes it easy to learn and use.
• Most of the concepts are drawn from C++, thus making Java learning simpler.
Secure :
• Java program cannot harm other system thus making it secure.
• Java provides a secure means of creating Internet applications.
• Java provides secure way to access web applications.
Portable :
• Java programs can execute in any environment for which there is a Java run-time
system.
• Java programs can run on any platform (Linux, Window, Mac)
• Java programs can be transferred over world wide web (e.g applets)
Object-oriented :
• Java programming is object-oriented programming language.
• Like C++, java provides most of the object oriented features.
• Java is pure OOP Language. (while C++ is semi object oriented)
Robust :
• Java encourages error-free programming by being strictly typed and performing run-
time checks.
Multithreaded :
• Java provides integrated support for multithreaded programming.
Architecture-neutral :
• Java is not tied to a specific machine or operating system architecture.
• Java is machine independent.
Interpreted :
• Java supports cross-platform code through the use of Java bytecode.
• Bytecode can be interpreted on any platform by JVM (Java Virtual Machine).
High performance :
• Bytecodes are highly optimized.
• JVM can execute bytecodes much faster .
Distributed :
• Java is designed with the distributed environment.
• Java can be transmitted over internet.
Dynamic :
• Java programs carry substantial amounts of run-time type information with them that
is used to verify and resolve accesses to objects at run time.
 JAVA RUNTIME ENVIRONMENT (JRE)
The Java Runtime Environment (JRE) is a set of software tools for development of Java
applications. It combines the Java Virtual Machine (JVM), platform core classes and support-
ing libraries.
JRE is part of the Java Development Kit (JDK), but can be downloaded separately. JRE
was originally developed by Sun Microsystems Inc., a wholly-owned subsidiary of Oracle
Corporation.
JRE consists of the following components:
Name of the component Elements of the component
Deployment technologies Deployment
Java Web Start
Java Plug-in
User interface toolkits Abstract Window Toolkit (AWT)
Swing
Java 2D
Accessibility
Image I/O
Print Service
Sound
Drag and Drop (DnD)
Input methods.
Integration libraries Interface Definition Language (IDL)
Java Database Connectivity (JDBC)
Java Naming and Directory Interface (JNDI)
Remote Method Invocation (RMI)
Remote Method Invocation Over Internet
Inter-Orb Protocol (RMI-IIOP)
Scripting.
base libraries International support
Input/Output (I/O)
Eextension mechanism
Beans
Java Management Extensions (JMX)
Java Native Interface (JNI)
Math
Networking
Override Mechanism
Security
Serialization and Java for XML Processing
(XML JAXP).
Lang and util base libraries lang and util
Management
Versioning
Zip
Instrument
Reflection
Collections
Concurrency
Java Archive (JAR)
Logging
Preferences API
Ref Objects
Regular Expressions.
Java Virtual Machine (JVM) Java HotSpot Client
Server Virtual Machines
 JAVA VIRTUAL MACHINE (JVM)
The JVM is a program that provides the runtime environment necessary for Java pro-
grams to execute. Java programs cannot run without JVM for the appropriate hardware and
OS platform.
Java programs are started by a command line, such as:
java <arguments> <program name>
This brings up the JVM as an operating system process that provides the Java runtime
environment. Then the program is executed in the context of an empty virtual machine.
When the JVM takes in a Java program for execution, the program is not provided as
Java language source code. Instead, the Java language source must have been converted (or
compiled) into a form known as Java bytecode. Java bytecode must be supplied to the JVM
in a format called class files. These class files always have a .class extension.
The JVM is an interpreter for the bytecode form of the program. It steps through one
bytecode instruction at a time. It is an abstract computing machine that enables a computer
to run a Java program.

SETTING UP AN ENVIRONMENT FOR JAVA

Local Environment Setup
Download Java and run the .exe to install Java on the machine.
Setting Up the Path for Windows
Assuming Java is installed in c:\Program Files\java\jdk directory −
• Right-click on ‘My Computer’ and select ‘Properties’.
• Click the ‘Environment variables’ button under the ‘Advanced’ tab.
• Now, alter the ‘Path’ variable so that it also contains the path to the Java executable.
Example, if the path is currently set to ‘C:\WINDOWS\SYSTEM32’, then change
your path to read ‘C:\WINDOWS\SYSTEM32;c:\Program Files\java\jdk\bin’.

POPULAR JAVA EDITORS

To write Java programs, we need any of the following:
• Notepad − Text editor
• Netbeans − A Java IDE that is open-source and free
• Eclipse − A Java IDE developed by the eclipse open-source community
 OOP CONCEPTS IN JAVA
OOP concepts in Java are the main ideas behind Java’s Object Oriented Programming.
They are:
Object
Any entity that has state and behavior is known as an object. It can be either physical or
logical.
For example: chair, pen, table, keyboard, bike etc.
Class & Instance
A class is a blueprint from which individual objects are created.
A Class is a 3-Compartment box encapsulating data and operations as shown in figure.

Class Name

Static Attributes

Dynamic Behaviors

Figure: Class Structure

The followings figure shows two classes ‘Student’ and ‘Circle’.
Name (Identifier) Student Circle
Variables (Static Attributes) name, gender, dept, marks radius, color
Methods getDetails() getRadius()
(Dynamic Behaviors) calculateGrade() printArea()
Figure: Examples of classes
A class can be visualized as a three-compartment box, as illustrated:
1. Name (or identity): identifies the class.
2. Variables (or attribute, state, field): contain the static attributes of the class.
3. Methods (or behaviors, function, operation): contain the dynamic behaviors of the
class.
An instance is an instantiation of a class. All the instances of a class have similar proper-
ties, as described in the class definition. The term “object” usually refers to instance.
For example, we can define a class called “Student” and create three instances of the class
“Student” for “John”, “Priya” and “Anil”.
The following figure shows three instances of the class Student, identified as “John”,
“Priya” and “Anil”.

John : Student Priya : Student Anil : Student

name = “John” name = “Priya” name = “Anil”
gender = “male” gender = “female” gender = “male”
 dept = “CSE” gender = “female” gender = “male”
mark = 88 dept = “IT” dept = “IT”
getDetails() getDetails() getDetails()
calculateGrade() calculateGrade() calculateGrade()

Abstraction

Abstraction refers to the quality of dealing with ideas rather than events. It basically deals
with hiding the details and showing the essential things to the user.
We all know how to turn the TV on, but we don’t need to know how it works in order to
enjoy it.
Abstraction means simple things like objects, classes, and variables represent more com-
plex underlying code and data. It avoids repeating the same work multiple times. In java, we
use abstract class and interface to achieve abstraction.
Abstract class:
Abstract class in Java contains the ‘abstract’ keyword. If a class is declared abstract, it
cannot be instantiated. So we cannot create an object of an abstract class. Also, an abstract
class can contain abstract as well as concrete methods.
To use an abstract class, we have to inherit it from another class where we have to provide
implementations for the abstract methods there itself, else it will also become an abstract
class.
Interface:
Interface in Java is a collection of abstract methods and static constants. In an interface,
each method is public and abstract but it does not contain any constructor. Along with ab-
straction, interface also helps to achieve multiple inheritance in Java.
So an interface is a group of related methods with empty bodies.
Encapsulation
Binding (or wrapping) code and data together into a single unit is known as encapsulation.
It means to hide our data in order to make it safe from any modification.
The best way to understand encapsulation is to look at the example of a medical capsule,
where the drug is always safe inside the capsule. Similarly, through encapsulation the meth-
ods and variables of a class are well hidden and safe.
A java class is the example of encapsulation.
Encapsulation can be achieved in Java by:
• Declaring the variables of a class as private.
• Providing public setter and getter methods to modify and view the variables values.
Inheritance
This is a special feature of Object Oriented Programming in Java. It lets programmers
create new classes that share some of the attributes of existing classes.
For eg, a child inherits the properties from his father.
Similarly, in Java, there are two classes:
1. Parent class (Super or Base class)
 2. Child class (Subclass or Derived class)
A class which inherits the properties is known as ‘Child class’ whereas a class whose
properties are inherited is known as ‘Parent class’.
Inheritance is classified into 4 types:

Single Inheritance
It enables a derived class to inherit the properties and behavior from a single parent
class.

Here, Class A is a parent class and Class B is a child class which inherits the properties
and behavior of the parent class.
Multilevel Inheritance
When a class is derived from a class which is also derived from another class, i.e. a class
having more than one parent class but at different levels, such type of inheritance is called
Multilevel Inheritance.

Here, class B inherits the properties and behavior of class A and class C inherits the prop-
erties of class B. Class A is the parent class for B and class B is the parent class for C. So, class
C implicitly inherits the properties and methods of class A along with Class B.
Hierarchical Inheritance
When a class has more than one child class (sub class), then such kind of inheritance is known
as hierarchical inheritance.
 Here, classes B and C are the child classes which are inheriting from the parent class A.

Hybrid Inheritance
Hybrid inheritance is a combination of multiple inheritance and multilevel inheritance.
Since multiple inheritance is not supported in Java as it leads to ambiguity, this type of inheri-
tance can only be achieved through the use of the interfaces.

Here, class A is a parent class for classes B and C, whereas classes B and C are the parent
classes of D which is the only child class of B and C.
Polymorphism
Polymorphism means taking many forms, where ‘poly’ means many and ‘morph’ means
forms. It is the ability of a variable, function or object to take on multiple forms. In other
words, polymorphism allows us to define one interface or method and have multiple imple-
mentations.

For eg, Bank is a base class that provides a method rate of interest. But, rate of interest
may differ according to banks. For example, SBI, ICICI and AXIS are the child classes that
provide different rates of interest.
Polymorphism in Java is of two types:
• Run time polymorphism
• Compile time polymorphism
Run time polymorphism:
In Java, runtime polymorphism refers to a process in which a call to an overridden method
is resolved at runtime rather than at compile-time. Method overriding is an example of run
time polymorphism.

Compile time polymorphism:

In Java, compile time polymorphism refers to a process in which a call to an overloaded
method is resolved at compile time rather than at run time. Method overloading is an example
of compile time polymorphism.
 JAVA SOURCE FILE STRUCTURE
When we write a Java source program, it needs to follow a certain structure or template
as shown in the following figure:

Figure: Java Source File Structure

Packages are used in Java in order to prevent naming conflicts, to control access, to make
searching/locating and usage of classes, interfaces, enumerations and annotations easier, etc.
A Java source file can have the following elements that must be specified in the following
order:
1. An optional package declaration to specify a package name.
2. Zero or more import declarations.
3. Any number of top-level type declarations. Class, enum, and interface declarations
are collectively known as type declarations.
Part 1: Optional Package Declaration
A package is a pack (group) of classes, interfaces and other packages. Packages are used
in Java in order to prevent naming conflicts, to control access, to make searching / locating
and usage of classes, interfaces, enumerations and annotations easier, etc.

Rules:
The package statement should be the first line in the source file.
•
There can be only one package statement in each source file.
•
If a package statement is not used, the class, interfaces, enumerations, and annotation
• types will be placed in the current default package.
It is a good practice to use names of packages with lower case letters to avoid any
• conflicts with the names of classes and interfaces.
Following package example contains interface named animals:

/* File name : [Link] */

package animals;
interface Animal
{
public void eat();
public void travel();
}

Part 2: Zero or More import Declarations

The import statement makes the declarations of external classes available to the current
Java source program at the time of compilation. The import statement specifies the path for
the compiler to find the specified class.
Syntax of the import statement:

import packagename;

or
import packagename.* ;
We may import a single class or all the classes belonging to a package.
• To import a single class, we specify the name of the class
• To import all classes, we specify *.
Examples of the import statement:
Statement in Java Purpose
import [Link]; imports the definition of the MyClass
class that is defined in the mypackage
package.
import [Link]. imports the definition of EmpClass
EmpClass; belonging to the [Link].
[Link] package.
import [Link].*; imports all the classes belonging to the
[Link] package.
Part 3: Zero or More top-level Declarations
The Java source file should have one and only one public class. The class name which is
defined as public should be the name of Java source file along with .java extension.
Source File Declaration Rules
• There can be only one public class per source file.
• A source file can have multiple non-public classes.
• The public class name should be the name of the source file which should have
.java extension at the end.
 • For eg, if the class name is public class Employee{}, then the source file should be
as [Link].
• If the class is defined inside a package, then the package statement should be the first
statement in the source file.
• If import statements are present, then they must be written between the package
statement and the class declaration. If there are no package statements, then the
import statement should be the first line in the source file.
• Import and package statements will imply to all the classes present in the source file.
It is not possible to declare different import and/or package statements to different
classes in the source file.

COMPILATION
In Java, programs are not compiled into executable files. Java source code is compiled
into bytecode using javac compiler. The bytecodes are platform-independent instructions for
the Java VM. They are saved on the disk with the file extension .class. When the program
is to be run, the bytecode is converted into the machine code using the just-in-time (JIT) com-
piler. It is then fed to the memory and executed.
Java code needs to be compiled twice in order to be executed:
1. Java programs need to be compiled to bytecode.
2. When the bytecode is run, it needs to be converted to machine code.
The Java classes / bytecode are compiled to machine code and loaded into memory by the
JVM when needed for the first time.
Compiling the Program
The Java compiler is invoked at the command line with the following syntax:

javac [Link]
Interpreting and Running the Program
Once the java program successfully compiles into Java bytecodes, we can interpret and
run applications on any Java VM, or interpret and run applets in any Web browser with a Java
VM built in such as Netscape or Internet Explorer. Interpreting and running a Java program
means invoking the Java VM byte code interpreter, which converts the Java byte codes to
platform-dependent machine codes so your computer can understand and run the program.
The Java interpreter is invoked at the command line with the following syntax:

java ExampleProgram
Quick compilation procedure
To execute the first Java program, follow the steps:
1. Open text editor. For example, Notepad or Notepad++ on Windows; Gedit, Kate or
SciTE on Linux; or, XCode on Mac OS, etc.
2. Type the java program in a new text document.
3. Save the file as [Link].
4. Next, open any command-line application. For example, Command Prompt on
Windows; and, Terminal on Linux and Mac OS.
5. Compile the Java source file using the command: javac [Link]
6. Once the compiler returns to the prompt, run the application using the following
command:
java HelloWorld
 FUNDAMENTAL PROGRAMMING STRUCTURES IN JAVA

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
1) Java Single Line Comment
The single line comment is used to comment only one line. A single-line comment begins
with a // and ends at the end of the line.
Syntax Example
//Comment //This is single line comment
2) Java Multi Line Comment
This type of comment must begin with /* and end with */. Anything between these two
comment symbols is ignored by the compiler. A multiline comment may be several lines
long.
Syntax Example
/*Comment starts /* This is a

continues multi line

continues comment */

Commnent ends*/

3) Java Documentation Comment

This type of comment is used to produce an HTML file that documents our program. The
documentation comment begins with a /** and ends with a */.
 Syntax Example
/**Comment start /**

* This

*tags are used in order to specify a parameter is

*or method or heading documentation

*HTML tags can also be used comment

*such as <h1> */

*comment ends*/

DATA TYPES
Java is a statically typed and also a strongly typed language. In Java, each type of data
(such as integer, character, hexadecimal, etc. ) is predefined as part of the programming lan-
guage and all constants or variables defined within a given program must be described with
one of the data types.
Data types represent the different values to be stored in the variable. In java, there are two
categories of data types:
o Primitive data types
o Non-primitive data types

Figure: Data types in java

The Primitive Types
Java defines eight primitive types of data: byte, short, int, long, char, float, double, and
boolean. The primitive types are also commonly referred to as simple types and they are
grouped into the following four groups:
i) Integers - This group includes byte, short, int, and long. All of these are signed,
positive and negative values. The width and ranges of these integer types vary widely,
as shown in the following table:
Name Width 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
Table: Integer Data Types
ii) Floating-point numbers – They are also known as real numbers. This group includes
float and double, which represent single- and double-precision numbers, respectively.
The width and ranges of them are shown in the following table:
Table: Floating-point Data Types

Name Width in bits Range

double 64 4.9e–324 to 1.8e+308
float 32 1.4e–045 to 3.4e+038
iii) Characters - This group includes char, which represents symbols in a character set,
like letters and numbers. char is a 16-bit type. The range of a char is 0 to 65,536.
There are no negative chars.
iv) Boolean - This group includes boolean. It can have only one of two possible values,
true or false.

VARIABLES
A variable is the holder that can hold the value while the java program is executed. A
variable is assigned with a datatype. It is name of reserved area allocated in memory. In
other words, it is a name of memory location. There are three types of variables in java: local,
instance and static.
A variable provides us with named storage that our programs can manipulate. Each vari-
able in Java has a specific type, which determines the size and layout of the variable’s mem-
ory; the range of values that can be stored within that memory; and the set of operations that
can be applied to the variable.

Before using any variable, it must be declared. The following statement expresses the
basic form of a variable declaration –
datatype variable [ = value][, variable [ = value] ...] ;
Here data type is one of Java’s data types and variable is the name of the variable. To de-
clare more than one variable of the specified type, use a comma-separated list.
Example
int a, b, c; // Declaration of variables a, b, and c.
int a = 20, b = 30; // initialization
byte B = 22; // Declaratrion initializes a byte type variable B.
Types of Variable
There are three types of variables in java:
• local variable
• instance variable
• static variable

Fig. Types of variables

Local Variable
• Local variables are declared inside the methods, constructors, or blocks.
• Local variables are created when the method, constructor or block is entered
• Local variable will be destroyed once it exits the method, constructor, or block.
• Local variables are visible only within the declared method, constructor, or block.
• Local variables are implemented at stack level internally.
• There is no default value for local variables, so local variables should be declared and
an initial value should be assigned before the first use.
• Access specifiers cannot be used for local variables.
Instance Variable
• A variable declared inside the class but outside the method, is called instance variable.
Instance variables are declared in a class, but outside a method, constructor or any
block.
• A slot for each instance variable value is created when a space is allocated for an
object in the heap.
• Instance variables are created when an object is created with the use of the keyword
‘new’ and destroyed when the object is destroyed.
• Instance variables hold values that must be referenced by more than one method,
constructor or block, or essential parts of an object’s state that must be present
throughout the class.
• Instance variables can be declared in class level before or after use.
• Access modifiers can be given for instance variables.
• The instance variables are visible for all methods, constructors and block in the
class. It is recommended to make these variables as private. However, visibility for
subclasses can be given for these variables with the use of access modifiers.
• Instance variables have default values.
○ numbers, the default value is 0,
○ Booleans it is false,
○ Object references it is null.
• Values can be assigned during the declaration or within the constructor.
• Instance variables cannot be declared as static.
• Instance variables can be accessed directly by calling the variable name inside the class.
However, within static methods (when instance variables are given accessibility), they
should be called using the fully qualified name. [Link].

Static variable
• Class variables also known as static variables are declared with the static keyword in
a class, but outside a method, constructor or a block.
• Only one copy of each class variable per class is created, regardless of how many
objects are created from it.
• Static variables are rarely used other than being declared as constants. Constants are
variables that are declared as public/private, final, and static. Constant variables never
change from their initial value.
• Static variables are stored in the static memory. It is rare to use static variables other
than declared final and used as either public or private constants.
• Static variables are created when the program starts and destroyed when the program
stops.
• Visibility is same as instance variables. However, most static variables are declared
public since they must be available for users of the class.
• Default values are same as instance variables.
○ numbers, the default value is 0;
○ Booleans, it is false;
○ Object references, it is null.
• Values can be assigned during the declaration or within the constructor. Additionally,
values can be assigned in special static initializer blocks.
• Static variables cannot be local.
• Static variables can be accessed by calling with the class name ClassName.
VariableName.
• When declaring class variables as public static final, then variable names (constants)
are all in upper case. If the static variables are not public and final, the naming syntax
is the same as instance and local variables.
 DEFINING CLASSES IN JAVA
A class is an entity that determines how an object will behave and what the object will
contain. A class is the basic building block of an object-oriented language such as Java. It
is acting as a template that describes the data and behavior associated with instances of that
class.
When you instantiate a class means creating an object. The class contains set of variables
and methods.
The data associated with a class or object is stored in variables; the behavior associated
with a class or object is implemented with methods. A class is a blueprint from which indi-
vidual objects are created.
class MyClass {
// field,
//constructor, and
// method declarations
}
Example:
class Myclass{
public static void main(String[] args)
{
[Link](“Hello World!”); //Display the string.
}
}
The keyword class begins the class definition for a class named name. The variables and
methods of the class are embraced by the curly brackets that begin and end the class definition
block. The “Hello World” application has no variables and has a single method named main.
In Java, the simplest form of a class definition is
class name {
...
}
In general, class declarations can include these components, in order:
1. Modifiers : A class can be public or has default access.
2. Class name: The name should begin with a initial letter.
3. Superclass(if any): The name of the class’s parent (superclass), if any, preceded by
the keyword extends. A class can only extend (subclass) one parent.
4. Interfaces(if any): A comma-separated list of interfaces implemented by the class,
if any, preceded by the keyword implements. A class can implement more than one
interface.
5. Body: The class body surrounded by braces, { }.
 CONSTRUCTORS
Every class has a constructor. If the constructor is not defined in the class, the Java com-
piler builds a default constructor for that class. While a new object is created, at least one
constructor will be invoked. The main rule of constructors is that they should have the same
name as the class. A class can have more than one constructor.
Constructors are used for initializing new objects. Fields are variables that provide the
state of the class and its objects, and methods are used to implement the behavior of the class
and its objects.
Rules for writing Constructor
• Constructor(s) of a class must have same name as the class name in which it resides.
• A constructor in Java cannot be abstract, final, static and synchronized.
• Access modifiers can be used in constructor declaration to control its access i.e which
other class can call the constructor.
Following is an example of a constructor −
Example
public class myclass {
public myclass() { // Constructor
}
public myclass(String name) {
// This constructor has one parameter, name.
}
}
Types of Constructors
There are two type of constructor in Java:
1. No-argument constructor:
A constructor that has no parameter is known as default constructor.
If the constructor is not defined in a class, then compiler creates default con-
structor (with no arguments) for the class. If we write a constructor with ar-
guments or no-argument then compiler does not create default constructor.
Default constructor provides the default values to the object like 0, null etc. depending on the
type.
// Java Program to illustrate calling a no-argument constructor
import [Link].*;
class myclass
{
int num;
String name;
// this would be invoked while object of that class created.
myclass()
{
 [Link](“Constructor called”);
}
}
class myclassmain
{
public static void main (String[] args)
{
// this would invoke default constructor.
myclass m1 = new myclass();
// Default constructor provides the default values to the object like 0, null
[Link]([Link]);
[Link]([Link]);
}
}
2. Parameterized Constructor
A constructor that has parameters is known as parameterized constructor. If we want to
initialize fields of the class with your own values, then use parameterized constructor.

// Java Program to illustrate calling of parameterized constructor.

import [Link].*;
class myclass
{
// data members of the class.
String name;
int num;
// contructor with arguments.
myclass(String name, int n)
{
[Link] = name;
[Link] = n;
}
}
class myclassmain{
public static void main (String[] args)
{
// this would invoke parameterized constructor.
myclass m1 = new myclass(“Java”, 2017);
[Link](“Name :” + [Link] + “ num :” + [Link]);
}
}
 OPERATORS
Operator in java is a symbol that is used to perform operations. Java provides a rich set
of operators to manipulate [Link] example: +, -, *, / etc.
All the Java operators can be divided into the following groups −
• Arithmetic Operators :
Multiplicative : * / %
Additive :+ -
• Relational Operators
Comparison : < > <= >= instanceof
Equality : == !=
• Bitwise Operators
bitwise AND : &
bitwise exclusive OR : ^
bitwise inclusive OR : |
Shift operator: << >> >>>
• Logical Operators
logical AND : &&
logical OR : ||
logical NOT : ~ !
• Assignment Operators: =
• Ternary operator: ? :
• Unary operator
Postfix : expr++ expr—
Prefix : ++expr --expr +expr -expr
The Arithmetic Operators
Arithmetic operators are used to perform arithmetic operations in the same way as they
are used in algebra. The following table lists the arithmetic operators −
Example:
int A=10,B=20;

Operator Description Example Output

+ (Addition) Adds values A & B. A+B 30
- (Subtraction) Subtracts B from A A-B -10
* (Multiplication) Multiplies values A & B A*B 200
 / (Division) Divides B by A B /A 2
Divides left-hand operand by right-
% (Modulus) B %A 0
hand operand and returns remainder.

// Java program to illustrate arithmetic operators

public class Aoperators
{
public static void main(String[] args)
{
int a = 20, b = 10, c = 0, d = 20, e = 40, f = 30;
String x = “Thank”, y = “You”;
[Link](“a + b = “+(a + b));
[Link](“a - b = “+(a - b));

[Link](“x + y = “+x + y);

[Link](“a * b = “+(a * b));
[Link](“a / b = “+(a / b));
[Link](“a % b = “+(a % b));
}
}
The Relational Operators
The following relational operators are supported by Java language.
Example:
int A=10,B=20;
Operator Description Example Output
Checks if the values of two operands
== (equal to) are equal or not, if yes then condition (A == B) true
becomes true.
Checks if the values of two operands
!= (not equal to) are equal or not, if values are not equal (A != B) true
then condition becomes true.
Checks if the value of left operand is
> (greater than) greater than the value of right operand, (A > B) true
if yes then condition becomes true.
Checks if the value of left operand is
< (less than) less than the value of right operand, if (A < B) true
yes then condition becomes true.
 Checks if the value of left operand is
>= (greater than or greater than or equal to the value of
(A >= B) true
equal to) right operand, if yes then condition be-
comes true.
Checks if the value of left operand is
<= (less than or less than or equal to the value of right
(A <= B) true
equal to) operand, if yes then condition becomes
true.
checks whether the object is of a partic- boolean re-
ular type (class type or interface type) sult = name
instance of Operator True
(Object reference variable ) instanceof instanceof
(class/interface type) String;

// Java program to illustrate relational operators

public class operators
{
public static void main(String[] args)
{
int a = 20, b = 10;
boolean condition = true;
//various conditional operators
[Link](“a == b :” + (a == b));
[Link](“a < b :” + (a < b));
[Link](“a <= b :” + (a <= b));
[Link](“a > b :” + (a > b));
[Link](“a >= b :” + (a >= b));
[Link](“a != b :” + (a != b));
[Link](“condition==true :” + (condition == true));
}
}
Bitwise Operators
Java supports several bitwise operators, that can be applied to the integer types, long, int,
short, char, and byte. Bitwise operator works on bits and performs bit-by-bit operation.
Example:
int a = 60,b = 13;
binary format of a & b will be as follows −
 a = 0011 1100
b = 0000 1101
Bitwise operators follow the truth table:

a b a&b a|b a^b ~a

0 0 0 0 1 1
0 1 0 1 0 1
1 0 0 1 0 0
1 1 1 1 1 0

a&b = 0000 1100

a|b = 0011 1101
a^b = 0011 0001
~a = 1100 0011
The following table lists the bitwise operators −
int A=60,B=13;

Operator Description Example Output

& (bit- Binary AND Operator copies a (A & B) will give 12 12
wise and) bit to the result if it exists in both which is (in binary
operands. form:0000
1100)
| (bitwise Binary OR Operator copies a bit (A | B) 61
or) if it exists in either operand. (in binary form:
0011 1101)
^ (bitwise Binary XOR Operator copies the (A ^ B) will give 49 49
XOR) bit if it is set in one operand but which is 0011 0001 (in binary form:
not both. 0011 0001)
~ (bitwise Binary Ones Complement Opera- (~A) will give -61 -61
compli- tor is unary and has the effect of which is 1100 0011 (in binary form:
ment) ‘flipping’ bits. in 2’s complement 1100 0011)
form due to a signed
binary number.
<< (left The left operands value is moved A << 2 will give 240 240
shift) left by the number of bits speci- which is 1111 0000 (in binary form:
fied by the right operand. 1111 0000)
 >> (right The left operands value is moved A >> 2 will give 15 15
shift) right by the number of bits speci- which is 1111 (in binary form:
fied by the right operand. 1111)
>>> (zero The left operands value is moved A >>>2 will give 15 15
fill right right by the number of bits speci- which is 0000 1111 (in binary form:
shift) fied by the right operand and 0000 1111)
shifted values are filled up with
zeros.
// Java program to illustrate bitwise operators
public class operators
{
public static void main(String[] args)
{
int a = 10;
int b = 20;
[Link](“a&b = “ + (a & b));
[Link](“a|b = “ + (a | b));
[Link](“a^b = “ + (a ^ b));
[Link](“~a = “ + ~a);
}
}
Logical Operators
The following are the logical operators supported by java.
Example:
A=true;
B=false;

Operator Description Example Ouptput

&& (logical If both the operands are non-zero,
(A && B) false
and) then the condition becomes true.
|| (logical or) If any of the two operands are non-
zero, then the condition becomes (A || B) true
true.
 ! (logical not) Use to reverses the logical state of its
operand. If a condition is true then
!(A && B) true
Logical NOT operator will make
false.

Assignment Operators
The following are the assignment operators supported by Java.
Operator Description Example
=
C = A + B will as-
(Simple Assigns values from right side oper- sign value of
assignment ands to left side operand.
A + B into C
operator)
+=
(Add AND It adds right operand to the left operand C += A is equiva-
assignment and assigns the result to left operand. lent to C = C + A
operator)
-=
(Subtract It subtracts right operand from the left
C -= A is equiva-
AND operand and assigns the result to left
lent to C = C – A
assignment operand.
operator)
*=
(Multiply It multiplies right operand with the left
C *= A is equiva-
AND operand and assigns the result to left
lent to C = C * A
assignment operand.
operator)

/=
(Divide It divides left operand with the right
C /= A is equiva-
AND operand and assigns the result to left
lent to C = C / A
assignment operand.
operator)
%=
(Modulus It takes modulus using two operands C %= A is equiva-
AND assign- and assigns the result to left operand. lent to C = C % A
ment opera-
tor)
 C <<= 2 is same as
<<= Left shift AND assignment operator.
C = C << 2
C >>= 2 is same as
>>= Right shift AND assignment operator.
C = C >> 2

C &= 2 is same as
&= Bitwise AND assignment operator.
C=C&2

bitwise exclusive OR and assignment C ^= 2 is same as

^=
operator. C=C^2

bitwise inclusive OR and assignment C |= 2 is same as C

|=
operator. =C|2

// Java program to illustrate assignment operators

public class operators

{
public static void main(String[] args)
{
int a = 20, b = 10, c, d, e = 10, f = 4, g = 9;
c = b;
[Link](“Value of c = “ + c);
a += 1;

b -= 1;
e *= 2;
f /= 2;
[Link](“a, b, e, f = “ +
a + “,” + b + “,” + e + “,” + f);
}
}
Ternary Operator
Conditional Operator ( ? : )
Since the conditional operator has three operands, it is referred as the ternary operator.
This operator consists of three operands and is used to evaluate Boolean expressions. The
goal of the operator is to decide, which value should be assigned to the variable. The operator
is written as –
variable x = (expression) ? value if true : value if false
Following is an example −
Example:
public class example
{
public static void main(String args[])
{
int a, b;
a = 10;
b = (a == 0) ? 20: 30;
[Link]( “b : “ + b );
}
}
Unary Operators
Unary operators use only one operand. They are used to increment, decrement or negate
a value.

Operator Description
- Unary minus negating the values
+ Unary plus converting a negative value to positive
++ :Increment operator incrementing the value by 1
— : Decrement operator decrementing the value by 1
! : Logical not operator inverting a boolean value
// Java program to illustrate unary operators
public class operators
{
public static void main(String[] args)
{
int a = 20, b = 10, c = 0, d = 20, e = 40, f = 30;
boolean condition = true;
c = ++a;
[Link](“Value of c (++a) = “ + c);
c = b++;
[Link](“Value of c (b++) = “ + c);
 c = --d;
[Link](“Value of c (--d) = “ + c);
c = --e;
[Link](“Value of c (--e) = “ + c);
[Link](“Value of !condition =” + !condition);
}
}
Precedence of Java Operators
Operator precedence determines the grouping of operands in an expression. This affects
how an expression is evaluated. Certain operators have higher precedence than others; for
example, the multiplication operator has higher precedence than the addition operator −

For example, the following expression,

x = 10 + 5 * 2;
is evaluated. So, the output is 20, not 30. Because operator * has higher precedence
than +.
The following table shows the operators with the highest precedence at the top of the table
and those with the lowest at the bottom. Within an expression, higher precedence operators
will be evaluated first.

Category Operator Associativity

Postfix >() [] . (dot operator) Left to right
Unary >++ - - ! ~ Right to left
Multiplicative >* / Left to right
Additive >+ - Left to right
Shift >>> >>> << Left to right
Relational >> >= < <= Left to right
Equality >== != Left to right
Bitwise AND >& Left to right
Bitwise XOR >^ Left to right
Bitwise OR >| Left to right
Logical AND >&& Left to right
Logical OR >|| Left to right
Conditional ?: Right to left
Assignment >= += -= *= /= %= >>= Right to left
<<= &= ^= |=
 CONTROL FLOW
Java Control statements control the flow of execution in a java program, based on data val-
ues and conditional logic used. There are three main categories of control flow statements;
Selection statements: if, if-else and switch.
Loop statements: while, do-while and for.
Transfer statements: break, continue, return, try-catch-finally and assert.
Selection statements
The selection statements checks the condition only once for the program execution.

If Statement:
The if statement executes a block of code only if the specified expression is true. If the
value is false, then the if block is skipped and execution continues with the rest of the pro-
gram.
The simple if statement has the following syntax:
if (<conditional expression>)
<statement action>
The following program explains the if statement.
public class programIF{
public static void main(String[] args)
{
int a = 10, b = 20;
if (a > b)
[Link](“a > b”);
if (a < b)
[Link](“b < a”);
}
}
The If-else Statement
The if/else statement is an extension of the if statement. If the condition in the if statement
fails, the statements in the else block are executed. The if-else statement has the following
syntax:
if (<conditional expression>)
<statement action>
else
<statement action>

The following program explains the if-else statement.

public class ProgramIfElse
 {
public static void main(String[] args)
{
int a = 10, b = 20;
if (a > b)
{
[Link](“a > b”);
}
else
{
[Link](“b < a”);
}
}
}
Switch Case Statement
The switch case statement is also called as multi-way branching statement with several
choices. A switch statement is easier to implement than a series of if/else statements. The
switch statement begins with a keyword, followed by an expression that equates to a no long
integral value.
After the controlling expression, there is a code block that contains zero or more labeled
cases. Each label must equate to an integer constant and each must be unique. When the
switch statement executes, it compares the value of the controlling expression to the values
of each case label.
The program will select the value of the case label that equals the value of the control-
ling expression and branch down that path to the end of the code block. If none of the case
label values match, then none of the codes within the switch statement code block will be
executed.
Java includes a default label to use in cases where there are no matches. A nested switch
within a case block of an outer switch is also allowed. When executing a switch statement,
the flow of the program falls through to the next case. So, after every case, you must insert a
break statement.

The syntax of switch case is given as follows:

switch (<non-long integral expression>) {
case label1: <statement1>
case label2: <statement2>
…
case labeln: <statementn>
default: <statement>
} // end switch
The following program explains the switch statement.
 public class ProgramSwitch
{
public static void main(String[] args)
{
int a = 10, b = 20, c = 30;
int status = -1;
if (a > b && a > c)
{
status = 1;
}
else if (b > c)
{
status = 2;
}
else
{
status = 3;
}
switch (status)
{
case 1:[Link](“a is the greatest”);
break;
case 2:[Link](“b is the greatest”);
break;
case 3:[Link](“c is the greatest”);
break;
default:[Link](“Cannot be determined”);
}
}
}
Iteration statements
Iteration statements execute a block of code for several numbers of times until the condi-
tion is true.
While Statement
The while statement is one of the looping constructs control statement that executes a
block of code while a condition is true. The loop will stop the execution if the testing expres-
sion evaluates to false. The loop condition must be a boolean expression. The syntax of the
while loop is
 while (<loop condition>)
<statements>
The following program explains the while statement.
public class ProgramWhile
{
public static void main(String[] args)
{
int count = 1;
[Link](“Printing Numbers from 1 to 10”);
while (count <= 10)
{
[Link](count++);}
}
}
}

Do-while Loop Statement

The do-while loop is similar to the while loop, except that the test condition is performed
at the end of the loop instead of at the beginning. The do—while loop executes atleast once
without checking the condition.
It begins with the keyword do, followed by the statements that making up the body of the
loop. Finally, the keyword while and the test expression completes the do-while loop. When
the loop condition becomes false, the loop is terminated and execution continues with the
statement immediately following the loop.
The syntax of the do-while loop is
do
<loop body>
while (<loop condition>);
The following program explains the do--while statement.
public class DoWhileLoopDemo {
public static void main(String[] args) {
int count = 1;
[Link](“Printing Numbers from 1 to 10”);
do {
[Link](count++);
} while (count <= 10);
}
}
For Loop
 The for loop is a looping construct which can execute a set of instructions for a specified
number of times. It’s a counter controlled loop.
The syntax of the loop is as follows:
for (<initialization>; <loop condition>; <increment expression>)
<loop body>
• initialization statement executes once before the loop begins. The <initialization>
section can also be a comma-separated list of expression statements.
• test expression. As long as the expression is true, the loop will continue. If this
expression is evaluated as false the first time, the loop will never be executed.
• Increment(Update) expression that automatically executes after each repetition of the
loop body.
• All the sections in the for-header are optional. Any one of them can be left empty, but
the two semicolons are mandatory.
The following program explains the for statement.
public class ProgramFor {
public static void main(String[] args) {
[Link](“Printing Numbers from 1 to 10”);
for (int count = 1; count <= 10; count++) {
[Link](count);
}
}
}
Transfer statements
Transfer statements are used to transfer the flow of execution from one statement to an-
other.
Continue Statement
A continue statement stops the current iteration of a loop (while, do or for) and causes
execution to resume at the top of the nearest enclosing loop. The continue statement can be
used when you do not want to execute the remaining statements in the loop, but you do not
want to exit the loop itself.
The syntax of the continue statement is
continue; // the unlabeled form
continue <label>; // the labeled form
It is possible to use a loop with a label and then use the label in the continue statement.
The label name is optional, and is usually only used when you wish to return to the outermost
loop in a series of nested loops.
The following program explains the continue statement.
public class ProgramContinue
{
public static void main(String[] args) {
 [Link](“Odd Numbers”);

for (int i = 1; i <= 10; ++i) {

if (i % 2 == 0)
continue;
[Link](i + “\t”);
}
}
}
Break Statement
The break statement terminates the enclosing loop (for, while, do or switch statement).
Break statement can be used when we want to jump immediately to the statement following
the enclosing control structure. As continue statement, can also provide a loop with a label,
and then use the label in break statement. The label name is optional, and is usually only used
when you wish to terminate the outermost loop in a series of nested loops.
The Syntax for break statement is as shown below;
break; // the unlabeled form
break <label>; // the labeled form
The following program explains the break statement.
public class ProgramBreak {
public static void main(String[] args) {
[Link](“Numbers 1 - 10”);
for (int i = 1;; ++i) {
if (i == 11)
break;
// Rest of loop body skipped when i is even
[Link](i + “\t”);
}
}
 Types of User-defined methods
The methods in C are classified based on data flow between calling method and called
method. They are:
• Method with no arguments and no return value
• Method with no arguments and a return value
• Method with arguments and no return value
• Method with arguments and a return value.
•
Method with no arguments and no return value
In this type of method, no value is passed in between calling method and called method.
Here, when the method is called program control transfers to the called method, executes the
method, and return back to the calling method.
Example:
Program to compute addition of two numbers (no argument and no return value)
public class Main{
public void add(){ // method definition with no arguments and no return value
int a=10,b=20;
[Link](“Sum:”+(a+b));
}
public static void main(String[] args) {
Main obj=new Main();
[Link](); // method call with no arguments
}
}
Sample Output:
Sum:30
Method with no arguments and a return value
In this type of method, no value is passed from calling method to called method but a
value is returned from called method to calling method.

Example:
Program to compute addition of two numbers (no argument and with return value)

public class Main {

public int add(){ // method definition with no arguments and with return value
int a=10,b=20;
return(a+b);
}
public static void main(String[] args) {
 int sum=0;
Main obj=new Main();
sum=[Link]();
[Link](“Sum:”+sum);
}
}
Sample Output:
Sum:30
Method with arguments and no return value
In this type of method, parameters are passed from calling method to called method but
no value is returned from called method to calling method.
Example:
Program to compute addition of two numbers (with argument and without return value)
public class Main {
public void add(int x,int y){ // method definition with arguments and no return value
[Link](“Sum:”+(x+y));
}
public static void main(String[] args) {
int a=10,b=20;
Main obj=new Main();
[Link](a,b); // method call with arguments
}
}
Sample Output:
Sum:30

Method with arguments and a return value.

In this type of method, there is data transfer in between calling method and called method.
Here, when the method is called program control transfers to the called method with argu-
ments, executes the method, and return the value back to the calling method.
Example:
Program to compute addition of two numbers (with argument and return value)
public class Main {
public int add(int x,int y){ // function definition with arguments and return value
return(x+y); //return value
 }
public static void main(String[] args) {int a=10,b=20;

Main obj=new Main();

[Link](“Sum:”+[Link](a,b));
}
}
Sample Output:
Sum:30

PARAMETER PASSING IN JAVA

The commonly available parameter passing methods are:
• Pass by value
• Pass by reference
Pass by Value
In pass by value, the value passed to the method is copied into the local parameter
and any change made inside the method only affects the local copy has no effect on the
original copy. In Java, parameters are always passed by value. All the scalar variables (of
type int, long, short, float, double, byte, char, Boolean) are always passed to the methods by
value. Only the non-scalar variables like Object, Array, String are passed by reference.
Note:
Scalar variables are singular data with one value; Non scalar variables are data with mul-
tiple values.

Example:
Pass by value
class Swapper{
int a;
int b;
Swapper(int x, int y) // constructor to initialize variables
{
a = x;
b = y;
}
void swap(int x, int y) // method to interchange values
{
 int temp; temp = x;

x=y;

y=temp;
}
}class Main{
public static void main(String[] args){
Swapper obj = new Swapper(10, 20); // create object
[Link](“Before swapping: a=”+obj.a+” b=”+obj.b);
[Link](obj.a,obj.b); // call the method by passing class object as parameter
[Link](“Before swapping: a=”+obj.a+” b=”+obj.b);
}
}
Sample Output:
Before swapping: a=10 b=20
After swapping: a=10 b=20

Here, to call method swap() first create an object for class Swapper. Then the method is
called by passing object values a and b as input parameters. As these values are scalar, the
parameters are passed using pass by value technique. So the changes carried out inside the
method are not reflected in original value of a and b.
Pass by Reference
In pass-by-reference, reference (address) of the actual parameters is passed to the local
parameters in the method definition. So, the changes performed on local parameters are re-
flected on the actual parameters.
Example:
class Swapper{
int a;
int b;
Swapper(int x, int y) // constructor to initialize variables
{
a = x;
b = y;
}
void swap(Swapper ref) // method to interchange values
{
 int temp = ref.a;
ref.a = ref.b;

ref.b = temp;
}
}
class PassByRef{
public static void main(String[] args){
Swapper obj = new Swapper(10, 20); // create object
[Link](“Before swapping: a=”+obj.a+” b=”+obj.b);

[Link](obj); // call the method by passing class object as parameter

[Link](“After swapping: a=”+obj.a+” b=”+obj.b);
}
}
Sample Output:
Before swapping: a=10 b=20
After swapping: a=20 b=10
In this example, the class object is passed as parameter using pass by reference technique.
So the method refers the original value of a and b.
Method using object as parameter and returning objects
A method can have object as input parameter (see pass by reference) and can return a class
type object.
Example:
class Addition{
int no;
Addition(){}
Addition(int x){
no=x;
}
public Addition display(Addition oa){
Addition tmp=new Addition();
/*method with same class object as input parameter &
[Link]=no+[Link]; return value*/
return(tmp);
 }
}
class Main{
public static void main(String args[]){
Addition a1=new Addition(10);
Addition a2=new Addition(10);
Addition a3;
a3=[Link](a2); // method is invoked using the object a1 with input parameter a2
[Link](“[Link]=”+[Link]+” [Link]=”+[Link]+” [Link]=”+[Link]);
}
}
Sample Output:
[Link]=10 [Link]=10 [Link]=20
Here, display() accepts class Addition object a2 as input parameter. It also return same
class object as output. This method adds the value of invoking object a1 and input parameter
a2. The summation result is stored in temporary object tmp inside the method. The value re-
turned by the method is received using object a3 inside main().
 METHOD OVERLOADING
Method overloading is the process of having multiple methods with same name that dif-
fers in parameter list. The number and the data type of parameters must differ in overloaded
methods. It is one of the ways to implement polymorphism in Java. When a method is called,
the overloaded method whose parameters match with the arguments in the call gets invoked.
Note: Overloaded methods are differentiable only based on parameter list and not on their
return type.
Example:
Program for addition using Method Overloading
class MethodOverload{
void add(){
[Link](“No parameters”);
}
void add(int a,int b){ // overloaded add() for two integer parameter
[Link](“Sum:”+(a+b));
}
void add(int a,int b,int c){ // overloaded add() for three integer parameter
[Link](“Sum:”+(a+b+c));
}
void add(double a,double b){ // overloaded add() for two double parameter
[Link](“Sum:”+(a+b));

}
}
public class Main {
public static void main(String[] args) {
MethodOverload obj=new MethodOverload();
[Link](); // call all versions of add()
[Link](1,2);
[Link](1,2,3);
[Link](12.3,23.4);
}
}
Sample Output:
No parameters
Sum:3
Sum:6
Sum:35.7
Here, add() is overloaded four times. The first version takes no parameters, second takes
two integers, third takes three integers and fourth accepts two double parameter.
 CONSTRUCTOR OVERLOADING
Like methods, we can overload constructors for creating objects in different ways.
Compiler differentiates constructors on the basis of numbers of parameters, types of the
parameters and order of the parameters.

// Java Program to illustrate constructor overloading

import [Link].*;
class myclass
{
// constructor with one argument
myclass (String name)
{
[Link](“Constructor with one “ + “argument - String : “ + name);
}
// constructor with two arguments
myclass (String name, int id)
{
[Link](“Constructor with two arguments : “ +” String and Integer : “ + name
+ “ “+ id);
}
// Constructor with one argument but with different type than previous.
myclass (long num)
{
[Link](“Constructor with one argument : “ +”Long : “ + num);
}
}
class myclassmain
{
public static void main(String[] args)
{
myclass m1 = new myclass (“JAVA”);
myclass m2 = new myclass (“Python”, 2017);
myclass m3 = new myclass(3261567);
}
}
Constructors are different from methods in Java
• Constructor(s) must have the same name as the class within which it defined while it
is not necessary for the method in java.
• Constructor(s) do not any return type while method(s) have the return type or void if
does not return any value.
• Constructor is called only once at the time of Object creation while method(s) can be
called any numbers of time.

Creating an Object
The class provides the blueprints for objects. The objects are the instances of the class. In
Java, the new keyword is used to create new objects.
There are three steps when creating an object from a class −
• Declaration − A variable declaration with a variable name with an object type.
• Instantiation − The ‘new’ keyword is used to create the object.
• Initialization − The ‘new’ keyword is followed by a call to a constructor. This call
initializes the new object.

METHODS IN JAVA
A method is a collection of statement that performs specific task. In Java, each method is
a part of a class and they define the behavior of that class. In Java, method is a jargon used
for method.
Advantages of methods
• Program development and debugging are easier
• Increases code sharing and code reusability
• Increases program readability
• It makes program modular and easy to understanding
• It shortens the program length by reducing code redundancy
Types of methods
There are two types of methods in Java programming:
• Standard library methods (built-in methods or predefined methods)
• User defined methods
Standard library methods
The standard library methods are built-in methods in Java programming to handle tasks
such as mathematical computations, I/O processing, graphics, string handling etc. These
methods are already defined and come along with Java class libraries, organized in packages.
In order to use built-in methods, we must import the corresponding packages. Some of library
methods are listed below.
 Packages Library Methods Descriptions
[Link] acos() Computes arc cosine of the argument
All maths related methods exp() Computes the e raised to given power
are defined in this class
abs() Computes absolute value of argument
log() Computes natural logarithm
sqrt() Computes square root of the argument
pow() Computes the number raised to given
power
[Link] charAt() Returns the char value at the specified
index.
All string related methods concat()
are defined in this class compareTo() Concatenates two string

indexOf() Compares two string

Returns the index of the first occurrence
of the given character
toUpperCase()
converts all of the characters in the String
to upper case
[Link] add() inserts a component
contains classes for setSize() set the size of the component
graphics
setLayout() defines the layout manager
setVisible() changes the visibility of the component

Example:
Program to compute square root of a given number using built-in method.
public class MathEx {
public static void main(String[] args) {
[Link](“Square root of 14 is: “ + [Link](14));
}
}
Sample Output:
Square root of 14 is: 3.7416573867739413

User-defined methods
The methods created by user are called user defined methods.
Every method has the following.
• Method declaration (also called as method signature or method prototype)
• Method definition (body of the method)
• Method call (invoke/activate the method)
Method Declaration
The syntax of method declaration is:
Syntax:
return_type method_name(parameter_list);
Here, the return_type specifies the data type of the value returned by method. It will be
void if the method returns nothing. method_name indicates the unique name assigned to the
method. parameter_list specifies the list of values accepted by the method.
Method Definition
Method definition provides the actual body of the method. The instructions to complete a
specific task are written in method definition. The syntax of method is as follows:
Syntax:
modifier return_type method_name(parameter_list){
// body of the method
}
Here,
Modifier – Defines the access type of the method i.e accessibility re-
gion of method in the application
return_type – Data type of the value returned by the method or void if
method returns nothing
method_name – Unique name to identify the method. The name must follow
the rules of identifier
parameter_list – List of input parameters separated by comma. It must be
like
datatype parameter1,datatype parameter2,……
List will be empty () in case of no input parameters.
method body – block of code enclosed within { and } braces to perform
specific task

The first line of the method definition must match exactly with the method prototype. A
method cannot be defined inside another method.
Method Call
A method gets executed only when it is called. The syntax for method call is.
Syntax:
method_name(parameters);
When a method is called, the program control transfers to the method definition where
the actual code gets executed and returns back to the calling point. The number and type of
parameters passed in method call should match exactly with the parameter list mentioned in
method prototype.
Example:
Method name
class Addition{
Modifier
public int add(int a,int b){
Return type Body of the method
return(a+b);
}
Parameter list
}
class Main{
Method call
Method return public static void main(String args[]){
int sum=0,a=1,b=12;
Addition obj=new Addition();
sum=[Link](a,b);
[Link](“Sum:”+sum);
}
}
 STATIC KEYWORD

The static keyword indicates that the member belongs to the class instead of a specific
instance. It is used to create class variable and mainly used for memory management. The
static keyword can be used with:
• Variable (static variable or class variable)
• Method (static method or class method)
• Block (static block)
• Nested class (static class)
• import (static import)

Static variable
Variable declared with keyword static is a static variable. It is a class level variable com-
monly shared by all objects of the class.
• Memory allocation for such variables only happens once when the class is loaded in
the memory.
• scope of the static variable is class scope ( accessible only inside the class)
• lifetime is global ( memory is assigned till the class is removed by JVM).
• Automatically initialized to 0.
• It is accessible using [Link]
• Static variables can be accessed directly in static and non-static methods.
Example :

Without static With static

class StaticEx{ class StaticEx{

int no=10; static int no=10;

StaticEx(){ StaticEx(){

[Link](no); [Link](no);

no++; no++;

} }

} }

public class Main{ public class Main{

public static void main(String[] args) public static void main(String[] args)

{ {

StaticEx obj1=new StaticEx(); StaticEx obj1=new StaticEx();

StaticEx obj2=new StaticEx(); StaticEx obj2=new StaticEx();

StaticEx obj3=new StaticEx(); StaticEx obj3=new StaticEx();

} }

} }

Sample Output: Sample Output:

10 10

10 11

10 12
Static Method
The method declared with static keyword is known as static method. main() is most com-
mon static method.
• It belongs to the class and not to object of a class.
• A static method can directly access only static variables of class and directly invoke
only static methods of the class.
• Static methods cannot access non-static members(instance variables or instance
methods) of the class
• Static method cant access this and super references
• It can be called through the name of class without creating any instance of that class.
For example, [Link]()
Example:
class StaticEx{
static int x;
int y=10;
static void display(){
[Link](“Static Method “+x); // static method accessing static variable
}
public void show(){
[Link](“Non static method “+y);
[Link](“Non static method “+x); // non-static method can access static variable
}
}
public class Main
{
public static void main(String[] args) {
StaticEx obj=new StaticEx();
[Link](); // static method invoked without using object
 [Link]();
}
}
Sample Output:
Static Method 0
Non static method 10
Non static method 0
In this example, class StaticEx consists of a static variable x and static method display().
The static method cannot access a non-static variable. If you try to access y inside static
method display(), it will result in compilation error.

static void display(){

[Link](“Static Method “+x+y);
}
Static Block
A static block is a block of code enclosed in braces, preceded by the keyword static.
• The statements within the static block are first executed automatically before main
when the class is loaded into JVM.
• A class can have any number of static blocks.
• JVM combines all the static blocks in a class as single block and executes them.
• Static methods can be invoked from the static block and they will be executed as and
when the static block gets executed.
Syntax:
static{
…………….
}
Example:
class StaticBlockEx{
StaticBlockEx (){
[Link](“Constructor”);
}
static {
[Link](“First static block”);
}
static void show(){
[Link](“Inside method”);
}
static{
[Link](“Second static block”);
show();
 }

public static void main(String[] args) {

StaticBlockEx obj=new StaticBlockEx ();
}
static{
[Link](“Static in main”);
}
}
Sample Output:
First static block
Second static block
Inside method

Static in main
Constructor
Nested class (static class)
Nested class is a class declared inside another class. The inner class must be a static class
declared using keyword static. The static nested class can refer directly to static members of
the enclosing classes, even if those members are private.
Syntax:
class OuterClass{
……..
static class InnerClass{
……….
}
}
We can create object for static nested class directly without creating object for outer class.
For example:
[Link]=new [Link]();
Example:
class Outer{
static int x=10;
static class Inner{
int y=20;
public void show(){
[Link](x+y); // nested class accessing its own data & outer
class static data
}
}
 }
class Main{
public static void main(String args[]){
[Link] obj=new [Link](); // Creating object for static nested class
[Link]();
}
}
Sample Output:
30
Static Import
The static import allows the programmer to access any static members of imported class
directly. There is no need to qualify it by its name.
Syntax:
Import static package_name;
Advantage:
• Less coding is required if you have access any static member of a class oftenly.
Disadvantage:
• Overuse of static import makes program unreadable and unmaintable.
Example:
import static [Link].*;
class StaticImportEx{
public static void main(String args[]){
[Link](“Static Import Example”); //Now no need of [Link]
}
}
Sample Output:
Static Import Example
 ACCESS SPECIFIERS
Access specifiers or access modifiers in java specifies accessibility (scope) of a data mem-
ber, method, constructor or class. It determines whether a data or method in a class can be
used or invoked by other class or subclass.
Types of Access Specifiers
There are 4 types of java access specifiers:
1. Private
2. Default (no speciifer)
3. Protected
4. Public

The details about accessibility level for access specifiers are shown in following table.
Access Modifiers Default Private Protected Public
Accessible inside the class Yes Yes Yes Yes
Accessible within the subclass
Yes No Yes Yes
inside the same package
Accessible outside the package No No No Yes
Accessible within the subclass
No No Yes Yes
outside the package
Private access modifier
Private data fields and methods are accessible only inside the class where it is declared i.e
accessible only by same class members. It provides low level of accessibility. Encapsulation
and data hiding can be achieved using private specifier.
Example:
Role of private specifier
class PrivateEx{
private int x; // private data
public int y; // public data
private PrivateEx(){} // private constructor
public PrivateEx(int a,int b){ // public constructor
x=a;
y=b;
}
}
public class Main {
public static void main(String[] args) {
PrivateEx obj1=new PrivateEx(); // Error: private constructor cannot be applied
PrivateEx obj2=new PrivateEx(10,20); // public constructor can be applied to obj2
 [Link](obj2.y); // public data y is accessible by a non-member
[Link](obj2.x); //Error: x has private access in PrivateEx
}
}

In this example, we have created two classes PrivateEx and Main. A class contains private
data member, private constructor and public method. We are accessing these private members
from outside the class, so there is compile time error.

Default access modifier

If the specifier is mentioned, then it is treated as default. There is no default specifier
keyword. Using default specifier we can access class, method, or field which belongs to same
package, but not from outside this package.

Example:

Role of default specifier

class DefaultEx{

int y=10; // default data

public class Main {

public static void main(String[] args) {

DefaultEx obj=new DefaultEx();

[Link](obj.y); // default data y is accessible outside the class

Sample Output:

10

In the above example, the scope of class DefaultEx and its data y is default. So it can be
accessible within the same package and cannot be accessed from outside the package.

Protected access modifier

Protected methods and fields are accessible within same class, subclass inside same pack-
age and subclass in other package (through inheritance). It cannot be applicable to class and
interfaces.

Example:
Role of protected specifier
 class Base{
protected void show(){
[Link](“In Base”);
}
}
public class Main extends Base{
public static void main(String[] args) {
Main obj=new Main();
[Link]();
}
}
Sample Output:
In Base
In this example, show() of class Base is declared as protected, so it can be accessed from
outside the class only through inheritance. Chapter 2 explains the concept of inheritance in
detail.
Public access modifier
The public access specifier has highest level of accessibility. Methods, class, and fields
declared as public are accessible by any class in the same package or in other package.
Example:
Role of public specifier
class PublicEx{
public int no=10;
}
public class Main{
public static void main(String[] args) {
PublicEx obj=new PublicEx();
[Link]([Link]);
}
}
Sample Output:
10
In this example, public data no is accessible both by member and non-member of the
class.
 ARRAYS
Array is a collection of elements of similar data type stored in contiguous memory loca-
tion. The array size is fixed i.e we can’t increase/decrease its size at runtime. It is index based
and the first element is stored at 0th index.

Advantages of Array
• Code Optimization: Multiple values can be stored under common name. Date retrieval
or sorting is an easy process.
• Random access: Data at any location can be retrieved randomly using the index.
Disadvantages of Array
• Inefficient memory usage: Array is static. It is not resizable at runtime based on number
of user’s input. To overcome this limitation, Java introduce collection concept.
Types of Array
There are two types of array.
• One Dimensional Array
• Multidimensional Array

One Dimensional Array

Declaring Array Variables
The syntax for declaring an array variable is
Syntax:
dataType[] arrayName; //preferred way
Or
dataType arrayName [];
Here datatype can be a primitive data type like: int, char, Double, byte etc. arrayName is
an identifier.
Example:
int[] a;
Instantiation of an Array
Array can be created using the new keyword. To allocate memory for array elements
we must mention the array size. The size of an array must be specified by an int value and
not long or short. The default initial value of elements of an array is 0 for numeric types
and false for boolean.
Syntax:
arrayName=new datatype[size];
 Or
dataType[] arrayName=new datatype[size]; //declaration and instantiation

Example:
int[] a=new int[5]; //defining an integer array for 5 elements
Alternatively, we can create and initialize array using following syntax.
Syntax:
dataType[] arrayName=new datatype[]{list of values separated by comma};
Or

dataType[] arrayName={ list of values separated by comma};

Example:
int[] a={12,13,14};
int[] a=new int[]{12,13,14};
The built-in length property is used to determine length of the array i.e. number of ele-
ments present in an array.
Accessing array elements
The array elements can be accessed by using indices. The index starts from 0 and ends at
(array size-1). Each element in an array can be accessed using for loop.
Example:
Program to access array elements.
class Main{
public static void main(String args[]){
int a[]=new int[]{10,20,30,40};//declaration and initialization
//printing array
for(int i=0;i<[Link];i++)//length is the property of array
[Link](a[i]);
}
}
Sample Output:
10
20
30
40

The for-each loop

The for-each loop is used to traverse the complete array sequentially without using an
index variable. It’s commonly used to iterate over an array or a Collections class (eg, Array-
List).
Syntax:
 for(type var:arrayName){
Statements using var;
}
Example:
Program to calculate sum of array elements.
class Main{
public static void main(String args[]){
int a[]=new int[]{10,20,30,40};//declaration and initialization
int sum=0;
for(int i:a) // calculate sum of array elements
sum+=i;
[Link](“Sum:”+sum);
}
}
Sample Output:
Sum:100
Multidimensional Arrays
Multidimensional arrays are arrays of arrays with each element of the array holding the
reference of other array. These are also known as Jagged Arrays.
Syntax:
dataType[][] arrayName=new datatype[rowsize][columnnsize]; // 2 dimensional array
dataType[][][] arrayName=new datatype[][][]; // 3 dimensional array
Example:
int[][] a=new int[3][4];

Example:
Program to access 2D array elements
class TwoDimEx
{
 public static void main(String args[])
{
// declaring and initializing 2D array
int arr[][] = { {1,1,12},{2,16,1},{12,42,2} };
// printing 2D array
for (int i=0; i< [Link]; i++)
{
for (int j=0; j < arr[i].length ; j++)
[Link](arr[i][j] + “ “);
[Link]();
}
}
}
Sample Output:
1 1 12
2 16 1
12 42 2

Jagged Array
Jagged array is an array of arrays with different row size i.e. with different dimensions.
Example:
class Main {
public static void main(String[] args) {

int[][] a = {
{11, 3, 43},
{3, 5, 8, 1},
{9},
};

[Link](“Length of row 1: “ + a[0].length);

[Link](“Length of row 2: “ + a[1].length);
[Link](“Length of row 3: “ + a[2].length);
}
}
Sample Output:
Length of row 1: 3
Length of row 2: 4
Length of row 3: 1

Passing an array to a method

An array can be passed as parameter to method.
Example:
Program to find minimum element in an array
class Main{
static void min(int a[]){
int min=a[0];
for(int i=1;i<[Link];i++)
if(min>a[i])
min=a[i];
[Link](“Minimum:”+min);
}
public static void main(String args[]){
int a[]={12,13,14,5};
min(a);//passing array to method
}
}
Sample Output:
Minimum:5

Returning an array from a method

A method may also return an array.
Example:
Program to sort array elements in ascending order.
class Main{
static int[] sortArray(int a[]){
int tmp;
for(int i=0;i<[Link]-1;i++) { //code for sorting
for(int j=i+1;j<=[Link]-1;j++) {
if(a[i]>a[j]){
tmp=a[i];
 a[i]=a[j];
a[j]=tmp;
}
}
}
return(a); // returning array
}
public static void main(String args[]){
int a[]={33,43,24,5};
a=sortArray(a);//passing array to method
 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.

Here, we will have the detailed learning of creating and using user-defined packages.

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.

Example of java package

The package keyword is used to create a package in java.
//save as [Link]
package mypack;
public class Simple{
public static void main(String args[]){
[Link]("Welcome to package");
}
}
How to compile java package

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

javac -d directory javafilename

For Example

javac -d . [Link]

The -d switch specifies the destination where to put the generated class file. You can use any
directory name like /home (in case of Linux), d:/abc (in case of windows) etc. If you want to
keep the package within the same directory, you can use . (dot).

How to run java package program

You need to use fully qualified name e.g. [Link] etc to run the class.

To Compile: javac -d . [Link]

To Run: java [Link]

Output:Welcome to package

The -d is a switch that tells the compiler where to put the class file i.e. it represents destination.
The . represents the current folder.

How to access package from another package?

There are three ways to access the package from outside the package.

1. import package.*;
2. import [Link];
3. fully qualified name.

1) Using packagename.*

If you use package.* then all the classes and interfaces of this package will be accessible but
not subpackages.

The import keyword is used to make the classes and interface of another package accessible to
the current package.
Example of package that import the packagename.*
//save by [Link]
package pack;
public class A{
public void msg(){[Link]("Hello");}
}
//save by [Link]
package mypack;
import pack.*;

class B{
public static void main(String args[]){
A obj = new A();
[Link]();
}
}

Output:Hello

2) Using [Link]

If you import [Link] then only declared class of this package will be accessible.

Example of package by import [Link]

//save by [Link]
package pack;
public class A{
public void msg(){[Link]("Hello");}
}
//save by [Link]
package mypack;
import pack.A;

class B{
public static void main(String args[]){
A obj = new A();
[Link]();
}
 }
Output:Hello

3) Using fully qualified name

If you use fully qualified name then only declared class of this package will be accessible. Now
there is no need to import. But you need to use fully qualified name every time when you are
accessing the class or interface.

It is generally used when two packages have same class name e.g. [Link] and [Link]
packages contain Date class.
Example of package by import fully qualified name
//save by [Link]
package pack;
public class A{
public void msg(){[Link]("Hello");}
}
//save by [Link]
package mypack;
class B{
public static void main(String args[]){
pack.A obj = new pack.A();//using fully qualified name
[Link]();
}
}
Output:Hello

Note: If you import a package, all the classes and interface of that package will be imported
excluding the classes and interfaces of the subpackages. Hence, you need to import the
subpackage as well.
 ORDER OF CONSTRUCTOR INVOCATION
• Constructors are invoked in the order of their derivation
• If a subclass constructor does not explicitly invoke a superclass constructor using
super() in the first line, the Java compiler automatically inserts a call to the no-
argument constructor of the superclass. If the superclass does not have a no-argument
constructor, it will generate a compile-time error.
Example:
class A
{
A(){
[Link](“A’s Constructor”);
}
}
/* sub class B extending A */
class B extends A
{
B(){
super();
[Link](“B’s Constructor”);
}
}
/* sub class C extending B */
class C extends B{
C(){
super();
[Link](“C’s Constructor”);
}
}
/* Driver program to test */
class Main
{
public static void main(String[] args)
{
C obj = new C();
}
}
Sample Output:
A’s Constructor
B’s Constructor
C’s Constructor
Invoking Superclass Parameterized Constructor
To call parameterized constructor of superclass, we must use the super keyword as shown
below.
Syntax:
super(value);
Example:
class SuperCls{
int x;
SuperCls(int x){
this.x=x; // this refers to current invoking object
}
}
class SubCls extends SuperCls{
int y;
SubCls(int x,int y){
super(x); // invoking parameterized constructor of superclass
this.y=y;
}
public void display(){
[Link](“x: “+x+” y: “+y);
}
}
public class Main
{
public static void main(String[] args) {
SubCls obj=new SubCls(10,20);
[Link]();
}
}
Sample Output:
x: 10 y: 20
The program contains a superclass and a subclass, where the superclass contains a param-
eterized constructor which accepts a integer value, and we used the super keyword to invoke
the parameterized constructor of the superclass.
 THE OBJECT CLASS
The Object class is the parent class of all the classes in java by default (directly or indi-
rectly). The [Link] class is the root of the class hierarchy. Some of the Object class
are Boolean, Math, Number, String etc.
Object

Boolean Character Number Math String StringBuffer

Byte Short Integer Long Float Double

Some of the important methods defined in Object class are listed below.
Object class Methods Description
boolean equals(Object) Returns true if two references point to the same object.
String toString() Converts object to String
void notify()
void notifyAll() Used in synchronizing threads
void wait()
void finalize() Called just before an object is garbage collected
Returns a new object that are exactly the same as the current
Object clone()
object
int hashCode() Returns a hash code value for the object.

Example:
public class Test
{
public static void main(String[] args)
{

Test t = new Test();

[Link](t);
[Link]([Link]());
[Link]([Link]());
t = null;
[Link]();
 [Link](“end”);
}
protected void finalize() // finalize() is called just once on an object
{
[Link](“finalize method called”);
}
}
Sample Output:
Test@2a139a55
Test@2a139a55
705927765
end
finalize method called
In the above program, the default toString() method for class Object returns a string con-
sisting of the name of the class Test of which the object is an instance, the at-sign character
`@’, and the unsigned hexadecimal representation of the hash code of the object.

ABSTRACT CLASSES AND METHODS

Abstract class
A class that is declared as abstract is known as abstract class. It can have abstract and
non-abstract methods (method with body). It needs to be extended and its method imple-
mented. It cannot be instantiated.
Syntax:
abstract class classname
{
}
Abstract method
A method that is declared as abstract and does not have implementation is known as ab-
stract method. The method body will be defined by its subclass.
Abstract method can never be final and static. Any class that extends an abstract class
must implement all the abstract methods declared by the super class.
Note:
A normal class (non-abstract class) cannot have abstract methods.
Syntax:
abstract returntype functionname (); //No definition
Syntax for abstract class and method:
modifier abstract class className
{
//declare fields
//declare methods
 abstract dataType methodName();
}
modifier class childClass extends className
{
dataType methodName()
{
}
}
Why do we need an abstract class?
Consider a class Animal that has a method sound() and the subclasses of it like Dog Lion,
Horse Cat etc. Since the animal sound differs from one animal to another, there is no point to
implement this method in parent class. This is because every child class must override this
method to give its own implementation details, like Lion class will say “Roar” in this method
and Horse class will say “Neigh”.
So when we know that all the animal child classes will and should override this method,
then there is no point to implement this method in parent class. Thus, making this method
abstract would be the good choice. This makes this method abstract and all the subclasses
to implement this method. We need not give any implementation to this method in parent
class.
Since the Animal class has an abstract method, it must be declared as abstract.
Now each animal must have a sound, by making this method abstract we made it compul-
sory to the child class to give implementation details to this method. This way we ensure that
every animal has a sound.
Rules
1. Abstract classes are not Interfaces.
2. An abstract class may have concrete (complete) methods.
3. An abstract class may or may not have an abstract method. But if any class has one or
more abstract methods, it must be compulsorily labeled abstract.
4. Abstract classes can have Constructors, Member variables and Normal methods.
5. Abstract classes are never instantiated.
6. For design purpose, a class can be declared abstract even if it does not contain any
abstract methods.
7. Reference of an abstract class can point to objects of its sub-classes thereby achieving
run-time polymorphism Ex: Shape obj = new Rectangle();
8. A class derived from the abstract class must implement all those methods that are
declared as abstract in the parent class.
9. If a child does not implement all the abstract methods of abstract parent class, then the
child class must need to be declared abstract as well.
Example 1
//abstract parent class
abstract class Animal
{
//abstract method
 public abstract void sound();
}
//Lion class extends Animal class
public class Lion extends Animal
{
public void sound()
{
[Link](“Roars”);
}
public static void main(String args])
{
Animal obj = new Lion();
[Link]();
}
}

Output:
Roars
In the above code, Animal is an abstract class and Lion is a concrete class.

Example 2
abstract class Bank
{
abstract int getRateOfInterest();
}
class SBI extends Bank
{
int getRateOfInterest()
{
return 7;
}
}
class PNB extends Bank
{
int getRateOfInterest()
{
return 8;
}
}
public class TestBank
 {
public static void main(String args[])
{
Bank b=new SBI();//if object is PNB, method of PNB will be invoked
int interest=[Link]();
[Link](“Rate of Interest is: “+interest+” %”);
b=new PNB();
[Link](“Rate of Interest is: “+[Link]()+” %”);
}
}

Output:
Rate of Interest is: 7 %
Rate of Interest is: 8 %
Abstract class with concrete (normal) method
Abstract classes can also have normal methods with definitions, along with abstract
methods.
Sample Code:
abstract class A
{
abstract void callme();
public void normal()
{
[Link](“this is a normal (concrete) method.”);
}
}
public class B extends A
{
void callme()
{
[Link](“this is an callme (abstract) method.”);
}
public static void main(String[] args)
{
B b = new B();
[Link]();
[Link]();
}
}
Output:
this is an callme (abstract) method.
this is a normal (concrete) method.
Observations about abstract classes in Java
1. An instance of an abstract class cannot be created; But, we can have references
of abstract class type though.
Sample Code:
abstract class Base
{
abstract void fun();
}
class Derived extends Base
{
void fun()
{
[Link](“Derived fun() called”);
}
}
public class Main
{
public static void main(String args[])
{
// Base b = new Base(); Will lead to error
// We can have references of Base type.
Base b = new Derived();
[Link]();
}
}
Output:
Derived fun() called

2. An abstract class can contain constructors in Java. And a constructor of ab-

stract class is called when an instance of a inherited class is created.
Sample Code:
abstract class Base
{
Base()
{
[Link](“Within Base Constructor”);
}
abstract void fun();
}
class Derived extends Base
{
 Derived()
{
[Link](“Within Derived Constructor”);
}
void fun()
{
[Link](“ Within Derived fun()”);
}
}
public class Main
{
public static void main(String args[])
{
Derived d = new Derived();
}
}
Output:
Within Base Constructor
Within Derived Constructor

3. We can have an abstract class without any abstract method. This allows us to create
classes that cannot be instantiated, but can only be inherited.
Sample Code:
abstract class Base
{
void fun()
{
[Link](“Within Base fun()”);
}
}
class Derived extends Base
{
}
public class Main
{
public static void main(String args[])
{
Derived d = new Derived();
[Link]();
}
}
Output:
Within Base fun()
4. Abstract classes can also have final methods (methods that cannot be
overridden).
Sample Code:
abstract class Base
{
final void fun()
{
[Link](“Within Derived fun()”);
}
}
class Derived extends Base
{
}
public class Main
{
public static void main(String args[])
{
Base b = new Derived();
[Link]();
}
}
Output:
Within Derived fun()
 FINAL KEYWORD
The final keyword in java is used to restrict the user. The java final keyword can be
ap-plied to:
• variable
• method
• class

Java final variable:- To prevent constant variables

Java final method : To prevent method overriding
Java final class:- To prevent inheritance

Java final variable

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.
Sample Code:
A final variable speedlimit is defined within a class Vehicle. When we try to change
the value of this variable, we get an error. This is due to the fact that the value of final
variable cannot be changed, once a value is assigned to it.
public class Vehicle
{
final int speedlimit=60;//final variable
void run()
{
speedlimit=400;
}
public static void main(String args[])
{
Vehicle obj=new
Vehicle();[Link]();
}
}
Output:
/[Link]: error: cannot assign a value to final variable speedlimit
speedlimit=400;
^
1 error
 Blank final variable
A final variable that is not initialized at the time of declaration is known as blank
final variable. We must initialize the blank final variable in constructor of the class
otherwise it will throw a compilation error.
Sample Code:
public class Vehicle
{
final int speedlimit; //blank final variable
void run()

}
public static void main(String args[])
{
Vehicle obj=new
Vehicle();[Link]();
}
}
Output:
/[Link]: error: variable speedlimit not initialized in the default
constructor final int speedlimit; //blank final variable
^
1 error

Java Final Method

A Java method with the final keyword is called a final method and it cannot be overridden in
the subclass.
In general, final methods are faster than non-final methods because they are not required
to be resolved during run-time and they are bonded at compile time.
Sample Code:
class XYZ
{
final void demo()
{
[Link](“XYZ Class Method”);
}
}
public class ABC extends XYZ
{
void demo()
{
 [Link](“ABC Class Method”);
}
public static void main(String args[])
{
ABC obj= new
ABC(); [Link]();
}
}
Output:
/[Link]: error: demo() in ABC cannot override demo() in
XYZ void demo()
^
overridden method is final
1 error
The following code will run fine as the final method demo() is not overridden. This
shows that final methods are inherited but they cannot be overridden.
Sample Code:
class XYZ
{
final void demo()
{
[Link](“XYZ Class Method”);
}
}
public class ABC extends XYZ
{
public static void main(String args[])
{
ABC obj= new
ABC(); [Link]();
}
}
Output:
XYZ Class Method

Points to be remembered while using final methods:

• Private methods of the superclass are automatically considered to be final.
• Since the compiler knows that final methods cannot be overridden by a subclass,
 so these methods can sometimes provide performance enhancement by removing
calls to final methods and replacing them with the expanded code of their
declarations at each method call location.
• Methods made inline should be small and contain only few lines of code. If it
grows in size, the execution time benefits become a very costly affair.
• A final’s method declaration can never change, so all subclasses use the same
method implementation and call to one can be resolved at compile time.
This is known as static binding
.

Java Final Class

• Final class is a class that cannot be extended i.e. it cannot be inherited.
• A final class can be a subclass but not a superclass.
• Declaring a class as final implicitly declares all of its methods as final.
• It is illegal to declare a class as both abstract and final since an abstract class is
incompleteby itself and relies upon its subclasses to provide complete
implementations.
• Several classes in Java are final e.g. String, Integer, and other wrapper classes.
• The final keyword can be placed either before or after the access specifier.
Syntax:

final public class A public final class A

{ {
OR
//code //code

} }

Sample Code:
final class XYZ
{
}

public class ABC extends XYZ

{
void demo()
{
[Link](“My Method”);
}
public static void main(String args[])
{
ABC obj= new
ABC(); [Link]();
}
 }
Output:
/[Link]: error: cannot inherit from final
XYZ public class ABC extends XYZ
^
1 error

Important points on final in Java

• Final keyword can be applied to a member variable, local variable, method or
class in Java.
• Final member variable must be initialized at the time of declaration or inside
the constructor, failure to do so will result in compilation error.
• We cannot reassign value to a final variable in Java.
• The local final variable must be initialized during declaration.
• A final method cannot be overridden in Java.
• A final class cannot be inheritable in Java.
• Final is a different than finally keyword which is used to Exception handling in
Java.
• Final should not be confused with finalize() method which is declared in Object class
and called before an object is a garbage collected by JVM.
• All variable declared inside Java interface are implicitly final.
• Final and abstract are two opposite keyword and a final class cannot be abstract in
Java.
• Final methods are bonded during compile time also called static binding.
• Final variables which are not initialized during declaration are called blank final
variable and must be initialized in all constructor either explicitly or by calling
this(). Failure to do so compiler will complain as “final variable (name) might not be
initialized”.
• Making a class, method or variable final in Java helps to improve performance because
JVM gets an opportunity to make assumption and optimization.
 INTERFACES
An interface is a reference type in Java. It is similar to class. It is a collection of
abstract methods. Along with abstract methods, an interface may also contain constants,
default meth- ods, static methods, and nested types. Method bodies exist only for default
methods and static methods.
An interface is similar to a class in the following ways:
• An interface can contain any number of methods.
• An interface is written in a file with a .java extension, with the name of the
interface matching the name of the file.
• The byte code of an interface appears in a .class file.
• Interfaces appear in packages, and their corresponding bytecode file must be
in a directory structure that matches the package name.
Uses of interface:
• Since java does not support multiple inheritance in case of class, it can be
achieved by using interface.
• It is also used to achieve loose coupling.
• Interfaces are used to implement abstraction.
Defining an Interface
An interface is defined much like a class.

Syntax:
accessspecifier interface interfacename
{
return-type method-name1(parameter-
list); return-type method-
name2(parameter-list); type final-
varname1 = value;
type final-varname2 = value;
// ...
return-type method-nameN(parameter-
list); type final-varnameN = value;
}
When no access specifier is included, then default access results, and the interface is
only available to other members of the package in which it is declared. When it is
declared as pub-lic, the interface can be used by any other code.
• The java file must have the same name as the interface.
• The methods that are declared have no bodies. They end with a semicolon after
the parameter list. They are abstract methods; there can be no default
implementation of any method specified within an interface.
• Each class that includes an interface must implement all of the methods.
• Variables can be declared inside of interface declarations. They are implicitly
final and static, meaning they cannot be changed by the implementing class.
 They must also be initialized.
• All methods and variables are implicitly public.
Sample Code:
The following code declares a simple interface Animal that contains two methods
called eat() and travel() that take no parameter.
/* File name : [Link]
*/interface Animal {
public void eat();
public void travel();
}

Implementing an Interface
Once an interface has been defined, one or more classes can implement that
interface. To implement an interface, the ‘implements’ clause is included in a class definition
and then the methods defined by the interface are created.
Syntax:
class classname [extends superclass] [implements interface [,interface...]]
{
// class-body
}
Properties of java interface
If a class implements more than one interface, the interfaces are separated with
a
comma.
If a class implements two interfaces that declare the same method, then the
same method will be used by clients of either interface.
The methods that implement an interface must be declared public.
Rules The type signature of the implementing method must match exactly the type
signature specified in the interface definition.

A class can implement more than one interface at a time.

A class can extend only one class, but can implement many interfaces.
An interface can extend another interface, in a similar way as a class can
extend
another class.
Sample Code 1:
The following code implements an interface Animal shown earlier.
/* File name : [Link] */
public class Mammal implements Animal
{
public void eat()
{
[Link](“Mammal eats”);
}
public void travel()

{
[Link](“Mammal travels”);
}
public int noOfLegs()
{
return 0;
}
public static void main(String args[])
{
Mammal m = new
Mammal(); [Link]();
[Link]();
}
}
Output:
Mammal eats
Mammal travels
It is both permissible and common for classes that implement interfaces to define ad-
ditional members of their own. In the above code, Mammal class defines additional
method called noOfLegs().
Sample Code 2:
The following code initially defines an interface ‘Sample’ with two members. This
inter-face is implemented by a class named ‘testClass’.
import [Link].*;
// A simple
interface interface
Sample
{
 final String name =
“Shree”; void display();
}
// A class that implements interface.
public class testClass implements
Sample
{
public void display()
{
[Link](“Welcome”);
}
public static void main (String[] args)
{
testClass t = new
testClass(); [Link]();
[Link](name);
}
}
Output:
Welcom
e Shree
Sample Code 3:
In this example, Drawable interface has only one method. Its implementation is
provided by Rectangle and Circle classes.
interface Drawable
{
void draw();
}
class Rectangle implements Drawable
{
public void draw()
{
[Link](“Drawing rectangle”);
}

}
class Circle implements Drawable
{
public void draw()
 {
[Link](“Drawing circle”);
}
}
public class TestInterface
{
public static void main(String args[])
{
Drawable d=new
Circle();[Link]();
}
}
Output:
Drawing circle
Nested Interface
An interface can be declared as a member of a class or another interface. Such an
inter- face is called a member interface or a nested interface. A nested interface can be
declared as public, private, or protected.
Sample Code:
interface MyInterfaceA
{
void display();
interface
MyInterfaceB
{
void myMethod();
}

}
public class NestedInterfaceDemo1 implements [Link]
{
public void myMethod()
{
[Link](“Nested interface method”);
}
public static void main(String args[])
{
[Link] obj= new
NestedInterfaceDemo1(); [Link]();
 }
}
Output:
Nested interface method
Differences between classes and interfaces
Both classes and Interfaces are used to create new reference types. A class is a
collection of fields and methods that operate on fields. A class creates reference types
and these refer- ence types are used to create objects. A class has a signature and a body.
The syntax of class declaration is shown below:
class class_Name extends superclass implements interface_1,….interface_n
// class signature
{
//body of class.
}
Signature of a class has class’s name and information that tells whether the class has
in- herited another class. The body of a class has fields and methods that operate on
those fields. A Class is created using a keyword class.
When a class is instantiated, each object created contains a copy of fields and
methods with them. The fields and members declared inside a class can be static or
nonstatic. Static members value is constant for each object whereas, the non-static
members are initialized by each object differently according to its requirement.

Members of a class have access specifiers that decide the visibility and accessibility
of the members to the user or to the subclasses. The access specifiers are public, private and
pro- tected. A class can be inherited by another class using the access specifier which
will decide the visibility of members of a superclass (inherited class) in a subclass
(inheriting class).
An interface has fully abstract methods (methods with nobody). An interface is
syntacti- cally similar to the class but there is a major difference between class and
interface that is a class can be instantiated, but an interface can never be instantiated.
An interface is used to create the reference types. The importance of an interface in
Java is that, a class can inherit only a single class. To circumvent this restriction, the
designers of Java introduced a concept of interface. An interface declaration is
syntactically similar to a class, but there is no field declaration in interface and the
methods inside an interface do not have any implementation. An interface is declared
using a keyword interface.

Aspect for
Class Interface
compariso
n
An interface can never be
A class is instantiated to
Basic instanti- ated as the methods are
create
unable to perform any action on
objects.
invoking.
Keyword class Interface
Access The members of a class can The members of an interface
specifier be private, public or protected. are always public.
 The methods of a class are The methods in an interface
Methods
defined to perform a specific are purely abstract.
action.
A class can implement any An interface can extend
inheritance num- ber of interfaces and can multiple interfaces but cannot
extend only one class. implement any interface.
Inheritance
extends implements
keyword
An interface can never have a
A class can have constructors
Constructor constructor as there is hardly
to
any variable to initialize.
initialize the variables.
class class_Name Interface interface_Name
{ {
//fields Type var_name=value;
Declaratio
//Methods Type method1(parameter-
n Syntax
} list); Type
method2(parameter-list);
..
}
The following example shows that a class that implements one interface:
public interface interface_example
{
public void method1();
public string method2();
}
public class class_name implements interface_example
{
public void method1()
{
..
}
public string method2()
{
…
}
}
Inheritance between concrete (non-abstract) and abstract classes use extends keyword.
It is possible to extend only one class to another. Java does not support multiple
inheri- tance. However, multilevel inheritance i.e., any number of classes in a ladder is
possible. For example, in the following code class C extends the class B, where the class
B extends class A.
class A {}
class B extends A {
} class C extends B
{}
Inheritance between classes (including abstract classes) and interfaces, use
implements keyword.
To support multiple inheritance, it uses interfaces. So after implements keyword,
there can be any number of interfaces. For example, in the following code, class B
extends only one class A and two interfaces I1 and I2.
interface I1
{} interface I2
{} class A
class B extends A implements I1, I2
{
}
Inheritance between two interfaces, is possible with the use of extends keyword only.
For example, in the following code, interface I2 extends the interface I1.
interface I1 { }
interface I2 extends I1{ }
 OBJECT CLONING
Object cloning refers to creation of exact copy of an object. It creates a new instance
of the class of current object and initializes all its fields with exactly the contents of the
corre- sponding fields of this object. In Java, there is no operator to create copy of an
object. Unlike C++, in Java, if we use assignment operator then it will create a copy of
reference variable and not the object. This can be explained by taking an example.
Following program demon-strates the same.
// Java program to demonstrate that assignment operator creates a new reference to
same object.
import [Link].*;

class sample
{
int a;
float b;
sample(
)
{
a = 10;
b = 20;
}
}
class Mainclass
{
public static void main(String[] args)
{
sample ob1 = new sample();
[Link](ob1.a + “ “ +
ob1.b);sample ob2 = ob1;
ob2.a = 100;
[Link](ob1.a+”
“+ob1.b);
[Link](ob2.a+”
“+ob2.b);
}
}
Output:
10 20.0
100 20.0
100 20.0
Creating a copy using clone() method
The class whose object’s copy is to be made must have a public clone method in it or
in one of its parent class.
• Every class that implements clone() should call [Link]() to obtain the
cloned
object reference.
• The class must also implement [Link] interface whose object
clone we want to create otherwise it will throw CloneNotSupportedException
when clone method is called on that class’s object.
• Syntax:
• protected Object clone() throws CloneNotSupportedException
import
[Link]; class
sample1
{
int a, b;
}
class sample2 implements Cloneable
{
int c;
int
d;
sample1 s = new sample1();
public Object clone() throws CloneNotSupportedException
{
return [Link]();
}
}
public class Mainclass
{
public static void main(String args[]) throws CloneNotSupportedException
{
sample2 ob1 = new
sample2(); ob1.c = 10;
ob1.d = 20;
ob1.s.a = 30;
ob1.s.b = 40;
sample2 ob2 = (sample2)[Link]();
ob2.d = 100; //Change in primitive type of ob2 will not be reflected in ob1 field
 ob2.s.a = 300; //Change in object type field will be reflected in both ob2
and
ob1(shallow copy)
[Link](ob1.c + “ “ + ob1.d + “ “ +ob1.s.a + “ “ +
ob1.s.b);[Link](ob2.c + “ “ + ob2.d + “ “ +ob2.s.a + “ “
+ ob2.s.b);
}
}
Types of Object cloning
1. Deep Copy
2. Shallow Copy

Shallow copy
Shallow copy is method of copying an object. It is the default in cloning. In this
method the fields of an old object ob1 are copied to the new object ob2. While copying the
object type field the reference is copied to ob2 i.e. object ob2 will point to same location
as pointed out by ob1. If the field value is a primitive type it copies the value of the
primitive type. So, any changes made in referenced objects will be reflected in other
object.
Note:
Shallow copies are cheap and simple to make.
Deep Copy
To create a deep copy of object ob1 and place it in a new object ob2 then new copy
of any referenced objects fields are created and these references are placed in object ob2.
This means any changes made in referenced object fields in object ob1 or ob2 will be
reflected only in that object and not in the other. A deep copy copies all fields, and
makes copies of dynamically allocated memory pointed to by the fields. A deep copy
occurs when an object is copied along with the objects to which it refers.

//Java program for deep copy using

clone() import [Link];
class Test
{
int a, b;
}
class Test2 implements Cloneable
{
int c, d;
Test ob1 = new Test();
public Object clone() throws CloneNotSupportedException
{
// Assign the shallow copy to new refernce variable t
 Test2 t1 = (Test2)[Link]();
t1.ob1 = new Test();
// Create a new object for the field c
// and assign it to shallow copy obtained,
// to make it a deep
copy return t1;
}
}
public class Main
{
public static void main(String args[]) throws CloneNotSupportedException
{
Test2 t2 = new Test2();
t2.c = 10;
t2.d = 20;
t2.ob1.a = 30;
t2.ob1.b = 40;
Test2 t3 =
(Test2)[Link](); t3.c =
100;
t3.ob1.a = 300;
[Link] (t2.c + “ “ + t2.d + “ “ + t2.ob1.a + “ “ +
t2.ob1.b);[Link] (t3.c + “ “ + t3.d + “ “ + t3.ob1.a + “ “
}
+ t3.ob1.b);
Outpu
t }
10 20 30 40
100 20 300 0
Advantages of clone method:
• If we use assignment operator to assign an object reference to another reference
variable then it will point to same address location of the old object and no new
copy of the object will be created. Due to this any changes in reference variable
will be reflected in original object.
• If we use copy constructor, then we have to copy all of the data over explicitly
i.e. we have to reassign all the fields of the class in constructor explicitly. But in
clone method this work of creating a new copy is done by the method itself. So
to avoid extra processing we use object cloning.