JAVA UNIT-1 Notes

JAVA PROGRAMMING
R20 REGULATION (ECE)
APRIL 1, 2021
MARRI LAXMAN REDDY INSTITUTE OF ENGINEERING AND TECHNOLOGY
DUNDIGAL, HYDERABAD
R20 B. TECH ECE II YEAR
Java Programming
B.Tech. II Year I Semester LTPC

2002
Prerequisites: Programming for Problem Solving.
Course Objectives:
1. Introduces Object Oriented Programming Concepts Using The Java Language

2. Introduces The Principles Of Inheritance And Polymorphism; And Demonstrates How They
Relate To The Design Of Abstract Classes.
3. Introduces The Implementation Of Packages And Interfaces.
4. Introduces Exception Handling, Event Handling and Multithreading.
5. Introduces The Design Of Graphical User Interface Using Applets And Swings.
Course Outcomes:
1. Develop Applications for Range of Problems Using Object-Oriented Programming Techniques

2. Design Simple Graphical User Interface Applications.
UNIT - I:
Object Oriented Thinking and Java Basics: Need for OOP Paradigm, Summary of OOP Concepts,
Coping with Complexity, Abstraction Mechanisms, A Way of Viewing World – Agents, Responsibility,
Messages, Methods, History of Java, Java Buzzwords, Data Types, Variables, Scope and Life Time of
Variables, Arrays, Operators, Expressions, Control Statements, Type Conversion and Casting, Simple
Java Program, Concepts of Classes, Objects, Constructors, Methods, Access Control, This Keyword,
Garbage Collection, Overloading Methods and Constructors, Method Binding, Inheritance, Overriding
and Exceptions, Parameter Passing, Recursion, Nested and Inner Classes, Exploring String Class.
UNIT - II:
Inheritance, Packages and Interfaces: Hierarchical Abstractions, Base Class Object, Subclass,
Subtype, Substitutability, Forms of Inheritance- Specialization, Specification, Construction, Extension,
Limitation, Combination, Benefits of Inheritance, Costs of Inheritance. Member Access Rules, Super
Uses, Using Final with Inheritance, Polymorphism- Method Overriding, Abstract Classes, The Object
Class.
Defining, Creating and Accessing a Package, Understanding Classpath, Importing Packages,
Differences between Classes and Interfaces, Defining an Interface, Implementing Interface, Applying
Interfaces, Variables in Interface and Extending Interfaces, Exploring Java.IO.
UNIT - III:
Exception Handling and Multithreading: Concepts of Exception Handling, Benefits of Exception
Handling, Termination or Resumptive Models, Exception Hierarchy, Usage of Try, Catch, Throw,
Throws and Finally, Built in Exceptions, Creating Own Exception Sub Classes.
String Handling, Exploring Java.Util, Differences between Multi-Threading and Multitasking, Thread Life
Cycle, Creating Threads, Thread Priorities, Synchronizing Threads, Interthread Communication,
Thread Groups, Daemon Threads.
Enumerations, Autoboxing, Annotations, Generics.
UNIT - IV:
Event Handling: Events, Event Sources, Event Classes, Event Listeners, Delegation Event Model,
Handling Mouse and Keyboard Events, Adapter Classes.
R18 B.TECH ECE III YEAR
The AWT Class Hierarchy, User Interface Components- Labels, Button, Canvas, Scrollbars, Text
Components, Check Box, Check Box Groups, Choices, Lists Panels – Scrollpane, Dialogs, Menubar,
Graphics, Layout Manager – Layout Manager Types – Border, Grid, Flow, Card and Grid Bag.
UNIT - V:
Applets: Concepts f Applets, Differences between Applets and Applications, Life Cycle of an Applet,
Types of Applets, Creating Applets, Passing Parameters to Applets.
Swing: Introduction, Limitations of AWT, MVC Architecture, Components, Containers, Exploring
Swing- Japplet, Jframe and Jcomponent, Icons and Labels, Text Fields, Buttons – The Jbutton Class,
Check Boxes, Radio Buttons, Combo Boxes, Tabbed Panes, Scroll Panes, Trees, and Tables.
TEXT BOOKS:
1. Java the Complete Reference, 7th Edition, Herbert Schildt, TMH.

2. Understanding OOP with Java Updated Edition, T. Budd, Pearson Education.
REFERENCES:
1. An Introduction to Programming and OO Design using Java, J. Nino and F.A. Hosch, John
Wiley & Sons.
2. An Introduction to OOP, Third Edition, T. Budd, Pearson Education.
3. Introduction to Java Programming, Y. Daniel Liang, Pearson Education.
4. An Introduction to Java Programming and Object-Oriented Application Development, R.A.
Johnson- Thomson.
5. Core Java 2, Vol 1, Fundamentals, Cay. S. Horstmann and Gary Cornell, Eighth Edition,
Pearson Education.
6. Core Java 2, Vol 2, Advanced Features, Cay. S. Horstmann and Gary Cornell, eighth Edition,
Pearson Education
NEED FOR OOP PARADIGM:
Object-oriented programming (OOP) is a programming paradigm based upon objects (having both
data and methods) that aims to incorporate the advantages of modularity and reusability. Objects,
which are usually instances of classes, are used to interact with one another to design applications
and computer programs.
The important features of object–oriented programming are −
 Bottom–up approach in program design

 Programs organized around objects, grouped in classes
 Focus on data with methods to operate upon object’s data
 Interaction between objects through functions
 Reusability of design through creation of new classes by adding features to existing classes
Some examples of object-oriented programming languages are C++, Java, Smalltalk, Delphi, C#,
Perl, Python, Ruby, and PHP.
Grady Booch has defined object–oriented programming as “a method of implementation in which
programs are organized as cooperative collections of objects, each of which represents an instance
of some class, and whose classes are all members of a hierarchy of classes united via inheritance
relationships”.
SUMMARY OF OOP CONCEPTS
Object means a real-world entity such as a pen, chair, table, computer, watch, etc. Object-
Oriented Programming is a methodology or paradigm to design a program using classes and
objects. It simplifies software development and maintenance by providing some concepts:
o Object
o Class
o Inheritance
o Polymorphism
o Abstraction
o Encapsulation
Object
Any entity that has state and behavior is known as an object. For example, a chair, pen, table,
keyboard, bike, etc. It can be physical or logical.
An Object can be defined as an instance of a class. An object contains an address and takes up
some space in memory. Objects can communicate without knowing the details of each other's data
or code. The only necessary thing is the type of message accepted and the type of response returned
by the objects.
Example: A dog is an object because it has states like color, name, breed, etc. as well as behaviors
like wagging the tail, barking, eating, etc.
Class- Collection of objects is called class. It is a logical entity.
A class can also be defined as a blueprint from which you can create an individual object. Class
doesn't consume any space.
Inheritance
When one object acquires all the properties and behaviors of a parent object, it is known as
inheritance. It provides code reusability. It is used to achieve runtime polymorphism.
Polymorphism
If one task is performed in different ways, it is known as polymorphism. For example: to convince
the customer differently, to draw something, for example, shape, triangle, rectangle, etc.
In Java, we use method overloading and method overriding to achieve polymorphism.
Another example can be to speak something; for example, a cat speaks meow, dog barks woof, etc.
Abstraction - in nothing but only declaration but not implementation
Hiding internal details and showing functionality is known as abstraction. For example phone call,
we don't know the internal processing.
In Java, we use abstract class and interface to achieve abstraction.
Encapsulation
Binding (or wrapping) code and data together into a single unit are known as encapsulation. For
example, a capsule, it is wrapped with different medicines.
A java class is the example of encapsulation. Java bean is the fully encapsulated class because all
the data members are private here.
Procedure oriented approach:
The Languages like C, Fortran, Pascal, etc., are called procedure oriented programming
languages since in these languages, a programmer uses procedures or functions to perform a
task. When the programmer wants to write a program, he will first divide the task into several
subtasks, each of which expressed as a function. So, C program generally contains several
functions which are called and controlled from main() function. This approach is called
procedure oriented approach.
Fig: Procedure oriented approach
Object oriented approach:

On the other hand, languages like C++ and Java use classes and objects in their
programs and are called Object Oriented Programming languages. A class is a module which
itself contains data and methods (functions) to achieve the task. The main task is divided into
several modules, and these are represented as, classes. Each class can perform some tasks for
which several methods are written in a class. This approach is called Object oriented
approach.
Fig: Object oriented approach
Problems in Procedural oriented approach:

 There is NO Reusability.
 The lines of code are very high.
 Security is very less.
 Don’t have any access specifier.
Difference between POP and OOP:
Procedure Oriented Programming Object Oriented Programming
In POP, program is divided into small partsIn OOP, program is divided into parts
called functions. called objects.
In POP, Importance is not given to data butIn OOP, Importance is given to the data
to functions as well as sequence of actionsrather than procedures or functions
to be done. because it works as a real world.
POP follows Top Down approach. OOP follows Bottom Up approach.
OOP has access specifiers named Public,
POP does not have any access specifier.
Private, Protected, etc.
In OOP, objects can move and
In POP, Data can move freely from
communicate with each other through
function to function in the system.
member functions.
To add new data and function in POP is OOP provides an easy way to add new
not so easy. data and function.
In OOP, data cannot move easily from
In POP, Most function uses Global data for
function to function, it can be kept public
sharing that can be accessed freely from
or private so we can control the access of
function to function in the system.
data.
POP does not have any proper way for OOP provides Data Hiding so
hiding data so it is less secure. provides more security.
In OOP, overloading is possible in the
In POP, Overloading is not possible. form of Function Overloading and
Operator Overloading.
Examples of POP are: C, VB, Examples of OOP are: C++, JAVA,
FORTRAN, Pascal. VB.NET, C#.NET.
Principles of OOP:
The key ideas of the object oriented approach are:
 Class / Objects
 Abstraction
 Encapsulation
 Inheritance
 Polymorphism
Class / Objects
Entire OOP methodology has been derived from a single root concept, called 'object'.
An object is anything that really exists in the world and can be distinguished from others.
This definition specifies that everything in this world is an object. For example, a table, a
ball, a car, a dog, a person, etc., everything will come under objects.
Every object has properties and can perform certain actions. For example, let us take a
person whose name is 'Raju'. Raju is an object because he exists physically. He has properties
like name, age, gender, etc. These properties can be represented by variables in our
programming.
String name;
int age;
char gender;
Similarly, Raju can perform some actions like talking, walking, eating and sleeping.
We may not write code for such actions in programming. But, we can consider calculations
and processing of data as actions. These actions are performed by methods (functions), So an
object contains variables and methods.
Fig: Person class and Raju Object

From the above diagram we can understand that Person is class and Raju is an object
i.e., instance of class.
Note: A class is ｾmodel for creating objects and does not exist physically. An object is
anything that exists physically. Both the class and objects contain variables and methods.
Abstraction
There may be a lot of data, a class contains and the user does not need the entire data.
The user requires only some part of the available data. In this case, we can hide the
unnecessary data from the user and expose only that data that is of interest to the user. This is
called abstraction.
A bank clerk should see the customer details like account number, name and balance
amount in the account. He should not be entitled to see the sensitive data like the staff
salaries, profit or loss of the bank amount paid by the bank and loans amount to be recovered
etc,. So such data can abstract from the clerk's view. Whereas the bank manager is interested
to know this data, it will be provided to the manager.
Encapsulation
Encapsulation in Java is a mechanism of wrapping the data (variables) and code
acting on the data (methods) together as a single unit. In encapsulation, the variables of a
class will be hidden from other classes, and can be accessed only through the methods of
their current class. Therefore, it is also known as data hiding.
To achieve encapsulation in Java −
 Declare the variables of a class as private.
 Provide public setter and getter methods to modify and view the variables values.
Inheritance
It creates new classes from existing classes, so that the new classes will acquire all the
features of the existing classes is called Inheritance. A good example for Inheritance in nature
is parents producing the children and children inheriting the qualities of the parents.
There are three advantages inheritance. First, we can create more useful classes
needed by the application (software). Next, the process of creating the new classes is very
easy, since they are built upon already existing classes. The last, but very important
advantage is managing the code becomes easy, since the programmer creates several classes
in a hierarchical manner, and segregates the code into several modules.
Polymorphism
The word polymorphism came from two Greek words 'poly' meaning 'many' and
'morphos' meaning 'forms'. Thus, polymorphism represents the· ability to assume several
different forms. In programming, we can use a single variable to refer to objects of different
types and thus using that variable we can call the methods of the different objects. Thus
method call can perform different tasks depending on the type of object.
Polymorphism provides flexibility in writing programs in such a way that the
programmer uses same method call to perform different operations depending on the
requirement.
Application of OOP:
The promising areas includes the followings,
1. Real Time Systems Design
2. Simulation and Modeling System
3. Object Oriented Database
4. Object Oriented Distributed Database
5. Client-Server System
6. Hypertext, Hypermedia
7. Neural Networking and Parallel Programming
8. Decision Support and Office Automation Systems
9. CIM/CAD/CAM Systems
10. AI and Expert Systems
Coping with complexity:
When programs are larger then complex is more programmers found it difficult to remember all the
information they needed to know in order to develop or debug their software.
Non-Linear behavior of complexity:
When projects become larger, a task that can be solved by a programmer in 2 months can’t be
accomplished by 2 programmers working for one month. The reason for this non-linear behavior is
complexity. The inter connections between the software components is complicated. The OOP
designers illustrated this with a memorable phrase “The bearing of a child takes nine months, no
matter how many women are assigned to the task”
JAVA PROGRAMMING UNIT-1
ABSTRACTION MECHANISM
Abstraction is a process of hiding the implementation details and showing only functionality to
the user.
Another way, it shows only essential things to the user and hides the internal details, for example,
sending SMS where you type the text and send the message. You don't know the internal
processing about the message delivery.
Abstraction lets you focus on what the object does instead of how it does it.
Ways to achieve Abstraction
There are two ways to achieve abstraction in java
1. Abstract class (0 to 100%)

2. Interface (100%)
Abstract class in Java
A class which is declared as abstract is known as an abstract class. It can have abstract and non-
abstract methods. It needs to be extended and its method implemented. It cannot be instantiated.
Points to Remember
o An abstract class must be declared with an abstract keyword.
o It can have abstract and non-abstract methods.
o It cannot be instantiated.
o It can have constructors and static methods also.
o It can have final methods which will force the subclass not to change the body of the
method.
Understanding the real scenario of Abstract class
In this example, Shape is the abstract class, and its implementation is provided by the Rectangle
and Circle classes.
Mostly, we don't know about the implementation class (which is hidden to the end user), and an
object of the implementation class is provided by the factory method.
A factory method is a method that returns the instance of the class. We will learn about the factory
method later.
In this example, if you create the instance of Rectangle class, draw() method of Rectangle class
will be invoked.
Page 1
File: TestAbstraction1.java
1. abstract class Shape{

2. abstract void draw();
3. }
4. //In real scenario, implementation is provided by others i.e. unknown by end user
5. class Rectangle extends Shape{
6. void draw(){System.out.println("drawing rectangle");}
7. }
8. class Circle1 extends Shape{
9. void draw(){System.out.println("drawing circle");}
10. }
11. //In real scenario, method is called by programmer or user
12. class TestAbstraction1{
13. public static void main(String args[]){
14. Shape s=new Circle1();//In a real scenario, object is provided through method, e.g., getShap
e() method
15. s.draw();
16. }
17. }
Page 2
A Way of viewing World- Agents

• The word agent has found its way into a number of technologies. It has been applied to
aspects of artificial intelligence research and to constructs developed for improving the
experience provided by collaborative online social environments (MUDS, MOOs, and the
like). It is a branch on the tree of distributed computing. There are agent development
toolkits and agent programming languages.
• The Agent Identity class defines agent identity. An instance of this class uniquely
identifies an agent. Agents use this information to identify the agents with whom they are
interested in collaborating.
• The Agent Host class defines the agent host. An instance of this class keeps track of
every agent executing in the system. It works with other hosts in order to transfer agents.
• The Agent class defines the agent. An instance of this class exists for each agent
executing on a given agent host.
• OOP uses an approach of treating a real world agent as an object.
• Object-oriented programming organizes a program around its data (that is, objects) and a
set of well-defined interfaces to that data.
• An object-oriented program can be characterized as data controlling access to code by
switching the controlling entity to data.
Responsibility
• In object-oriented design, the chain-of-responsibility pattern is a design pattern consisting of
a source of command objects and a series of processing objects..
• Each processing object contains logic that defines the types of command objects that it can
handle; the rest are passed to the next processing object in the chain. A mechanism also
exists for adding new processing objects to the end of this chain.
Primary motivation is the need for a platform-independent (that is, architecture- neutral)
language that could be used to create software to be embedded in various consumer
electronic devices, such as microwave ovens and remote controls.
• Objects with clear responsibilities
• Each class should have a clear responsibility.
• If you can't state the purpose of a class in a single, clear sentence, then perhaps your class
structure needs some thought.
• In object-oriented programming, the single responsibility principle states that every
class should have a single responsibility, and that responsibility should be entirely
encapsulated by the class. All its services should be narrowly aligned with that
responsibility.
Messages
• Message implements the Part interface. Message contains a set of attributes and a
"content".
• Message objects are obtained either from a Folder or by constructing a new Message
object of the appropriate subclass. Messages that have been received are normally
retrieved from a folder named "INBOX".
• A Message object obtained from a folder is just a lightweight reference to the actual
message. The Message is 'lazily' filled up (on demand) when each item is requested from
the message.
• Note that certain folder implementations may return Message objects that are pre-filled
with certain user-specified items. To send a message, an appropriate subclass of Message
(e.g., Mime Message) is instantiated, the attributes and content are filled in, and the
message is sent using the Transport. Send method.
Page 3
• We all like to use programs that let us know what's going on. Programs that keep us
informed often do so by displaying status and error messages.
• These messages need to be translated so they can be understood by end users around the
world.
• The Section discusses translatable text messages. Usually, you're done after you move a
message String into a Resource Bundle.
• If you've embedded variable data in a message, you'll have to take some extra steps to
prepare it for translation.
Methods
• The only required elements of a method declaration are the method's return type, name,
a pair of parentheses, (), and a body between braces, {}.
• Two of the components of a method declaration comprise the method signature—the
method's name and the parameter types.
• More generally, method declarations have six components, in order:
• Modifiers—such as public, private, and others you will learn about later.
The return type—the data type of the value returned by the method, or void if the method
does not return a value.
• The method name—the rules for field names apply to method names as well, but the
convention is a little different.
• The parameter list in parenthesis—a comma-delimited list of input parameters, preceded
by their data types, enclosed by parentheses, (). If there are no parameters, you must use
empty parentheses.
• The method body, enclosed between braces—the method's code, including the
declaration of local variables, goes here.
Page 4
History of Java:
Before starting to learn Java, let us plunge into its history and see how the language
originated. In 1990, Sun Microsystems Inc. (US) was conceived a project to develop software
for consumer electronic devices that could be controlled by a remote. This project was called
Stealth Project but later its name was changed to Green Project.
In January of 1991, Bill Joy, James Gosling, Mike Sheradin, Patrick Naughton, and
several others met in Aspen, Colorado to discuss this' project. Mike Sheradin was to focus on
business development; Patrick Naughton was to begin work on the graphics system; and
James Gosling was to identify the proper programming language for the project. Gosling
thought C and C++ could be used to develop the project.
But the problem he faced with them is that they were system dependent languages and
hence could not be used on various processors, which the electronic devices might use. So he
started developing a new language, which was completely system independent. This language
was initially called Oak. Since this name was registered by some other company, later it was
changed to Java.
Why the name Java? James Gosling and his team members were consuming a lot of
tea while developing this language. They felt that they were able to develop a better language
because of the good quality tea they had consumed. So the tea also had its own role in
developing this language and hence, they fixed the name for the language as Java. Thus, the
symbol for Java is tea cup and saucer.
 James Gosling was born on May 19, 1955.

 James Gosling received a Bachelor of Science from the
University of Calgary and his M.A. and Ph.D. from Carnegie
Mellon University. He built a multi-processor version of Unix for
a 16-way computer system while at Carnegie Mellon University,
before joining Sun Microsystems.
By September of 1994, Naughton and Jonathan Payne started writing WebRunner-a

Java-based Web browser, which was later renamed as HotJava. By October 1994, HotJava
was stable and was demonstrated to Sun executives. HotJava was the fIrst browser, having
the capabilities of executing applets, which are programs designed to run dynamically on
Internet. This time, Java's potential in the context of the World Wide Web was recognized.
Sun formally announced Java and HotJava at SunWorld conference in 1995. Soon
after, Netscape Inc. announced that it would incorporate Java support in its browser Netscape
Navigator. Later, Microsoft also announced that they would support Java in their Internet
Explorer Web browser, further solidifying Java's role in the World Wide Web. On January
23rd 1996, JDK 1.0 version was released. Today more than 4 million developers use Java
and more than 1.7 5 billion devices run Java. Thus, Java pervaded the world.
Features of Java:
 Simple: Java is a simple programming language. Rather than saying that this is the
feature of Java, we can say that this is the design aim of Java. JavaSoft (the team who
developed Java is called with this name) people maintained the same syntax of C and
C++ in Java, so that a programmer who knows C or C++ will find Java already familiar.
 Object-oriented: Java is an object oriented programming language. This means Java
programs use objects and classes. What is an object? An object is anything that really
exists in the world and can be distinguished from others.
Page 5
 Distributed: Information is distributed on various computers on a network. Using Java,

we can write programs, which capture information and distribute it to the clients. This is
possible because Java can handle the protocols like TCP/IP and UDP.
 Robust: Robust means strong. Java programs are strong and they don't crash easily like
a C or C++ program. There are two reasons -for this. Firstly, Java has got excellent
inbuilt exception handling features.
 Secure: Security problems like eavesdropping, tampering, impersonation, and virus
threats can be eliminated or minimized by using Java on Internet.
 System independence: Java's byte code is not machine dependent. It can be run on any
machine with any processor and any operating system.
 Portability: If a program yields the same result on every machine, then that program is
called portable. Java programs are portable. This is the result of Java's System
independence nature.
 Interpreted: Java programs are compiled to generate the byte code. This byte code can
be downloaded and interpreted by the interpreter in JVM. If we take any other
language, only an interpreter or a compiler is used to execute the programs. But in Java,
we use .both compiler and interpreter for the execution.
 High Performance: The-problem with interpreter inside the JVM is that it is slow.
Because of this, Java programs used to run slow. To overcome this problem, along with
the interpreter, JavaSoft people have introduced JIT (Just In Time) compiler, which
enhances the speed of execution. So now in JVM, both interpreter and JIT compiler
work together to run the program.
 Multithreaded: A thread represents an individual process to execute a group of
statements. JVM uses several threads to execute different blocks of code. Creating
multiple threads is called 'multithreaded'.
 Scalability: Java platform can be implemented on a wide range of computers with
varying levels of resources-from embedded devices to mainframe computers. This is
possible because Java is compact and platform independent.
 Dynamic: Before the development of Java, only static text used to be displayed-in the
browser. But when James Gosling demonstrated an animated atomic molecule where
the rays are moving and stretching, the viewers are dumbstruck. This animation was
done using an applet program, which are the dynamically interacting programs on
Internet.
Java Virtual Machine:
Fig: Components in JVM Architecture
Page 6
First of all, the .java program is converted into a .class file consisting of byte code
instructions by the java compiler. Remember, this java compiler is outside the JVM: Now this
.class file is given to the JVM. In JVM, there is a module (or program) called class loader
sub system, which performs the following functions:
 First of all, it loads the .class file into memory.
 Then it verifies whether all byte code instructions are proper or not. If it finds any
instruction suspicious, the execution is rejected immediately.
 If the byte instructions are proper, then it allocates necessary memory to execute the
program.
This memory is divided into 5 parts, called run time data areas, which contain the data and
results while running the program. These areas are as follows:
 Method area: Method area is the memory block, which stores the class code, code of
the variables, and code of the methods in the Java program. (Method means functions
written in a class)
 Heap: This is the area where objects are created. Whenever JVM loads a class, a
method and a heap area are immediately created in it.
 Java Stacks: Method code is stored on Method area. But while running a method, it
needs some more memory to store the data and results. This memory is allotted on Java
stacks.
 PC (Program Counter) registers: These are the registers (memory areas), which
contain memory address of the instructions of the methods. If there are 3 methods, 3 PC
registers will be used to track the instructions of the methods.
 Native method stacks: Java methods are executed on Java stacks. Similarly, native
methods (for example C/C++ functions) are executed on Native method stacks. To
execute the native methods, generally native method libraries (for example C/C++
header files) are required. These header files are located and connected to JVM by a
program, called Native method interface.
Execution engine contains interpreter and JIT (Just In Time) compiler, which are
responsible for converting the byte code instructions into machine code so that the processor
will execute them. Most of the JVM implementations use both the interpreter and JIT
compiler simultaneously to convert the byte code. This technique is also called adaptive
optimizer. Generally, any language (like C/C++, Fortran, COBOL, etc.) will use either an
interpreter or a compiler to translate the source code into a machine code. But in JVM, we got
interpreter and JIT compiler both working at the same time on byte code to translate it into
machine code.
Java Program Structure:
 Documentation Section
 Package Statement
 Import Statements
 Interface Statement
 Class Definition
 Main Method Class
o Main Method Definition
Page 7
It comprises of a comment line which gives the names program, the

Documentation programmer’s name and some other brief details. In addition to the 2
Section other styles of comments i.e. /**/ and //, Java also provides another
style of comment i.e. /**….*/
The first statement allowed in Java file is the Package statement
Package which is used to declare a package name and it informs the compiler
statement that the classes defined within the program belong to this package.
package package_name;
The next is the number of import statements, which is equivalent to
Import #include statement in C++.
statements Example:
import calc.add;
Interfaces are like class that includes a group of method declarations.

Interface
This is an optional section and can be used only when programmers
statement
want to implement multiple inheritance(s) within a program.
A Java program may contain multiple class definitions. Classes are
Class
the main and important elements of any Java program. These classes
Definition
are used to plot the objects of real world problem.
Since every Java stand alone program requires a main method as the
Main Method starting point of the program. This class is essentially a part of Java
Class program. A simple Java program contains only this part of the
program.
Sample Code of Java “Hello Java” Program

Example:
Program Output:
Hello Java
Comments:
 Single line comments: These comments are for marking a SL'1gle line as a comment.
These comments start with double slash symbol / / and after this, whatever is written
till the end of the line is taken as a comment. For example,
// This is single line comment
Page 8
 Multi-line comments: These comments are used for representing several lines as
comments. These comments start with / * and end with * /. In between / * and * /,
whatever is written is treated as a comment. For example,
/* This is Multi line comment,
Line 2 is here
Line 3 is here */
Importing Classes:
In C/C++ compiler to include the header file <stdio.h>. What is a header file? A
header file is a file, which contains the code of functions that will be needed in a program. In
other words, to be able to use any function in a program, we must first include the header file
containing that function's code in our program. For example, <stdio.h> is the header me that
contains functions, like printf (), scanf (), puts (), gets (), etc. So if we want to use any of
these functions, we should include this header file in our C/C++ program.
A similar but a more efficient mechanism, available in case of Java, is that of
importing classes. First, we should decide which classes are 'needed in our program.
Generally, programmers are interested in two things:
 Using the classes by creating objects in them.
 Using the methods (functions) of the classes.
In Java, methods are available in classes or interfaces. What is an interface? An interface
is similar to a class that contains some methods. Of course, there is a lot of difference
between an interface and a class, which we will discuss later. The main point to be kept in
mind, at this stage, is that a class or an interface contains methods. A group of classes and
interfaces are contained in a package. A package is a kind of directory that contains a group
of related Classes and interfaces and Java has several such packages in its library,
Java library
|
Packages
|
Classes and interfaces
|
Methods
In our first Java program, we are using two classes namely, System and String. These
classes belong to a package called java .lang (here lang represents language). So these two
classes must be imported into our program, as shown below:
import java.lang.System;
import java.lang.String;
Whenever we want to import several classes of the same package, we need not write
several import statements, as shown above; instead, we can write a single statement as:
import java.lang.*;
Here, * means all the classes and interfaces of that package, i.e. java.lang, are
imported made available) into our program. In import statement, the package name that we
have written acts like a reference to the JVM to search for the classes there. JVM will not
copy any code from the classes or packages. On the other hand, when a class name or a
Page 9
method name is used, JVM goes to the Java library, executes the code there, comes back, and
substitutes the result in that place of the program. Thus, the Java program size will not be
increased.
After importing the classes into the program, the next step is to write a class, Since
Java is purely an object-oriented programming language and we cannot write a Java program
without having at least one class or object. So, it is mandatory that every Java program should
have at least one class in it, How to write a class? We should use class keyword for this
purpose and then write the class name.
class Hello{
statements;
}
A class code starts with a { and ends with a }. We know that a class or an object
contains variables and methods (functions), 'So we can create any number of variables and
methods inside the class. This is our first program, so we will create only one method, i.e.
compulsory, main () method.
The main method is written as follows:
public static void main(String args[ ])
 Here args[ ] is the array name and it is of String type. This means that it can store a
group of strings. Remember, this array can also store a group of numbers but in the
form of strings only. The values passed to main( ) method are called arguments. These
arguments are stored into args[ ] array, so the name args[ ] is generally used for it.
 If a method is not meant to return any value, then we should write void before that
method's name. void means no value. main() method does not return any value, so void
should be written before that method's name.
 static methods are the methods, which can be called and executed without creating the
objects. Since we want to call main()method without using an object, we should
declare main( ) method as static. Then, how is the main( ) method called and executed?
The answer is by using the classname.methodname(). JVM calls main() method
using its class name as Hello.main() at the time of running the program.
 JVM is a program written by JavaSoft people (Java development team) and main() is
the method written by us. Since, main() method should be available to the JVM, it
should be declared as public. If we don't declare main() method as public, then. It
doesn't make itself available to JVM and JVM cannot execute it:
So, the main()method should always be written as shown here:
public static void main(String args[ ])
If at all we want to make any changes, we can interchange public and static and write it as
follows:
static public void main(String args[])
Or, we can use a different name for the string type array and write it as:
public static void main(String x[])
Q) When main() method is written without String args[args]:
public static void main ()
Ans: The code will compile but JVM cannot run the code because it cannot
recognize the main () method as the method from where it should start
execution of the Java program. Remember JVM always looks for main () method
with string type array as parameter.
Page 10
print method in java:

In Java, print() method is used to display something on the monitor. So, we can
write it as:
print(“Welcome to java”);
But this is not the correct way of calling a method in Java. A method should be called by
using objectname .methodname( ). So, to call print() method, we should create an object to
the class to which print() method belongs. print() method belongs to PrintStream class.
So, we should call print() method by creating an object to PrintStream class as:
PrintStream obj.print(“Welcome to java”);
But as it is not possible to create the object to PrintStream class directly, an alternative is
given to us, i.e. System.out. Here, System is the class name and out is a static variable in
System class. Out is called a field in System class. When we call this field, a PrintStream class
object will be created internally. So, we can call the print() method as shown below:
System.out.print(“Welcome to java”);
System.out gives the PrintStream class object. This object, by default, represents the standard
output device, i.e. the monitor. So, the string "Welcome to Java" will be sent to the monitor.
class Hello
{
public static void main(String[] args)
{
System.out.print(“Welcome to java”);
}
}
Save the above program in a text editor like Notepad with the name Hello.java. Now, go to
System prompt and compile it using javac compiler as:
javac Hello.java
The compiler generates a file called Hello.class that contains byte code instructions. This file
is executed by calling the JVM as:
java Hello
Then, we can see the result.
Note: In fact, JVM is written in C language.
Output:
C:\> javac Hello.java
C:\> java Hello
Welcome to Java
Program: Write a program to find the sum of addition of two numbers.
class Add
{
public static void main(String args[])
{
int x, y;
x = 27;
y = 35;
int z = x + y;
System.out.print(“The Sum is “+z);
}
}
Page 11
Data types:
Based on the data type of a variable, the operating system allocates memory and
decides what can be stored in the reserved memory. Therefore, by assigning different data
types to variables, you can store integers, decimals, or characters in these variables.
There are two data types available in Java −
a) Primitive Data Types
b) Reference/Object Data Types
a) Primitive Data Types
There are eight primitive datatypes supported by Java. Primitive datatypes are
predefined by the language and named by a keyword. Let us now look into the eight
primitive data types in detail.
Data Size Description

Type
Byte 1 byte Stores whole numbers from -128 to 127
Short 2 bytes Stores whole numbers from -32,768 to 32,767
Int 4 bytes Stores whole numbers from -2,147,483,648 to 2,147,483,647
Long 8 bytes Stores whole numbers from -9,223,372,036,854,775,808 to

9,223,372,036,854,775,807
Float 4 bytes Stores fractional numbers. Sufficient for storing 6 to 7 decimal digits
double 8 bytes Stores fractional numbers. Sufficient for storing 15 decimal digits
boolean 1 bit Stores true or false values
Char 2 bytes Stores a single character/letter or ASCII values
Page 12
byte
• Byte data type is an 8-bit signed two's complement integer
• Minimum value is -128 (-2^7)
• Maximum value is 127 (inclusive)(2^7 -1)
• Default value is 0
• Byte data type is used to save space in large arrays, mainly in place of integers, since a byte is
four times smaller than an integer.
• Example: byte a = 100, byte b = -50
short
• Short data type is a 16-bit signed two's complement integer
• Minimum value is -32,768 (-2^15)
• Maximum value is 32,767 (inclusive) (2^15 -1)
• Short data type can also be used to save memory as byte data type. A short is 2 times smaller
than an integer
• Default value is 0.
• Example: short s = 10000, short r = -20000
int
• Int data type is a 32-bit signed two's complement integer.
• Minimum value is - 2,147,483,648 (-2^31)
• Maximum value is 2,147,483,647(inclusive) (2^31 -1)
• Integer is generally used as the default data type for integral values unless there is a concern
about memory.
• The default value is 0
• Example: int a = 100000, int b = -200000
long
• Long data type is a 64-bit signed two's complement integer
• Minimum value is -9,223,372,036,854,775,808(-2^63)
• Maximum value is 9,223,372,036,854,775,807 (inclusive)(2^63 -1)
• This type is used when a wider range than int is needed
• Default value is 0L
• Example: long a = 100000L, long b = -200000L
float
• Float data type is a single-precision 32-bit IEEE 754 floating point
• Float is mainly used to save memory in large arrays of floating point numbers
• Default value is 0.0f
• Float data type is never used for precise values such as currency
• Example: float f1 = 234.5f
Page 13
Double
• double data type is a double-precision 64-bit IEEE 754 floating point
• This data type is generally used as the default data type for decimal values, generally the
default choice
• Double data type should never be used for precise values such as currency
• Default value is 0.0d
• Example: double d1 = 123.4
Boolean
• boolean data type represents one bit of information
• There are only two possible values: true and false
• This data type is used for simple flags that track true/false conditions
• Default value is false
• Example: boolean one = true
char
• char data type is a single 16-bit Unicode character
• Minimum value is '\u0000' (or 0)
• Maximum value is '\uffff' (or 65,535 inclusive)
• Char data type is used to store any character
• Example: char letterA = 'A'
Integer Data Types: Float Data Types:

Data Type Memory Size Data Type Memory Size
byte 1 byte float 4 byte
short 2 bytes double 8 bytes
int 4 bytes
long 8 bytes
Character Data Types:
The Character Data type is having 2 bytes of memory size.
String Data Types:
A String represents a group of characters, like New Delhi, AP123, etc. The simplest way to
create a String is by storing a group of characters into a String type variable as:
String str=”New Delhi”;
Now, the String type variable str contains "New Delhi". Note that any string written directly
in a program should be enclosed by using double quotes.
There is a class with the name String in Java, where several methods are provided to
perform different operations on strings. Any string is considered as an object of String class.
b) Reference Datatypes
 Reference variables are created using defined constructors of the classes. They are used
Page 14
to access objects. These variables are declared to be of a specific type that cannot be
changed. For example, Employee, Puppy, etc.
 Class objects and various type of array variables come under reference datatype.
 Default value of any reference variable is null.
 A reference variable can be used to refer any object of the declared type or any
compatible type.
 Example: Animal an = new Animal("giraffe");
Variables:
• A variable is a container which holds the value while the Java program is executed. A
variable is assigned with a data type.
• Variable is a name of memory location. There are three types of variables in java: local,
instance and static.
• There are two types of data types in Java: primitive and non-primitive.
Int a = 10;
Int data type
a  variable
10  value
A variable provides us with named storage that our programs can manipulate. Each
variable in Java has a specific type, which determines the size and layout of the variable's
memory; the range of values that can be stored within that memory; and the set of operations
that can be applied to the variable.
You must declare all variables before they can be used. Following is the basic form
of a variable declaration −
DataType variable [ = value][, variable [ = value] ...] ;
Here DataType is one of Java's datatypes and variable is the name of the variable. To
declare more than one variable of the specified type, you can use a comma-separated list.
Following are valid examples of variable declaration and initialization in Java −
Example
int a, b, c; // Declares three ints, a, b, and c.
int a = 10, b = 10; // Example of initialization
byte B = 22; // initializes a byte type variable B.
double pi = 3.14159; // declares and assigns a value of PI.
char a = 'a'; // the char variable a is initialized with value 'a'
There are three kinds of variables in Java −

a) Local variables
b) Instance variables
c) Class/Static variables
a) Local Variables
 Local variables are declared in methods, constructors, or blocks.
 Local variables are created when the method, constructor or block is entered and the
variable will be destroyed once it exits the method, constructor, or block.
 Access modifiers cannot be used for local variables.
 Local variables are visible only within the declared method, constructor, or block.
 Local variables are implemented at stack level internally.
Page 15
 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.
Example 1
Here, age is a local variable. This is defined inside pupAge() method and its scope is limited
to only this method.
class Test {
void pupAge( ) {
int age = 0;
age = age + 7;
System.out.println("Puppy age is : " + age);
}
public static void main(String args[]) {

Test test = new Test();
test.pupAge();
}
}
This will produce the following result −
Puppy age is: 7
Page 16
b) Instance Variables
 Instance variables are declared in a class, but outside a method, constructor or any
block.
 When a space is allocated for an object in the heap, a slot for each instance variable
value is created.
 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.
Normally, it is recommended to make these variables private (access level). However,
visibility for subclasses can be given for these variables with the use of access
modifiers.
 Instance variables have default values. For numbers, the default value is 0, for
Booleans it is false, and for object references it is null. Values can be assigned during
the declaration or within the constructor.
 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 sho3333333111uld be called using the fully
qualified name. ObjectReference.VariableName.
Example 1
import java.io.*;
public class Employee {
public String name;
public Employee (String empName) {
name = empName;
}
public void printEmp() {
System.out.println("name : " + name );
}
Employee empOne = new Employee("Sai krishna");
empOne.printEmp();
}
}
Output
name : Sai krishna
c) Class/Static Variables
 Class variables also known as static variables are declared with the static keyword in
a class, but outside a method, constructor or a block.
 There would only be one copy of each class variable per class, 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.
Page 17
 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 similar to 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. Static variables can be accessed by
calling with the class name ClassName.VariableName.
Example 1
import java.io.*;
public class Employee {
private static double salary;
salary = 1000;
System.out.println("average salary:" + salary);
}
}
average salary:1000
SCOPE AND LIFETIME OF VARIABLES

• Scope of a variable refers to in which areas or sections of a program can the variable be
accessed or visible.
• lifetime of a variable refers to how long the variable stays alive in memory.
• General convention for a variable’s scope is, it is accessible only within the block in
which it is declared. A block begins with a left curly brace { and ends with a right curly
brace }.
Arrays:
Java provides a data structure, the array, which stores a fixed-size sequential
collection of elements of the same type. An array is used to store a collection of data, but it is
often more useful to think of an array as a collection of variables of the same type.
Advantage of Java Array

 Code Optimization: It makes the code optimized, we can retrieve or sort the data
easily.
 Random access: We can get any data located at any index position.
Disadvantage of Java Array
Page 18
 Size Limit: We can store only fixed size of elements in the array. It doesn't grow its
size at runtime. To solve this problem, collection framework is used in java.
Types of Array in java
There are two types of array.
 Single Dimensional Array
 Multidimensional Array
Declaring Single Dimensional Array:
To use an array in a program, you must declare a variable to reference the array, and
you must specify the type of array the variable can reference. Here is the syntax for declaring
an array variable −
Syntax:
dataType[] varName;
or
dataType varName[];
Example:
int a[]; or int[] a;
Page 19
Instantiating an Array in Java

When an array us declared, only a reference of array is created. To actually create or
give memory to array, you create an array like this: The general form of new as it applies to
one-dimensional arrays appears as follows:
varName = new type [size];
Here, type specifies the type of data being allocated, size specifies the number of elements in
the array, and varName is the name of array variable that is linked to the array.
That is, to use new to allocate an array, you must specify the type and number of elements to
allocate.
Single -Dimensional Array:

The declaration and instantiating of an 1-D array is, as follows
Example:
int[] a=new int[5];
Example: Write a JAVA program to find sum of all numbers in an array.
import java.util.Scanner;
class SumArray
{
{
Scanner sc=new Scanner(System.in);
System.out.print("Enter the no. of elements: ");
int n=sc.nextInt();
int[] a=new int[n];
System.out.print("Enter the "+n+" elements ");
for(int i=0;i<n;i++)
a[i]=sc.nextInt();
int sum=0;
for(int i=0;i<n;i++)
{
sum=sum+a[i];
}
System.out.print("The Sum of elements is "+sum);
}
}
Output:
Enter the no. of elements: 5
Enter the 5 elements 5 4 2 1 3
The Sum of elements is 15
Two-Dimensional Array:
The declaration and instantiating of an 1-D array is, as follows
Example:
int[][] a=new int[2][3];
Page 20
Example: Write a java Program to perform Matrix addition.

class MatrixAddition
{
{
int[][] b=new int[2][2];
int[][] c=new int[2][2];
System.out.println("Enter the A Matrix elements ");
for(int i=0;i<2;i++)
for(int j=0;j<2;j++)
a[i][j]=sc.nextInt();
System.out.println("Enter the B Matrix elements ");
b[i][j]=sc.nextInt();
c[i][j]=a[i][j]+b[i][j];
System.out.println("The Addition of Matrix is ");
{
{
System.out.print(c[i][j]+" ");
}
System.out.print("\n");
}
}
}
Output:
Enter the A Matrix elements
12
34
Enter the B Matrix elements
56
78
The Addition of Matrix is
68
10 12
Page 21
Example: Write a java Program to perform Matrix multiplication.

class MatrixMultiplication
{
{
int[][] b=new int[2][2];
int[][] c=new int[2][2];
System.out.println("Enter the A Matrix elements ");
a[i][j]=sc.nextInt();
System.out.println("Enter the B Matrix elements ");
b[i][j]=sc.nextInt();
for(int k=0;k<2;k++)
c[i][j]+=a[i][k]*b[k][j];
System.out.println("The Multiplication of Matrix is ");
{
{
System.out.print(c[i][j]+" ");
}
}
}
}
Output:
Enter the A Matrix elements
12
34
Enter the B Matrix elements
56
78
The Multiplication of Matrix is
19 22
43 50
Page 22
Operators:
Java provides a rich set of operators to manipulate variables. We can divide all the Java
operators into the following groups −
 Arithmetic Operators
 Relational Operators
 Bitwise Operators
 Logical Operators
 Assignment Operators
 Misc Operators
The Arithmetic Operators

Arithmetic operators are used in mathematical expressions in the same way that they
are used in algebra. The following table lists the arithmetic operators −
Assume integer variable A holds 10 and variable B holds 20, then −
Page 23
Operator Description Example

+ (Addition) Adds values on either side of the operator. A + B will give 30
Subtracts right-hand operand from left-hand
- (Subtraction) A - B will give -10
operand.
Multiplies values on either side of the
* (Multiplication) A * B will give 200
operator.
Divides left-hand operand by right-hand
/ (Division) B / A will give 2
operand.
Divides left-hand operand by right-hand
% (Modulus) B % A will give 0
operand and returns remainder.
++ (Increment) Increases the value of operand by 1. B++ gives 21
-- (Decrement) Decreases the value of operand by 1. B-- gives 19
The Relational Operators

There are following relational operators supported by Java language.
Assume variable A holds 10 and variable B holds 20, then −
Checks if the values of two operands are equal (A == B) is not
== (equal to)
or not, if yes then condition becomes true. true.
Checks if the values of two operands are equal
!= (not equal to) or not, if values are not equal then condition (A != B) is true.
becomes true.
Checks if the value of left operand is greater
> (greater than) than the value of right operand, if yes then (A > B) is not true.
condition becomes true.
Checks if the value of left operand is less than
< (less than) the value of right operand, if yes then (A < B) is true.
condition becomes true.
Checks if the value of left operand is greater
>= (greater than (A >= B) is not
than or equal to the value of right operand, if
or equal to) true.
yes then condition becomes true.
Checks if the value of left operand is less than
<= (less than or
or equal to the value of right operand, if yes (A <= B) is true.
equal to)
then condition becomes true.
The Bitwise Operators

Java defines several bitwise operators, which can be applied to the integer types,
long, int, short, char, and byte.
Bitwise operator works on bits and performs bit-by-bit operation. Assume if a = 60
and b = 13; now in binary format they will be as follows –
a = 0011 1100
b = 0000 1101
Page 24
-----------------
a&b = 0000 1100
a|b = 0011 1101
a^b = 0011 0001
~a = 1100 0011
Assume integer variable A holds 60 and variable B holds 13 then −

Binary AND Operator copies a bit to the (A & B) will give 12
& (bitwise and)
result if it exists in both operands. which is 0000 1100
Binary OR Operator copies a bit if it exists (A | B) will give 61 which
| (bitwise or)
in either operand. is 0011 1101
^ (bitwise Binary XOR Operator copies the bit if it is (A ^ B) will give 49 which
XOR) set in one operand but not both. is 0011 0001
(~A ) will give -61 which
~ (bitwise Binary Ones Complement Operator is is 1100 0011 in 2's
compliment) unary and has the effect of 'flipping' bits. complement form due to a
signed binary number.
Binary Left Shift Operator. The left
operands value is moved left by the A << 2 will give 240
<< (left shift)
number of bits specified by the right which is 1111 0000
operand.
Binary Right Shift Operator. The left
operands value is moved right by the A >> 2 will give 15 which
>> (right shift)
number of bits specified by the right is 1111
operand.
Shift right zero fill operator. The left
operands value is moved right by the
>>> (zero fill A >>>2 will give 15
number of bits specified by the right
right shift) which is 0000 1111
operand and shifted values are filled up
with zeros.
The Logical Operators

The following table lists the logical operators −
Assume Boolean variables A holds true and variable B holds false, then −
&& (logical Called Logical AND operator. If both the operands are (A && B) is
and) non-zero, then the condition becomes true. false
Called Logical OR Operator. If any of the two operands
|| (logical or) (A || B) is true
are non-zero, then the condition becomes true.
Called Logical NOT Operator. Use to reverses the
! (logical !(A && B) is
logical state of its operand. If a condition is true then
not) true
Logical NOT operator will make false.
Page 25
The Assignment Operators

Following are the assignment operators supported by Java language –
Simple assignment operator. Assigns values from C = A + B will assign
=
right side operands to left side operand. value of A + B into C
Add AND assignment operator. It adds right
C += A is equivalent to
+= operand to the left operand and assign the result to
C=C+A
left operand.
Subtract AND assignment operator. It subtracts
C -= A is equivalent to
-= right operand from the left operand and assign the
C=C–A
result to left operand.
Multiply AND assignment operator. It multiplies
C *= A is equivalent to
*= right operand with the left operand and assign the
C=C*A
result to left operand.
Divide AND assignment operator. It divides left
C /= A is equivalent to
/= operand with the right operand and assign the result
C=C/A
to left operand.
Modulus AND assignment operator. It takes
C %= A is equivalent
%= modulus using two operands and assign the result
to C = C % A
to left operand.
C <<= 2 is same as C =
<<= Left shift AND assignment operator.
C << 2
C >>= 2 is same as C =
>>= Right shift AND assignment operator.
C >> 2
C &= 2 is same as C =
&= Bitwise AND assignment operator.
C&2
bitwise exclusive OR and assignment operator. C ^= 2 is same as C =
^=
C^2
bitwise inclusive OR and assignment operator. C |= 2 is same as C = C
|=
|2
Miscellaneous Operators
There are few other operators supported by Java Language.
Conditional Operator ( ? : )
Conditional operator is also known 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
Page 26
Example
public class Test {

int a, b;
a = 10;
b = (a == 1) ? 20: 30;
System.out.println( "Value of b is : " + b );
b = (a == 10) ? 20: 30;

System.out.println( "Value of b is : " + b );
}
}
Output
Value of b is : 30
Value of b is : 20
instanceof Operator
This operator is used only for object reference variables. The operator checks whether the
object is of a particular type (class type or interface type). instanceof operator is written as −
( Object reference variable ) instanceof (class/interface type)
If the object referred by the variable on the left side of the operator passes the IS-A check for
the class/interface type on the right side, then the result will be true. Following is an example
Example
public class Test {
String name = "James";
// following will return true since name is type of String

boolean result = name instanceof String;
System.out.println( result );
}
}
Output
true
This operator will still return true, if the object being compared is the assignment compatible
with the type on the right. Following is one more example −
Example
class Vehicle {}
public class Car extends Vehicle {
Vehicle a = new Car();
boolean result = a instanceof Car;
System.out.println( result );
Page 27
}
}
Output
true
Precedence of Java Operators
Operator precedence determines the grouping of terms 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, x = 7 + 3 * 2; here x is assigned 13, not 20 because operator * has higher
precedence than +, so it first gets multiplied with 3 * 2 and then adds into 7.
Here, operators with the highest precedence appear at the top of the table, those with
the lowest appear at the bottom. Within an expression, higher precedence operators will be
evaluated first.
Category Operator Associativity
Postfix >() [] . (dot operator) Left toright
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
Page 28
Identifiers:
Identifiers are the names of variables, methods, classes, packages and interfaces. In the Hello
program, Hello, String, args, main and print are identifiers. There are a few rules and
conventions related to the naming of variables.
The rules are:
1. Java variable names are case sensitive. The variable name money is not the same
as Money or MONEY.
2. Java variable names must start with a letter, or the $ or _ character.
3. After the first character in a Java variable name, the name can also contain numbers
(in addition to letters, the $, and the _ character).
4. Variable names cannot be equal to reserved key words in Java. For instance, the
words int or forare reserved words in Java. Therefore you cannot name your
variables int or for.
Here are a few valid Java variable name examples:
myvar myVar MYVAR _myVar
$myVar myVar1 myVar_1
Java Literals
A literal is a value that is stored into a variable directly in the program. There are 5
types of literals.
a) Integer Literals
b) Float Literals
c) Character Literals
d) String Literals
e) Boolean Literals
a) Integer Literals
class Test {
{
int dec = 101; // decimal-form literal
int oct = 0100; // octal-form literal
int hex = 0xFace; // Hexa-decimal form literal
System.out.println(dec); //101
System.out.println(oct); //64
System.out.println(hex); //64206
}
}
Page 29
b) Float Literals
class Test {
{
double d1 = 123.4;
double d2 = 1.234e2; //Same value as d1, but in scientific notation
float f1 = 123.4f;
System.out.println(d1); //123.4
System.out.println(d2); //123.4
System.out.println(f1); //123.4
}
}
c) Character Literals
public class Test {
{
char ch1 = 'a';
char ch2 = '\"';
char ch3 = '\n';
char ch4 = '\u0015';
System.out.println(ch1); // a
System.out.println(ch2); // “
System.out.println(ch3); //
System.out.println(ch4); // §
}
}
d) String Literals
String literals represent objects of String class. For example, Hello, Anil
Kumar, AP1201, etc. will come under string literals, which can be directly stored into
a String object.
e) Boolean Literals
Boolean literals represent only two values-true and false, It means we can
store either true or false into a boolean type variable.
Primitive Type Conversion and casting:

Java supports two types of castings – primitive data type casting and reference type
casting. Reference type casting is nothing but assigning one Java object to another object. It
comes with very strict rules and is explained clearly in Object Casting. Now let us go for data
type casting.
Java data type casting comes with 3 flavors.
a) Implicit casting
b) Explicit casting
c) Boolean casting.
Page 30
b) Implicit casting (widening conversion)

A data type of lower size (occupying less memory) is assigned to a data type of higher
size. This is done implicitly by the JVM. The lower size is widened to higher size. This is
also named as automatic type conversion.
Examples:
int x = 10; // occupies 4 bytes
double y = x; // occupies 8 bytes
System.out.println(y); // prints 10.0
In the above code 4 bytes integer value is assigned to 8 bytes double value.
c) Explicit casting (narrowing conversion)
A data type of higher size (occupying more memory) cannot be assigned to a data
type of lower size. This is not done implicitly by the JVM and requires explicit casting; a
casting operation to be performed by the programmer. The higher size is narrowed to lower
size.
double x = 10.5; // 8 bytes
int y = x; // 4 bytes ; raises compilation error
In the above code, 8 bytes double value is narrowed to 4 bytes int value. It raises error. Let us
explicitly type cast it.
double x = 10.5;
int y = (int) x;
The double x is explicitly converted to int y. The thumb rule is, on both sides, the same data
type should exist.
d) Boolean casting
A boolean value cannot be assigned to any other data type. Except boolean, all the
remaining 7 data types can be assigned to one another either implicitly or explicitly; but
boolean cannot. We say, boolean is incompatible for conversion. Maximum we can assign a
boolean value to another boolean.
Following raises error.
boolean x = true;
int y = x; // error
boolean x = true;
int y = (int) x; // error
byte –> short –> int –> long –> float –> double
In the above statement, left to right can be assigned implicitly and right to left requires
explicit casting. That is, byte can be assigned to short implicitly but short to byte requires
explicit casting.
Following char operations are possible
class Demo {
char ch1 = 'A';
double d1 = ch1;
System.out.println(d1); // prints 65.0

System.out.println(ch1 * ch1); // prints 4225 , 65 * 65
double d2 = 66.0;
char ch2 = (char) d2;
System.out.println(ch2); // prints B
}
}
Page 31
JAVA EXPRESSIONS
A Java expression consists of variables, operators, literals, and method calls. To know more
about method calls, visit Java methods.
For example,
int score;
score = 90; Here, score = 90 is an expression that returns an int
Consider another example,
Double a = 2.2, b = 3.4, result;
result = a + b - 3.4; // here, a + b - 3.4 is an expression
Expression statements
We can convert an expression into a statement by terminating the expression with a ;. These
are known as expression statements. For example,
// expression
number = 10
// statement
number = 10;
CONTROL STATEMENTS
Java compiler executes the java code from top to bottom. The statements are executed
according to the order in which they appear. However, Java provides statements that
can be used to control the flow of java code. Such statements are called control flow
statements.
Java provides three types of control flow statements.
1. Decision Making statements
2. Loop statements
3. Jump statements
Decision-Making statements:
Decision-making statements evaluate the Boolean expression and control the program
flow depending upon the condition result. There are two types of decision-making
statements in java, I.e., If statement and switch statement.
If Statement:
In Java, the "if" statement is used to evaluate a condition. The control of the program is
diverted depending upon the condition result that is a Boolean value, either true or
false. In java, there are four types of if-statements given below.
1. if statement
Page 32
2. if-else statement
3. else-if statement
4. Nested if-statement
1. if statement:
This is the most basic statement among all control flow statements in java. It
evaluates a Boolean expression and enables the program to enter a block of code
if the expression evaluates to true.
Syntax of if statement is given below.

1. if(<condition>) {
2. //block of code
3. }
Consider the following example in which we have used the if statement in the java code.
1. //Java Program to demonstate the use of if statement.

2. public class IfExample {
3. public static void main(String[] args) {
4. //defining an 'age' variable
5. int age=20;
6. //checking the age
7. if(age>18){
8. System.out.print("Age is greater than 18");
9. }
10. }
11. }
o/pAge is greater than 18
Java if-else Statement
The Java if-else statement also tests the condition. It executes the if block if
condition is true otherwise else block is executed.
Page 33
Syntax:
1. if(condition){
2. //code if condition is true
3. }else{
4. //code if condition is false
5. }
Example:
1. //A Java Program to demonstrate the use of if-else statement.

2. //It is a program of odd and even number.
3. public class IfElseExample {
5. //defining a variable
6. int number=13;
7. //Check if the number is divisible by 2 or not
8. if(number%2==0){
9. System.out.println("even number");
10. }else{
11. System.out.println("odd number");
12. } } } o/p odd number
Leap Year Example:
A year is leap, if it is divisible by 4 and 400. But, not by 100.
1. public class LeapYearExample {

3. int year=2020;
4. if(((year % 4 ==0) && (year % 100 !=0)) || (year % 400==0)){
5. System.out.println("LEAP YEAR");
6. }
7. else{
8. System.out.println("COMMON YEAR");
9. } } }
Output:
Page 34
LEAP YEAR
Java if-else-if ladder Statement

The if-else-if ladder statement executes one condition from multiple
statements.
Syntax:
1. if(condition1){
2. //code to be executed if condition1 is true
3. }else if(condition2){
5. }
6. else if(condition3){
8. }
9. ...
10. else{
11. //code to be executed if all the conditions are false
12. }
Example:
1. //Java Program to demonstrate the use of If else-if ladder.

2. //It is a program of grading system for fail, D grade, C grade, B grade, A grade a
nd A+.
3. public class IfElseIfExample {
5. int marks=65;
6.
7. if(marks<50){
8. System.out.println("fail");
9. }
10. else if(marks>=50 && marks<60){
11. System.out.println("D grade");
12. }
14. System.out.println("C grade");
15. }
Page 35
17. System.out.println("B grade");

18. }
20. System.out.println("A grade");
21. }else if(marks>=90 && marks<100){
22. System.out.println("A+ grade");
23. }else{
24. System.out.println("Invalid!");
25. } } }
Output:
C grade
Program to check POSITIVE, NEGATIVE or ZERO:
1. public class PositiveNegativeExample {

3. int number=-13;
4. if(number>0){
5. System.out.println("POSITIVE");
6. }else if(number<0){
7. System.out.println("NEGATIVE");
8. }else{
9. System.out.println("ZERO");
10. }
11. }
12. }
Output:
NEGATIVE
Page 36
Java Nested if statement

The nested if statement represents the if block within another if block. Here, the inner if
block condition executes only when outer if block condition is true.
Syntax:
1. if(condition){
2. //code to be executed
3. if(condition){
5. }
6. }
Example:
1. //Java Program to demonstrate the use of Nested If Statement.

2. public class JavaNestedIfExample {
4. //Creating two variables for age and weight
5. int age=20;
6. int weight=80;
7. //applying condition on age and weight
8. if(age>=18){
9. if(weight>50){
10. System.out.println("You are eligible to donate blood");
11. }
12. }
13. }}
Output:
You are eligible to donate blood
Page 37
Loops in Java
In programming languages, loops are used to execute a set of instructions/functions
repeatedly when some conditions become true. There are three types of loops in Java.
o while loop
o do-while loop
o for loop
Java While Loop

The Java while loop is used to iterate a part of the program several times. If the number
of iteration is not fixed, it is recommended to use while loop.
Syntax:
1. while(condition){
3. }
Example:
1. public class WhileExample {

3. int i=1;
4. while(i<=10){
5. System.out.println(i);
6. i++;
7. }
8. }
9. }
Output: 1 2 3 4 5 6 7 8 9 10
Java do-while Loop

The Java do-while loop is used to iterate a part of the program several times. If the
number of iteration is not fixed and you must have to execute the loop at least once, it
is recommended to use do-while loop.
The Java do-while loop is executed at least once because condition is checked after loop
Page 38
Syntax:
1. do{
3. }while(condition);
Example:
1. public class DoWhileExample {

3. int i=1;
4. do{
6. i++;
7. }while(i<=10);
8. }
9. }
Ouuput: 1 2 3 4 5 6 7 8 9 10
Example 2:
public class Test {

int x = 10;
do {
System.out.print("value of x : " + x );
x++;
}while( x < 20 );
}
}
Output
value of x : 10
value of x : 11
value of x : 12
value of x : 13
value of x : 14
value of x : 15
value of x : 16
value of x : 17
value of x : 18
value of x : 19
Page 39
Java For Loop

The Java for loop is used to iterate a part of the program several times. If the number of
iteration is fixed, it is recommended to use for loop.
Java Simple For Loop

A simple for loop is the same as C/C++. We can initialize the variable, check condition
and increment/decrement value. It consists of four parts:
1. Initialization: It is the initial condition which is executed once when the loop
starts. Here, we can initialize the variable, or we can use an already initialized
variable. It is an optional condition.
2. Condition: It is the second condition which is executed each time to test the
condition of the loop. It continues execution until the condition is false. It must
return boolean value either true or false. It is an optional condition.
3. Statement: The statement of the loop is executed each time until the second
condition is false.
4. Increment/Decrement: It increments or decrements the variable value. It is

an optional condition.
Syntax:
1. for(initialization;condition;incr/decr){
2. //statement or code to be executed
3. }
Example:
1. //Java Program to demonstrate the example of for loop

2. //which prints table of 1
3. public class ForExample {
5. //Code of Java for loop
6. for(int i=1;i<=10;i++){
8. }
9. }
10. }
Output: 12 3 4 5 6 7 8 9 10
Page 40
Jump statements in Java

 Break
 Continue
 return
Java Break Statement
When a break statement is encountered inside a loop, the loop is immediately
terminated and the program control resumes at the next statement following the loop.
The Java break statement is used to break loop or switch statement. It breaks the
current flow of the program at specified condition. In case of inner loop, it breaks only
inner loop.
We can use Java break statement in all types of loops such as for loop, while
loop and do-while loop.
Syntax:
1. jump-statement;
2. break;
Example:
1. //Java Program to demonstrate the use of break statement

2. //inside the for loop.
3. public class BreakExample {
5. //using for loop
6. for(int i=1;i<=10;i++){
7. if(i==5){
8. //breaking the loop
9. break;
10. }
12. }
13. }
14. }
Output: 1 2 3 4
Page 41
Java Continue Statement

The continue statement is used in loop control structure when you need to jump to the
next iteration of the loop immediately. It can be used with for loop or while loop.
The Java continue statement is used to continue the loop. It continues the current flow
of the program and skips the remaining code at the specified condition. In case of an
inner loop, it continues the inner loop only.
We can use Java continue statement in all types of loops such as for loop, while loop
and do-while loop.
Syntax:
1. jump-statement;
2. continue;
Example:
1. //Java Program to demonstrate the use of continue statement

2. //inside the for loop.
3. public class ContinueExample {
5. //for loop
6. for(int i=1;i<=10;i++){
7. if(i==5){
8. //using continue statement
9. continue;//it will skip the rest statement
10. }
12. }
13. }
14. }
Output: 1 2 3 4 6 7 8 9 10
Page 42
Java return Keyword

Java return keyword is used to complete the execution of a method. The return followed
by the appropriate value that is returned to the caller. This value depends on the
method return type like int method always return an integer value.
Points to remember
o It is used to exit from the method.
o It is not allowed to use return keyword in void method.
o The value passed with return keyword must match with return type of the
method.
Example 1
1. public class ReturnExample1 {
2. int display()
3. {
4. return 10;
5. }
7. ReturnExample1 e =new ReturnExample1();
8. System.out.println(e.display());
9. }
10. }
OUTPUT : 10
Example 2:
1. public class ReturnExample2 {
2. void display()
3. {
4. return null;
5. }
7. ReturnExample2 e =new ReturnExample2();
8. e.display();
9. }
10. }
OUTPUT: Void methods cannot return a value
Page 43
TYPE CASTING AND CONVERSION

In Java, type casting is a method or process that converts a data type into another
data type in both ways manually and automatically. The automatic conversion is done
by the compiler and manual conversion performed by the programmer. In this section,
we will discuss type casting and its types with proper examples.
Type casting
Convert a value from one data type to another data type is known as type casting.
o Widening Type Casting
o Narrowing Type Casting
Widening Type Casting

Converting a lower data type into a higher one is called widening type casting. It is
also known as implicit conversion or casting down. It is done automatically. It is
safe because there is no chance to lose data. It takes place when:
o Both data types must be compatible with each other.
o The target type must be larger than the source type.
byte -> short -> char -> int -> long -> float -> double
For example, the conversion between numeric data type to char or Boolean is not
done automatically. Also, the char and Boolean data types are not compatible
with each other. Let's see an example.
WideningTypeCastingExample.java
1. public class WideningTypeCastingExample

2. {
3. public static void main(String[] args)
4. {
5. int x = 7;
6. //automatically converts the integer type into long type
7. long y = x;
8. //automatically converts the long type into float type
9. float z = y;
10. System.out.println("Before conversion, int value "+x);
11. System.out.println("After conversion, long value "+y);
12. System.out.println("After conversion, float value "+z);
Page 44
13. }
14. }
Output
15. Before conversion, the value is: 7

16. After conversion, the long value is: 7
17. After conversion, the float value is: 7.0
Narrowing Type Casting

Converting a higher data type into a lower one is called narrowing type casting. It is
also known as explicit conversion or casting up. It is done manually by the
programmer. If we do not perform casting then the compiler reports a compile-time
error.
double -> float -> long -> int -> char -> short -> byte
In the following example, we have performed the narrowing type casting two times.
First, we have converted the double type into long data type after that long data type is
converted into int type.
NarrowingTypeCastingExample.java
1. public class NarrowingTypeCastingExample

2. {
3. public static void main(String args[])
4. {
5. double d = 166.66;
6. //converting double data type into long data type
7. long l = (long)d;
8. //converting long data type into int data type
9. int i = (int)l;
10. System.out.println("Before conversion: "+d);
11. //fractional part lost
12. System.out.println("After conversion into long type: "+l);
13. //fractional part lost
14. System.out.println("After conversion into int type: "+i);
15. }
16. }
Output:
Before conversion: 166.66
After conversion into long type: 166
Page 45
After conversion into int type: 166
First Java Program

To create a simple java program, you need to create a class that contains the main
method. Let's understand the requirement first.
The requirement for Java Hello World Example

For executing any java program, you need to
o Install the JDK if you don't have installed it, download the JDK and install it.
o Set path of the jdk/bin directory. http://www.javatpoint.com/how-to-set-path-in-java
o Create the java program
o Compile and run the java program
1. class Simple{
2. public static void main(String args[]){
3. System.out.println("Hello Java");
4. }
save this file as Simple.java
To compile: javac Simple.java
To execute: java Simple

Output:Hello Java
Parameters used in First Java Program

Let's see what is the meaning of class, public, static, void, main, String[],
System.out.println().
o class keyword is used to declare a class in java.
o public keyword is an access modifier which represents visibility. It means it is

visible to all.
o static is a keyword. If we declare any method as static, it is known as the static

method. The core advantage of the static method is that there is no need to
create an object to invoke the static method. The main method is executed by
Page 46
the JVM, so it doesn't require to create an object to invoke the main method. So
it saves memory.
o void is the return type of the method. It means it doesn't return any value.
o main represents the starting point of the program.
o String[] args is used for command line argument. We will learn it later.
o System.out.println() is used to print statement. Here, System is a class, out is

the object of PrintStream class, println() is the method of PrintStream class. We
will learn about the internal working of System.out.println statement later.
Valid java main method signature

1. public static void main(String[] args)
2. public static void main(String []args)
3. public static void main(String args[])
4. public static void main(String... args)
5. static public void main(String[] args)
6. public static final void main(String[] args)
7. final public static void main(String[] args)
8. final strictfp public static void main(String[] args)
Classes and Objects:

We know a class is a model for creating objects. This means, the properties and
actions of the objects are written in the class. Properties are represented by variables and
actions of the objects are represented by methods. So, a class contains variables and methods.
The same variables and methods are also available in the objects because they are created
from the class. These variables are also called 'instance variables' because they are created
inside the object (instance).
If we take Person class, we can write code in the class that specifies the properties and
actions performed by any person. For example, a person has properties like name, age, etc.
Similarly a person can perform actions like talking; walking, etc. So, the class Person
contains these properties and actions as shown here:
class Person
{
String name;
int age;
void talk()
{
System.out.println("Hello my name is "+name);
System.out.println("and my age is "+age);
}
}
Object Creation:
We know that the class code along with method code is stored in 'method area' of the
Page 47
JVM. When an object is created, the memory is allocated on 'heap'. After creation of an
object, JVM produces a unique reference number for the object from the memory address of
the object. This reference number is also called hash code number.
To know the hashcode number (or reference) of an object, we can use hashCode() method
object class, as shown here:
Person p = new Person();
System.out.println(p.hashCode());
The object reference, (hash code) internally represents heap memory where instance-
variables are stored. There would be a pointer (memory address) from heap memory to a
special structure located in method area. In method area, a table is available which contains
pointers to static variables and methods.
Page 48
class Person
{
String name;
int age;
void talk()
{
}
}
class Demo
{
{
System.out.println(p.hashCode()); // 705927765
}
}
Initializing the instance variables:
It is the duty of the programmer to initialize the instance depending on his
requirements. There are various ways to do this.
First way is to initialize the instance variables of Person class in other class, i.e.,
Demo class. For this purpose, the Demo class can be rewritten like this:
class Demo
{
{
p.name="Raju";
p.age=22;
System.out.println(p.hashCode()); // 705927765
}
}
Second way is to initialize the instance variables of Person class in the Same class.
For this purpose, the Person class can be rewritten like this:
class Person
{
String name="Raju";
int age=22;
void talk()
{
System.out.println("My Name is "+name);
System.out.println("My Age is "+age);
}
}
Page 49
class Demo
{
{
Person p1 = new Person();
System.out.println("p1 hashcode "+p1.hashCode());
p1.talk();
p2.talk();
}
}
Output:
p1 hashcode 705927765
My Name is Raju
My Age is 22
My Name is Raju
My Age is 22
But, the problem in this way of initialization is that all the objects are initializing with same
data.
Constructors:
The third possibility of initialization is using constructors. A constructor is similar to a
method is used to initialize the instance variables. The sole purpose of a constructor is to
initialize the instance variables. A constructor has the following characteristics:
 The constructor's name and class name should be same. And the constructor's name
should end with a pair of simple braces.
Person()
{
}
 A constructor may have or may not have parameters: Parameters are variables to
receive data from outside into the constructor. If a constructor does not have any
parameters, it is called ‘Default constructor’. If a constructor has 1 or more parameters,
it is called ‘parameterized constructor’; For example, we can write a default constructor
as:
Person()
{
}
And a Parameterized constructor with two parameters, as:
Person(String s, int i)
{
}
Page 50
 A constructor does not return any value, not even 'void'. Recollect, if a method does not
return any value, we write 'void' before the method name. That means, the method is
returning ‘void’ which means 'nothing'. But in case of a constructor, we should not even
write 'void' before the constructor.
 A constructor is automatically called and executed at the time of creating an object.
While creating an object, if nothing is passed to, the object, the default constructor is
called and executed. If-some values are passed to the object, then the parameterized
constructor is called. For example, if we create the object as:
Person p = new Person(); // Default Constructor
Person p = new Person(Raju, 22); // Parameterized Constructor
 A constructor is called and executed only once per object. This means .when we create
an object, the constructor is called. When we create second object, again the constructor
is called second time.
class Person
{
String name;
int age;
Person()
{
name="Raju";
age=22;
}
void talk()
{
}
}
class Demo
{
{
Person p = new Person(); // Default Constructor
System.out.println("p hashcode "+p.hashCode());
p.talk();
System.out.println(p1.hashCode());
p1.talk();
}
}
Output:
p hashcode 705927765
My Name is Raju
My Age is 22
My Name is Raju
My Age is 22
Page 51
From the output, we can understand that the same data "Raju" and 22 are store in both
objects p1 and p2. p2 object should get p2’s data, not p1’s data. Isn't it? To mitigate the
problem, let us try parameterized constructor, which accepts data from outside and initializes
instance variables with that data.
class Person
{
String name;
int age;
Person()
{
name="Raju";
age=22;
}
Person(String s, int i)
{
name=s;
age=i;
}
void talk()
{
System.out.println("My Name is "+name);
System.out.println("My Age is "+age);
}
}
class Demo
{
{
p1.talk();
Person p2 = new Person("Sita",23);
System.out.println(p2.hashCode());
p2.talk();
}
}
Output:
My Name is Raju
My Age is 22
My Name is Sita
My Age is 23
Q: When is a constructor called, before or after creating the object?

Ans: A constructor is called concurrently when the object creation is going on. JVM first
allocates memory for the object and then executes the constructor to initialize the instance
variables. By the time, object creation is completed; the constructor execution is also
completed.
Page 52
Difference between Default Constructor and Parameterized Constructor:

Default Constructor Parameterized Constructor
Default constructor is useful to initialize Parameterized constructor is useful to
all the objects with same data. initialize each object with different data.
Default constructor does not have any Parameterized constructor will have 1 or
parameters. more parameters.
When the data is not passed at the time When the data is passed at the time of
of creating object, default constructor is creating object, default constructor is
called. called.
Difference between Constructor and Method:
Java Constructor Java Method
Constructor is used to initialize the state Method is used to expose behaviour of an
of an object. object.
Constructor must not have return type. Method must have return type.
Constructor is invoked implicitly. Method is invoked explicitly.
The java compiler provides a default Method is not provided by compiler in
constructor if you don't have any any case.
constructor.
Constructor name must be same as the Method name may or may not be same as
class name. class name.
Q: What is constructor overloading?

Ans: Writing two or more constructors with the same name but with difference in the
parameters is called constructor overloading. Such constructors are useful to perform
different tasks.
Write a Java Program for Constructor Overloading?

class Box
{
double width, height, depth;
Box()
{
width = height = depth = 0;
}
Box(double len)
{
width = height = depth = len;
}
Box(double w, double h, double d)
{
width = w;
height = h;
depth = d;
}
Page 53
double volume()
{
return width * height * depth;
}
}
public class Test
{
{
Box mybox1 = new Box(10, 20, 15);
Box mybox2 = new Box();
Box mybox3 = new Box(7);
double vol;
vol = mybox1.volume();
System.out.println(" Volume of mybox1 is " + vol);
}
}
Output:
Volume of mybox1 is 3000.0
Java Garbage Collection

 In java, garbage means unreferenced objects. Garbage Collection is process of
reclaiming the runtime unused memory automatically.
 In other words, it is a way to destroy the unused objects. To do so, we were using
free() function in C language and delete() in C++. But, in java it is performed
automatically. So, java provides better memory management.
Advantage of Garbage Collection
 It makes java memory efficient because garbage collector removes the unreferenced
objects from heap memory. 
 It is automatically done by the garbage collector (a part of JVM) so we don't need to
make extra efforts.
How can an object be unreferenced?
 Even though programmer is not responsible to destroy useless objects but it is highly
recommended to make an object unreachable (thus eligible for GC) if it is no longer
required.
 There are many ways: 
 By nulling the reference
 By assigning a reference to another
 By annonymous object etc.
Page 54
1) By nulling a reference:
Employee e=new Employee();
e=null;
2) By assigning a reference to another:
Employee e1=new Employee();
Employee e2=new Employee();
e1=e2;//now the first object referred by e1 is available for garbage collec
tion
3) By annonymous object:
new Employee();
finalize() method
The finalize() method is invoked each time before the object is garbage collected.
This method can be used to perform cleanup processing. This method is defined in Object
class as: protected void finalize(){}
gc() method
The gc() method is used to invoke the garbage collector to perform cleanup
processing. The gc() is found in System and Runtime classes.
public static void gc(){}
Program:
public class TestGarbage1
{
public void finalize()
{
System.out.println("object is garbage collected");
}
{
TestGarbage1 s1=new TestGarbage1();
TestGarbage1 s2=new TestGarbage1();
s1=null;
s2=null;
System.gc();
}
}
Output:
object is garbage collected
object is garbage collected
Methods in Java:
 A method represents a group of statements that performs a task. Here 'task' represents
a calculation or processing of data or generating a report etc.
 A Method has two types:
 Method Header
 Method Body
Page 55
 Method Header: It contains method name, method parameters and method return
data type.
returntype methodName(parameters)
 Method Body: Method body consists of group of statements which contains logic to
perform the task.
{
Statements;
}
 If a method returns some value, then a return statement should be written within the
body of method, as:
return somevalue;
 There are two types of methods in java:
a) Instance methods
b) Static methods
a) Instance Methods:
Instance methods are the methods which act on the instance variables of the
class. To call the instance methods, we should use the form:
objectname. methodname ();
Example-1: Write a program to perform addition of two numbers using instance
method without return statement.
class Addition
{
void add(double a,double b)
{
double c=a+b;
System.out.println("Addition is "+c);
}
}
class MethodDemo
{
{
Addition a1=new Addition();
a1.add(27,35);
}
}
Output:
Addition is 62
Example-2: Write a program to perform addition of two numbers using instance
method with return statement.
class Addition
{
double add(double a,double b)
{
double c=a+b;
return c;
}
Page 56
}
class MethodDemo
{
{
Addition a1=new Addition();
double c=a1.add(27,35);
}
}
Output:
Addition is 62
b) Static Methods:
Static methods are the methods which do not act on the instance variables of
the class. static methods are declared as ‘static’. To call the static methods, we need
not create the object. we call a static method, as:
ClassName. methodname ();
Example-1: Write a program to perform addition of two numbers using static method
without return statement.
class Addition
{
static void add(double a,double b)
{
double c=a+b;
}
}
class MethodDemo
{
{
Addition.add(27,35);
}
}
Output:
Addition is 62
Example-2: Write a program to perform addition of two numbers using static method
with return statement.
class Addition
{
static double add(double a,double b)
{
double c=a+b;
return c;
}
}
class MethodDemo
{
Page 57

{
double c= Addition.add(27,35);
}
}
Output:
Addition is 62
Q: why instance variables are not available to static methods?

Ans: After executing static methods, JVM creates the objects. So, the instance variables are
not available to static methods.
Example: Write a JAVA program to implement method overloading.
Static Block:
 A static block is a block of statements declared as ‘static’.
static {
statements;
}
 JVM executes a static block on highest priority basis. This means JVM first goes to
static block even before it looks for the main() method in the program.
Example-1: Write a program to test which one is-executed first by JVM, the static block or
the static method.
class Demo
{
static
{
System.out.println("Static block");
}
{
System.out.println("Static Method");
}
}
Output:
Static block
Static Method
Example-2: Write a java program without main() method.
class Demo
{
static
{
System.out.println("Static block");
}
}
Output:
Static block
Page 58
Q: Is it possible to compile and run a Java program without writing main() method?
Ans: Yes, it is possible by using a static block in theJava program.
'this' keyword:
 'this' is a keyword that refers to the object of the class where it is used. In other words,
'this' refers the object of the present class.
 Generally, we write instance variables, constructors and methods in a class. All these
members are referenced by 'this'. When an object is created to a class, a default
reference is also created internally to the object.
Example: Write a program for 'this' keyword.

class Demo
{
int x;
Demo(int x)
{
this.x=x+3;
System.out.println("x="+x);
System.out.println("this.x="+this.x);
}
{
Demo d=new Demo(5);
}
}
Output:
x=5
this.x=8
Recursion:
A method calling itself is known as recursive method', and that process is called 'recusrion'. It
is possible to write recursive methods in Java. Let us, take an example to find the factorial
value of the given number. Factorial value of number num is defined as: num * (num-1) *
(num-2) * ......
Example: Write a java Program to find factorial of a given number using recursion.
class Factorial
{
static long fact(long num)
{
if(num==1 || num==0)
return 1;
else
Page 59
{
return num*fact(num-1);
}
}
{
System.out.print("Enter number: ");
long num=sc.nextInt();
long f=Factorial.fact(num);
System.out.println("Factorial is "+f);
}
}
Command line arguments:
 The java command-line argument is an argument i.e. passed at the time of running the
java program.
 The arguments passed from the console can be received in the java program and it can be
used as an input.
 So, it provides a convenient way to check the behaviour of the program for the different
values. You can pass N (1,2,3 and so on) numbers of arguments from the command
prompt.
Example: Write a JAVA Program to read input from command line.
class CommandLine
{
{
System.out.println("Command line argument values are ");
for(int i=0;i<args.length;i++)
{
System.out.println(args[i]);
}
}
}
Output:
Command line argument values are
27
2.5
krishna
Nested Classes:
 Nested classes are the classes that contain other classes like inner classes. Inner class is
basically a safety mechanism since it is hidden from other classes in its outer class.
 To make instance variables not available outside the class, we use 'private' access
specifier before the variables. This is how we provide the security mechanism to
variables. Similarly, in some cases we want to provide security for the entire class.
 In this case, can we use 'private' access specifier before the class? The problem is, if we
Page 60
use private access specifier before a class, the class is not available to the Java compiler
or JVM. SO it is illegal to use 'private' before a class name in Java.
 But, private specifier is allowed before an inner class and thus it is useful to provide
security for the entire inner class.
 An inner class is a class that is defined inside another class.
 Inner class is a safety mechanism.
 Inner class is hidden from other classes in its outer class.
 An object to inner class cannot be created in other classes.
 An object to inner class can be created only in its outer class.
 Inner class _can access the members of outer class directly.
 Inner class object and outer class objects are created in separate memory locations.
Page 61
Example: Write a JAVA program to create the outer class BankAccount and the inner class
Interest in it.
class BankAccount
{
double bal;
BankAccount(double b)
{
bal=b;
}
void contact(double r)
{
System.out.print("Enter Password: ");
String password=sc.next();
if(password.equals("cse556"))
{
Interest in=new Interest(r);
in.calculateInterest();
}
}
private class Interest
{
double rate;
Interest(double r)
{
rate=r;
}
void calculateInterest()
{
double inter=bal*rate/100;
bal=bal+inter;
System.out.println("Updated Balance= "+bal);
}
}
{
BankAccount ba=new BankAccount(10000);
ba.contact(9.5);
}
}
Output:
Enter Password: cse556
Updated Balance= 10950.0
Page 1
Strings:
In java, string is basically an object that represents sequence of char values. An array of
characters works same as java string.
String is a class in java.lang package. But in java, all classes are also considered as data
types. So, we can take string as a data type also. A class is also called as user-defined data
type.
Creating Strings:
There are three ways to create strings in Java:
 We can create a string just by assigning a group of characters to a string type variable:
String s;
s = "Hello";
 Preceding two statements can be combined and written as:
String s = "Hello";
In this, case JVM creates an object and stores the string: "Hello" in that object. This object is
referenced by the variable's'. Remember, creating object means allotting memory for storing
data.
 We can create an object to String class by allocating memory using new operator. This
is just like creating an object to any class, like given here:
String s = new String("Hello");
Here, we are doing two things. First, we are creating object using new operator. Then,
we are storing the string: "Hello" into the object.
 The third way of creating the strings is by converting the character arrays into strings.
Let us take a character type array: arr[] With some characters, as:
char arr[]={'H','e','l','l','o'};
 Now create a string object, by pass.ing the array name to it, as:
String s = new String(arr);
String Methods:
No. Method Description
char charAt(int index) returns char value for the particular
1
index
2 int length() returns string length
static String format(String returns formatted string
3 format, Object... args)
String substring(int beginIndex, returns substring for given begin index
4 int endIndex) and end index
boolean contains(CharSequence s) returns true or false after matching the
5
sequence of char value
static String join(CharSequence returns a joined string
6 delimiter, CharSequence...
elements)
7 boolean equals(Object another) checks the equality of string with object
8 boolean isEmpty() checks if string is empty
9 String concat(String str) concatenates specified string
String replace(char old, char replaces all occurrences of specified
10 new) char value
static String Compares another string. It doesn't
11 equalsIgnoreCase(String another) check case.
Page 2
String[] split(String regex, int returns splitted string matching regex

12 limit) and limit
13 int indexOf(int ch) returns specified char value index
14 String toLowerCase() Returns string in lowercase.
15 String toUpperCase() Returns string in uppercase.
String trim() Removes beginning and ending spaces
16
of this string.
static String valueOf(int value) Converts given type into string. It is
17
overloaded.
equals method in java:
Program:
class StringComapre
{
{
String s1 = "Hello";
String s2 = new String("Hello");
System.out.println(s1==s2); //false
System.out.println(s1.equals(s2)); //true
}
}
Immutability of String:
 In java, string objects are immutable. Immutable simply means unmodifiable or
unchangeable.
 Once string object is created its data or state can't be changed but a new string object is
created.
class Testimmutablestring{
public static void main(String args[]){
String s="Sachin";
s.concat(" Tendulkar");
System.out.println(s);
}
}
Output: Sachin
 But if we explicitely assign it to the reference variable, it will refer to "Sachin
Tendulkar" object.For example:
class Testimmutablestring1{
public static void main(String args[]){
String s="Sachin";
s=s.concat(" Tendulkar");
System.out.println(s);
}
}
Output: Sachin Tendulkar
Page 3
StringBuffer Class:
 Java StringBuffer class is used to create mutable (modifiable) string. The StringBuffer
class in java is same as String class except it is mutable i.e. it can be changed.
 String class objects are immutable and hence their contents cannot be modified.
StringBuffer class objects are mutable; so they can be modified. Moreover the methods
that directly manipulate data of the object are not available in String class. Such methods
are available in StringBuffer class.
Creating StringBuffer objects:
We can create StringBuffer object by using new operator and pass the string to the object, as:
StringBuffer sb = new StringBuffer("Hello");
Methods in StringBuffer class:

S.No. Method & Description
StringBuffer append(String str)
1
This method appends the specified string to this character sequence.
char charAt(int index)
2 This method returns the char value in this sequence at the specified
index.
StringBuffer delete(int start, int end)
3
This method removes the characters in a substring of this sequence.
void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
4 This method characters are copied from this sequence into the
destination character array dst.
int indexOf(String str, int fromIndex)
5 This method returns the index within this string of the first
occurrence of the specified substring, starting at the specified index.
StringBuffer insert(int offset, String str)
6
This method inserts the string into this character sequence.
int lastIndexOf(String str)
7 This method returns the index within this string of the rightmost
occurrence of the specified substring.
int length()
8
This method returns the length (character count).
StringBuffer replace(int start, int end, String str)
9 This method replaces the characters in a substring of this sequence
with characters in the specified String.
StringBuffer reverse()
10 This method causes this character sequence to be replaced by the
reverse of the sequence.
void setCharAt(int index, char ch)
11
The character at the specified index is set to ch.
String substring(int start, int end)
12 This method returns a new String that contains a subsequence of
characters currently contained in this sequence.
String toString()
13
This method returns a string representing the data in this sequence.
void trimToSize()
14
This method attempts to reduce storage used for the character sequence.
Page 4
Program: Write a JAVA Program to delete single character.

class DeleteCharacter
{
{
StringBuffer sb = new StringBuffer("Hello");
sb.delete(1,2);
System.out.println(sb); //Hllo
sb.delete(3,4);
System.out.println(sb); //Hll
}
}
Accessing Input from the keyboard:

 Input represents data given to a program and output represents data displayed as a result
of a program.
 A stream is required to accept input from the keyboard. A stream represents flow of
data from one place to another place.
 It is like a water-pipe where water flows. Like a water-pipe carries water from one
place to another, a stream carries data from one place to another place.
 A stream can carry data from keyboard to memory or from memory to printer or from
memory to a file.
 A stream is always required if we want to move data from one place to another.
 Basically, there are two types of streams: input streams and output streams.
 Input streams are those streams which receive or read data coming from some other
place.
 Output streams are those streams which send or write data to some other place.
 All streams are represented by classes in java.io (input and output) package.
Page 5
 This package contains a lot of classes, all of which can be classified into two basic
categories: input streams and output streams.
 Keyboard is represented by a field, called in System class. When we write System.in,
we are representing a standard input device, i.e. keyboard, by default. System class is
found in java.lang (language) package and has three fields' as shown below.
 All these fields represent some type of stream:
System.in: This represents Ii1putStream object, which by default represents
standard input device, i.e., keyboard.
System.out: This represents PrintStream object, which by default represents
standard output device, i.e., monitor.
System.err: This field also represents PrintStream object, which by default
represents monitor.
 Note that both System.out and System.err can be used to represent the monitor and hence
any of these two can be used to send data to the monitor.
 To accept data from the keyboard i.e., System.in. we need to connect it to an input stream.
And input stream is needed to read data from the keyboard.
 Connect the keyboard to an input stream object. Here, we can use InputStreamReader that
can read data from the keyboard.
InputStreamReader isr = new InputStreamReader(System.in);
 Connect InputStreamReader to BufferedReader, which is another input type of stream.
BufferedReader br = new BufferedReader(isr);
 Now we can read data coming from the keyboard using read( ) and readLine( ) methods
available in BufferedReader class.
Ex: Write a JAVA Program to read Single character from the keyboard.
import java.io.*;
import java.lang.*;
class Test {
public static void main(String[] args)throws IOException
{
System.out.print("Enter a single Character: ");
char ch = (char)br.read();
System.out.print("\n The Character is "+ch);
}
}
Output:
javac Test.java
java Test
Enter a single Character: m
The Character is m
Page 6
Ex: Write a JAVA Program to read String from the keyboard.

import java.io.*;
import java.lang.*;
class Test {
{
System.out.print("Enter the String: ");
String str = br.readLine();
System.out.print("\n The String is "+str);
}
}
Output:
javac Test.java
java Test
Enter the String: mothi
The String is mothi
Ex: Write a JAVA Program to read Integer from the keyboard.

import java.io.*;
import java.lang.*;
class Test {
{
System.out.print("Enter the Number: ");
int n = Integer.parseInt(br.readLine());
System.out.print("\n The number is "+n);
}
}
Output:
javac Test.java
java Test
Enter the Number: 56
The Number is 56
 To accept Float value we have to use
float f = Float.parseFloat(br.readLine());
 To accept Double value we have to use
double d = Double.parseDouble(br.readLine());
Reading Input with java.util.Scanner Class:

We can use Scanner class of java.util package to read input from the keyboard or a
text file. When the Scanner class receives input, it breaks the input into several pieces, called.
tokens. These tokens can be retrieved from the Scanner object using the following methods
 next() - to read a string
 nextByte() - to read byte value
 nextlnt() - to read an integer value
 nextFloat() - to read float value
 nextLong()- to read long value.
 nextDouble () -to read double value
Page 7
To read input from keyboard, we can use Scanner class as:

Scanner sc = new Scanner(System.in);
Ex: Write a JAVA Program to read different types of data separated by space, from the
keyboard using the Scanner class.
import java.lang.*;
class Test {
{
Scanner sc = new Scanner(System.in);
System.out.print("Enter id name sal: ");
int id = sc.nextInt();
String name = sc.next();
float sal = sc.nextFloat();
System.out.println("Id is: "+id);
System.out.println("Name is: "+name);
System.out.println("Sal is: "+sal);
}
}
Output:
javac Test.java
java Test
Enter id name sal: 09 sudheer 40000.00
Id is: 09
Name is: sudheer
Sal is: 40000.00
Page 25
TUTORIAL QUESTIONS
S.No. WEEK-1 Ref

1.2
1 List and Explain the OOPs concepts in java?
1.7
2 Explain about Buzzwords in java?
1.1
3 Need for OOPs Paradigm?
4 Explain different data types in java? 1.8
5 What is a variable and explain its types? 1.9
S.No. WEEK – II Ref

Explain about array and types? 1.11
1
2 Comparison between the while and do-while? 1.14.2
1.13
3 How to identify the literals and expression?
Write about garbage collection in java? 1.21
4
1.20
5 What is this keyword in java and describe with an example?
S.No. WEEK – III Ref

1 Explain overloading methods in java? 1.22
2 Write about inheritance? 1.25
1.26
3 Explain about method overriding?
Give an example program for recursion? 1.27
4
Write about nested and inner classes? 1.28

5
Page 26
University Questions
R16
Code No: 136FM
JAWAHARLAL NEHRU TECHNOLOGICAL UNIVERSITY HYDERABAD
B. Tech III Year II Semester Examinations, May - 2019
JAVA PROGRAMMING
(Common to CE, EEE, ME, ECE, EIE, MSNT)
Time: 3 hours Max. Marks: 75
Note: This question paper contains two parts A and B.
Part A is compulsory which carries 25 marks. Answer all questions in Part A. Part B consists of 5
Units. Answer any one full question from each unit. Each question carries 10 marks and may have a, b,
c as sub questions.
PART - A
(25 Marks)
1.a) Define polymorphism. [2]
b) Why is byte code of Java is known as magical code? [3]
c) What is an inner class? [2]
d) Differentiate between interface and abstract class. [3]
e) List checked exceptions of Java. [2]
f) How to create a thread? [3]
g) What is a ResultSet? [2]
h) How is a vector different from an array? [3]
i) Why swing components are light weight? [2]
j) Give AWT hierarchy and swing hierarchy. [3]
PART - B
(50 Marks)
2. Make a comparison of procedure oriented programming and object oriented programming. [10]
OR
3.a) How does Java support type casting?
b) Demonstrate the use of ‘this’ keyword. [5+5]
4. Describe different forms of inheritance. Write a program to implement multiple inheritance. [10]
OR
5.a) What is meant by dynamic binding? Explain dynamic method dispatch.
b) Describe the need of package creation in Java. [5+5]
6. What is an exception? What are the benefits of exception handling? Explain the five keywords of
Java important for exception handling. [10]
OR
7.a) Differentiate between process and thread.
b) Write a program to solve producer-consumer problem using inter-thread communication. [5+5]
www.manaresults.co.in
Page 27
8. Write a Java program to append second file content to first file, read two file names as command line
arguments. [10]
OR
9.a) Describe the four types of database drivers of JDBC.
b) Describe the important methods of StringTokenizer class. [5+5]
10. What is an event? Describe delegation event model and write a program to handle mouse events.
[10]
OR
11. Compare applets with application programs. With suitable program segments explain applet life
cycle. [10]
Page 28
Code No: 133BM

JAWAHARLAL NEHRU TECHNOLOGICAL UNIVERSITY HYDERABAD
B.Tech II Year I Semester Examinations, May/June - 2019
OBJECT ORIENTED PROGRAMMING THROUGH JAVA
(Common to CSE, IT)
Time: 3 Hours Max. Marks: 75
Note: This question paper contains two parts A and B.
Part A is compulsory which carries 25 marks. Answer all questions in Part A.
Part B consists of 5 Units. Answer any one full question from each unit. Each question carries 10 marks
and may have a, b as sub questions.
PART- A
(25 Marks)
1.a) Differentiate between class and object. [2]
b) What is meant by ad-hoc polymorphism? [3]
c) How to define a package in Java? [2]
d) Contrast between abstract class and interface. [3]
e) Define exception. [2]
f) Differentiate between a thread and a process. [3]
g) Which methods of deque enable it to be used as a stack? [2]
h) Make a comparison of List, array and ArrayList. [3]
i) Give the AWT hierarchy. [2]
j) What are the various classes used in creating a swing menu? [3]
PART-B
(50 Marks)
2.a) What are the responsibilities of an agent?
b) What is the purpose of constructor in Java programming? [5+5]
OR
3. Define inheritance. What are the benefits of inheritance? What costs are associated with inheritance?
How to prevent a class from inheritance? [10]
4. Write a program to demonstrate hierarchical and multiple inheritance using interfaces. [10]
OR
5.a) Demonstrate ordinal( ) method of enum.
b) What is type wrapper? What is the role of auto boxing? [5+5]
6. Write a program to create three threads in your program and context switch among the threads using
sleep functions. [10]
OR
7.a) Write a program with nested try statements for handling exception.
b) How to create a user defined exception? [5+5]
8. Write a program to read a file content and extract words using String Tokenizer class. Display the
file if it contains the user query term/search key. [10]
OR
9.a) Contrast sorted map and navigable map interfaces.
b) What is the purpose of BitSet class? What is the functionality of the following functions of BitSet
class: cardinality( ) , flip( ) and intersects( ) [5+5]
10.a) Illustrate the use of Grid Bag layout.
b) What are the subclasses of JButton class of swing package? [5+5]
OR
11.a) Create a simple applet to display a smiley picture using Graphics class methods.
b) Write a short note on delegation event model. [5+5]
Page 29
DESCRIPTIVE QUESTIONS
S.No. Description BTL COs
a) Define Object Oriented Programming? How it is different from Procedural concepts?

1. b) Define an Object? How to allocate memory for objects? TL1 CO2
2. Can a method be overloaded based on different return type but same argument type? TL 1 CO 1
a) Explain Summarize the following object oriented concepts.
Abstraction ii) Polymorphism
3. TL 3 CO 1
b) "Java is called Machine Independent language" - Justify this statement with proper
explanation.
a) What do you mean by static class and static method? Can we make an instance of an
4. TL 2 CO 1
abstract class? Justify your answer with an example?
a) Define the different forms of inheritance?
5. TL 3 CO 2
b) Define java Buzzwords?
a) Justify why the features of Object Oriented Programming are important for
programming?
6. TL 3 CO 2
b) List out the characteristics of the static method.
a) Categorize on the advantages and disadvantages of Object Oriented Programming

7. TL 2 CO 2
a) Demonstrate to illustrate "Constructor Overloading".

8. b) Define the various types of exceptions available in Java? Also Categorize on how they TL 2 CO 3
are handled?
a) "Write Once and Run Anywhere" - Support this statement with proper reasoning.
9. b) Define a constructor? When does the compiler supply default constructor for a TL 4 CO 3
class?
a) Categorize various control structures available in Java.

10. b) Demonstrate to perform the following functions using classes, objects, TL 1 CO 3
constructors and destructors wherever necessary
11. a) Illustrate type casting in java with an example. TL 3 CO 1
a) "Abstract classes can be defined without any abstract methods"

12. - support this statement with proper reasoning. TL 2 CO 1
13. b) Explain clearly about how Java handles cleaning up of unused objects. TL 1 CO 1
a) Define the use of super keyword?
14. b) Distinguish between abstract class and concrete class. TL 3 CO 2
a) Compare Inheritance and polymorphism?

15. TL 3 CO 2
b) Define the use of final method?
a) Define the string method of object class?
16. TL 2 CO 2
b) Compare and contrast the hierarchical inheritance and multiple inheritance?
Page 30
OBJECTIVE QUESTIONS
1) Which of the following option leads to the portability and security of Java?
a. Byte code is executed by JVM

b. The applet makes the Java code secure and portable
c. Use of exception handling
d. Dynamic binding between objects
2) Which of the following is not a Java features?
a. Dynamic
b. Architecture Neutral
c. Use of pointers
d. Object-oriented
3. Which of these is necessary condition for automatic type conversion in Java?

a) The destination type is smaller than source type
b) The destination type is larger than source type
c) The destination type can be larger or smaller than source type
d) None of the mentioned
4. Which of the following is not OOPS concept in Java?
a) Inheritance
b) Encapsulation
c) Polymorphism
d) Compilation
5. Which concept of Java is achieved by combining methods and attribute into a class?
a) Encapsulation
b) Inheritance
c) Polymorphism
d) Abstraction
6. Which keyword is used to create object in the java class.
a). This b) Super c) final d) New
7. When a method having same method name with different signatures are called------
a) Operator Overloading
Page 31
b) Method Overriding
c) Constructor Overloading
d) Method Overloading
8. Which is not a control statement in java?
a) If and else-if-ladder
b) While
c) For
d) Abstract
9. What access specifies allows to global variable.

a) Private
b) Protected
c) Public
d) Static
10. Garbage Collection is used for ________

a) to remove un-accessed memory locations
b) to delete constructor
c) to assign a value to the variable.
d) to create new class
Page 32
UNIT TEST PAPER
SET-1
PART – 1 Objective Questions: 10*0.5=5 Marks
1. A Class can be defined as ………………………………………….
2. ……………………………………. is the instance of the class.
3. ……………….class is used to derive properties from ……………. class.
4. An abstraction is only for declaration but not for …………………………………..
5. Which oops concept is used to perform in different ways …………………….
6. The main responsibility of the garbage collection is ……………………………..
7. A method is call itself is called as ………………………………….
8. How many types of variables in java ……………………………….?
9. ……………….. keyword is used to invoke the current class methods and attributes.
10. Converting a lower datatype into another data type is known as ………………………
PART – 2 Descriptive Questions 5*1=5 Marks
1. a) what is type casting and type conversion in java?
b) Explain about the iteration statements with suitable examples?
Or
2. a) List and brief explain about the OOPs concepts in Java?
b) How may operators supporting java and explain in detail?
SET-2
PART – 1 Objective Questions: 10*0.5=5 Marks

Page 33
1. a) Why OOPs paradigm important to build applications?
b) What is a data type and explain in detail about datatypes in java?
Or
2. a) Define the variable and describe the scope and life time of a variable?
b) Explain the abstraction mechanism with a suitable example?
PART – 1 Objective Questions: 10*0.5=5 Marks SET-3


Page 34
1. a) Define the class and object with a sample java program?
b) Explain the constructor in java?
Or
2. a) Discuss the importance of the recursion in programming languages?
b) Is there any use of Inner classes and how?
PART – 1 Objective Questions: 10*0.5=5 Marks SET-4
1. a) Explain about the iteration statements with suitable examples
b) What is a data type and explain in detail about datatypes in java?
Or
2. a) Define the variable and describe the scope and life time of a variable?
b) Explain the abstraction mechanism with a suitable example?
Page 35
SEMINAR TOPICS
S.No Seminar Topic

1. Importance of java and its applications.
2. Object Oriented Programming concepts.
3. What is a variable and where we can use a variable.
4. Discuss about a class and object with sample example.
5. Differences between Constructor and overloading constructor.
Page 36
ASSIGNMENT QUESTIONS
SNo Questions Taxonomy Course

Level Outcome
1 What are the OOPS concepts in java? TL1 CO1
2 List and Explain java Buzzwords? TL2 CO1
3 Define Describe the Data Types in java? TL2 CO1
4 Classify the types of control statements and their usage? TL2 CO1
5 Discuss about Class and define? TL2 CO1
Page 37
REAL TIME APPLICATIONS
Abstraction Mechanism: ATM’s

Basically, ATM machine provide the operations like,
 Balance Withdraw ()
 Balance Enquiry ()
 Amount Deposit ()
 Pin change ()
From customer/ User perspective, need to use or operate the functions which are provided by the
ATM machine or application.
Here, customer can view the operation but he can’t understand the application how it is
implemented and what logic used to run the application.
Control Statements: To find weather the person eligible for vote.

By using control statements can identify the person eligible for giving vote.
 While
 Do while
 For loop
The verity of loop statements are used to identify the person is eligible for vote or not.
If the person is eligible then he gets the message like your eligible for the vote otherwise
sometimes skip the statements and some times it shows alternative message like you’re not eligible
for the vote.
Encapsulation: Capsule, it is wrapped with different medicines. In a capsule, all medicine

is encapsulated inside a capsule.
Page 38
PLACEMENT QUESTIONS WITH KEY
1.What is JVM?
The Java interpreter along with the runtime environment required to run the Java application in called as
Java virtual machine(JVM)
2. What is the most important feature of Java?
Java is a platform independent language.
3. What do you mean by platform independence?
Platform independence means that we can write and compile the java code in one platform (eg
Windows) and can execute the class in any other supported platform eg (Linux,Solaris,etc).
4. What is the difference between a JDK and a JVM?
JDK is Java Development Kit which is for development purpose and it includes execution environment
also. But JVM is purely a run time environment and hence you will not be able to compile your source
files using a JVM.
5. What is the base class of all classes?
java.lang.Object
6. What are the access modifiers in Java?
There are 3 access modifiers. Public, protected and private, and the default one if no identifier is
specified is called friendly, but programmer cannot specify the friendly identifier explicitly.
7. Why there are no global variables in Java?
Global variables are globally accessible. Java does not support globally accessible variables due to
following reasons:
1)The global variables breaks the referential transparency
2)Global variables creates collisions in namespace.
8. What are Encapsulation, Inheritance and Polymorphism?
Encapsulation is the mechanism that binds together code and data it manipulates and keeps both safe
from outside interference and misuse. Inheritance is the process by which one object acquires the
properties of another object. Polymorphism is the feature that allows one interface to be used for
general class actions.
9. What is the use of bin and lib in JDK?

Page 39
Bin contains all tools such as javac, appletviewer, awt tool, etc., whereas lib contains API and all
packages.
10. What is method overloading and method overriding?
Method overloading: When a method in a class having the same method name with different arguments
is said to be method overloading. Method overriding : When a method in a class having the same
method name with same arguments is said to be method overriding.
11. What is the difference between this() and super()?
this() can be used to invoke a constructor of the same class whereas super() can be used to invoke a
super class constructor.
12. What is JIT and its use?
Really, just a very fast compiler… In this incarnation, pretty much a one-pass compiler — no offline
computations. So you can’t look at the whole method, rank the expressions according to which ones are
re-used the most, and then generate code. In theory terms, it’s an on-line problem.
13. What are different types of access modifiers?
public: Any thing declared as public can be accessed from anywhere. private: Any thing declared as
private can’t be seen outside of its class. protected: Any thing declared as protected can be accessed by
classes in the same package and subclasses in the other packages. default modifier : Can be accessed
only to classes in the same package.
14. What is the difference between a constructor and a method?
A constructor is a member function of a class that is used to create objects of that class. It has the same
name as the class itself, has no return type, and is invoked using the new operator.
A method is an ordinary member function of a class. It has its own name, a return type (which may be
void),and is invoked using the dot operator.
15.What is UNICODE?
Unicode is used for internal representation of characters and strings and it uses 16 bits to represent each
other.
Page 40
THINKING ABILTY
Object-oriented programming has four basic concepts: encapsulation, abstraction, inheritance and
polymorphism. Even if these concepts seem incredibly complex, understanding the general
framework of how they work will help you understand the basics of a computer program. Here are
the four basic theories and what they entail:
 Encapsulation, Abstraction, Inheritance and Polymorphism
Beginning programmers may better understand this concept in relation to how a browser
functions. Browsers have local storage objects that allow you to store data locally. These objects
have properties, like length, which turns the number of objects into storage, along with methods
like (remove item) and (set item).
Another way to consider encapsulation is in terms of an employee's pay. The properties of an

employee can include base salary, overtime and rate with a method called factor wage. Code
written in an encapsulated, object-oriented way functions with fewer and fewer parameters. The
fewer the number of parameters, the easier it is to use and maintain that function.
Think of a stereo system as an object with a complex logic board on the inside. It has buttons on
the outside to allow for interaction with the object. When you press any of the buttons, you're not
thinking about what happens on the inside because you can't see it. Even though you can't see the
logic board completing functions as a result of pressing a button, it's still performing actions. This is
an abstraction, which can be used to understand the concept of programming.
Another way to understand this is to consider the human body. The skin acts as an abstraction to
hide the internal body parts responsible for bodily functions like digesting and walking.
Consider two classes. One is the superclass (parent) while the subclass (child) will inherit the
properties of the parent class and modify its behavior. Programmers applying the technique of
inheritance arrange these classes into a hierarchy of "is-a-type-of" relationships.
For instance, in the animal world, an insect would be a superclass. All insects share similar
properties, such as having six legs and an exoskeleton. Grasshoppers and ants are both insects and
inherited similar properties.
To better understand the two terms of polymorphism called overloading and overriding, it helps to
visualize the process of walking. Babies learn to crawl first by using their arms and legs. Once they
learn to stand and walk, they are ultimately changing the body part used to accomplish the act of
walking. This term of polymorphism is called overloading. To understand the next term of
overriding, think of how you naturally walk in the direction you are facing. When you stop and walk
backward, this changes the direction of your path and also the mechanism of function. You are
overriding the natural action that you usually complete.
Page 41

JAVA UNIT-1 Notes

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

JAVA UNIT-1 Notes

Uploaded by

Copyright:

Available Formats

JAVA PROGRAMMING

R20 REGULATION (ECE)

B.Tech. II Year I Semester LTPC

Prerequisites: Programming for Problem Solving.

1. Introduces Object Oriented Programming Concepts Using The Java Language

1. Develop Applications for Range of Problems Using Object-Oriented Programming Techniques

1. Java the Complete Reference, 7th Edition, Herbert Schildt, TMH.

 Bottom–up approach in program design

SUMMARY OF OOP CONCEPTS

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

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

Abstraction - in nothing but only declaration but not implementation

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

Fig: Procedure oriented approach

Object oriented approach:

Fig: Object oriented approach

Problems in Procedural oriented approach:

Fig: Person class and Raju Object

Coping with complexity:

Non-Linear behavior of complexity:

Ways to achieve Abstraction

There are two ways to achieve abstraction in java

1. Abstract class (0 to 100%)

Abstract class in Java

Understanding the real scenario of Abstract class

1. abstract class Shape{

A Way of viewing World- Agents

 James Gosling was born on May 19, 1955.

By September of 1994, Naughton and Jonathan Payne started writing WebRunner-a

 Distributed: Information is distributed on various computers on a network. Using Java,

Fig: Components in JVM Architecture

It comprises of a comment line which gives the names program, the

Interfaces are like class that includes a group of method declarations.

Sample Code of Java “Hello Java” Program

print method in java:

Data Size Description

Byte 1 byte Stores whole numbers from -128 to 127

Short 2 bytes Stores whole numbers from -32,768 to 32,767

Int 4 bytes Stores whole numbers from -2,147,483,648 to 2,147,483,647

Long 8 bytes Stores whole numbers from -9,223,372,036,854,775,808 to

boolean 1 bit Stores true or false values

Char 2 bytes Stores a single character/letter or ASCII values

Integer Data Types: Float Data Types:

There are three kinds of variables in Java −

public static void main(String args[]) {

SCOPE AND LIFETIME OF VARIABLES

Advantage of Java Array

Instantiating an Array in Java

Single -Dimensional Array:

Example: Write a java Program to perform Matrix addition.

Example: Write a java Program to perform Matrix multiplication.

The Arithmetic Operators

Operator Description Example

The Relational Operators

The Bitwise Operators

Assume integer variable A holds 60 and variable B holds 13 then −

The Logical Operators

The Assignment Operators

public static void main(String args[]) {

b = (a == 10) ? 20: 30;

public static void main(String args[]) {

String name = "James";