Introduction to

Object-Oriented
Programming
CHAPTER ONE
Programming Paradigms
• Programming Paradigm is a way of conceptualizing what it
means to perform computation and how tasks to be carried out
and organized on a computer.
Structured Programming
• Problem solving would involve the analysis of processes in
terms of the procedural tasks carried out and the production of
a system whose representation is based on the procedural flow
of the processes.
• data was separate from code.
• programmer is responsible for organizing everything in to
logical units of code/data.
• A procedural program is divided into functions, and (ideally, at
least) each function has a clearly defined purpose & a clearly
defined interface to the other functions in the program.
 Contd…

Disadvantages of Structured Programming

1. Unrestricted Access
• Functions have unrestricted access to global data.

2. Real-World Modeling
• Unrelated functions and data, the basics of the procedural paradigm,
provide a poor model of the real world.

3. Difficult of Creating New Data Types

• Traditional languages are not extensible because they will not let you
create new data types.
 Contd…
OOP Approach
• A modern programming paradigm that allows the
Programmer to model a problem in a real-world fashion as
an object.
• Major objective is to eliminate some of the flaws
encountered in the procedural approach.
• OOP allows us to decompose a problem into number of
entities called objects and then build data and methods
(functions) around these entities.
• The data of an object can be accessed only by the
methods associated with the object.
• Follows bottom-up approach in program design
 Contd…
Features of OOP
• Emphasis is on data rather than procedure.

• Programs are divided into objects.

• Data Structures are designed such that they characterize the

objects.

• Methods that operate on the data of an object are tied

together in the data structure.

• Data is hidden and can not be accessed by external functions.

• Objects may communicate with each other through methods.

Basic OOP Concepts
The following are the basic OOP concepts:
1. Objects
2. Classes
3. Data Abstraction
4. Data Encapsulation
5. Inheritance
6. Polymorphism
7. Dynamic Binding
8. Message Passing
 Contd…
1. Object
• An object is an any real world entity which may represent place, person, data
item related to program.
• An object has state, behavior and identity.
• Ex. A ‘Mouse’ object has,
State: moving or working
Behavior: picking or pointing an object on the screen
Identity: color, company, Identification No. etc.
• An object is a variable/instance of class.
• An object is a run-time entity.
2. Class
• Is the template or blueprint that defines the states and the behaviors
common to all objects of a certain kind.
• It is a collection of objects of similar type.
• Classes are user-defined data types & behave like the built-in types
of programming language.
 Contd…
3. Data Abstraction
• Abstraction means representing essential features
without including the background details or explanations
• A classes can use the concept of Abstraction and are defined
as list of abstract data and functions to operate on these data.
• Since the classes use the concept of Data Abstraction, they
are known as Abstract Data Type(ADT).
4. Data Encapsulation
• The wrapping up of data and methods into a single unit
(called class) is known as encapsulation.
• This insulation of the data from direct access by the
program is called data hiding.
 Contd…
5. Inheritance
• Is the process by which objects of one class acquire the
properties of objects of another class.
• It provides the idea of reusability( reusing the code)
6. Polymorphism
• In polymorphism, ‘Poly’ means many and ‘morph’ means forms,
i.e. many forms.
• Is the ability to take more than one form. It allows a function
responding in different ways.
7. Dynamic Binding
• Dynamic binding means that the code associated with a
given procedure call is not known until the time of the call at
runtime.
• Memory is allocated at runtime not at compile time.
 Contd…
8. Message Passing
• The process of invoking an operation of an object is called Message
Passing.
• In response to the given message, the respective method or
operation is called.
• OOPs includes objects which communicates by sending/ receiving
information with each other.
• Message Passing involves specifying the name of the object, the
name of the function (message) and the information to be sent.
employee.salary (name);
• A message for an object is a request for the execution of a procedure.
Introduction to Java
• Java is an Object Oriented Programming language developed
by Sun Microsystems in the year 1991.
• Initially it was named as “Oak” by James Gosling
• In 1995, “Oak” is renamed to “Java” because the name “Oak”
did not survive legal registration.
• James Gosling and his team members were consuming a lot of
coffee while developing this language.
• Good quality of coffee was supplied from a place called “Java
Island’. Hence they fixed the name of the language as Java. The
symbol for Java language is cup and saucer.
• Sun formally announced Java at Sun World conference in 1995.
On January 23rd 1996, JDK1.0 version was released.
Features of Java
• Simple: Learning and practicing Java is easy because of
resemblance with C and C++.
• Object Oriented: Unlike C++, Java is purely OOP.
• Distributed: Java is designed for use on network; it has an
extensive library which works in agreement with TCP/IP.
• Secure: Java is designed for use on Internet. Java enables the
construction of virus-free, tamper free systems.
• Robust (Strong/ Powerful): Java programs will not crash
because of its exception handling and its memory management
features.
• Portable: Java does not have implementation dependent
aspects and it gives same result on any machine.
 Contd…
• Interpreted: Java programs are compiled to generate the byte
code(.class file). This byte code can be interpreted by the
interpreter contained in JVM.
• Architectural Neutral Language: Java byte code is not
machine dependent, it can run on any machine with any
processor and with any OS.
• High Performance: Along with interpreter there will be JIT
(Just In Time) compiler which enhances the speed of
execution.
• Multithreaded: Executing different parts of a program
simultaneously is called multithreading. This is an essential
feature to design server side programs.
• Dynamic: We can develop programs in Java which
dynamically change on Internet (e.g.: Applets).
Java Platforms (Editions)
• Platforms of Java are divided into four Java editions,
which are −
Java Environment
• Java Environment includes a large number of development
tools and hundreds of classes and methods.
• The development tools are part of the system known as
Java Development Kit (JDK) and the classes and methods
are part of the Java Standard Library (JSL), also known as
Application Programming Interface (API).
• JDK comes with a collection of tools that are used for
developing and running java programs:
• appleviewer (for viewing java applets )
• javac (java compiler)
• java (java interpreter)
• javap (java disassembler)
• javah (for C header files)
• javadoc (for creating HTML documents)
• jdb (Java debugger)
Java API
• It includes hundreds of classes and methods grouped
into several functional packages.
• Most commonly used packages are:
• Language Support Package: a collection of classes and methods
required for implementing basic features of java.
• Utilities Package: a collection of classes to provide utility functions such
as date and time functions.
• Input/output Package: a collection of classes required for input/output
manipulation.
• Networking Package: a collection of classes for communicating with
other computers via Internet.
• AWT Package (Abstract Window Tool kit package): contains classes that
implements platform-independent graphical user interface.
• Applet Package: includes set of classes that allows us to create java
applets.
Programming Structure
• In Java programming language:
• A program is made up of one or more classes
• A class contains one or more methods
• A method contains program statements
• In Java, first we need to import the required packages. By
default, java.lang.* is imported. Java has several such
packages in its library.
• A package is a kind of directory that contains a group of
related classes and interfaces. A class or interface contains
methods.
• Since Java is purely an Object Oriented Programming
language, we cannot write a Java program without having at
least one class or object. So, it is mandatory to write a class in
Java program. We should use class keyword for this purpose
and then write class name.
 Contd…
// comments about the class
class header
public class Class-name
{

// comments about the method

public static void main (String[] args)
class body
{
method header
method body
}

Comments can be placed almost anywhere

First Java Program
// MyProgram.java
public class Sample
{
public static void main( String args[])
{
System.out.println(“ Hello World! “);
}
}
Let us discuss the program line by line:
• Class Declaration: the first line class Sample declares a class, which
is an object constructor. Class is keyword and declares a new class
definition and Sample is a java identifier that specifies the name of
the class to be defined.
 Contd…
• Braces : Every class definition in java begins with an opening
brace “{“ and ends with a closing brace “}”.
• The main line: the third line public static void main(String args[])
defines a method named as main, is the starting point for the
interpreter to begin the execution of the program.
• public: is an access specifier that declares the main method
as “unprotected” and therefore making it accessible to all other
classes.
• static: declares that this method as one that belongs to the
entire class and not a part of any objects of the class.
• Main must always be declared as static since the interpreter
uses this method before any objects are created.
• void : states that the main method does not return any value
(but prints some text to the screen.)
 Contd…
• All parameters to a method are declared inside a pair of
parenthesis. Here, String args[ ] declares a parameter
named args, which contains array of objects of the class
type String.
• The Output Line: The only executable statement in the
program is System.out.println(“Hello World!” );
• This is similar to cout<< constructor of C++.

• The println method is a member of the out object, which

is a static data member of System class.
Java Program Structure

Documentation Section Suggested

Optional
Package Statement

Optional
Import Statements

Optional
Interface Statements

Class Definitions Optional

Main Method class

{ Essential
Main Method Definition
}
Documentation Section
• Comprises a set of comment lines giving the name of the
program, the author and other details, which the
programmer would like to refer at a later stage.
• Comments are description about the aim and features of
the program.
• Comments increase readability of a program.
• Java supports three types of comments:
1. Single line comment //
2. Multiple line comment /*………………
………………*/
3. Documentation comment /**….*/
• This form of comment is used for generating
documentation automatically.
Package Statement
• Is the first statement in Java file and is optional.
• It declares a package name and informs the compiler that
the classes defined here belong to this package.
Example: package student;

Import statements
• Next to package statements (but before any class
definitions) a number of import statements may exist. This is
similar to #include statements in C or C++.
• Using import statements we can have access to classes that
are part of other named packages.
Example: import java.lang.Math;
Interface Statements
• An interface is like a class but includes a group of method
declarations.
• is also an optional section.
• is used only when we wish to implement the multiple
inheritance features in the program

Class Definitions
• A Java program may contain multiple class definitions.
• Classes are the primary and essential elements of a Java
program.
• These classes are used to map objects of real-world
problems.
• The number of classes depends on the complexity of the
problem.
Main Method
• Since every Java stand-alone program requires a main

method as its starting point, this class is the essential part of

a Java program.

• A simple Java program may contain only this part.

• The main method creates objects of various classes and

establishes communications between them.

• On reaching the end of main, the program terminates and

control passes back to the operating system.

Creating a Source File
• Type the program in a text editor (i.e. Notepad, WordPad,
Microsoft Word or Edit Plus).
• We can launch the Notepad editor from the Start menu by selecting
Programs > Accessories > Notepad. In a new document, type the
above code (i.e. Sample Program).
• Save the program with filename same as Class_name (i.e.
Sample.java) in which main method is written. To do this in
Notepad, first choose the File > Save menu item. Then, in the
Save dialog box:
• Using the Save in combo box, specify the folder (directory)
where you'll save your file.
• In this example, the directory is JQR on the D drive.
• In the File name text field, type "Sample.java", including the
quotation marks. Then the dialog box should look like this:
 Contd…

Now click Save, and exit Notepad.

 Executing the Source File
• To Compile the Sample.java program go to DOS prompt. We can do this
from the Start menu by choosing Run... and then entering cmd. The
window should look similar to the following figure.

• The prompt shows current directory. To compile Sample.java source file,

change current directory to the directory where Sample.java file is located.
For example, if source directory is JQR on the D drive, type the following
commands at the prompt and press Enter:

• Now the prompt should change to D:\JQR>

 Contd…
• At the prompt, type the following command and press
Enter: javac Sample.java

• The compiler generates byte code and Sample.class will

be created.
• To run the program, enter java followed by the class name
created at the time of compilation at the command prompt
in the same directory as: java Sample

• The program interpreted and the output is displayed.

Java Tokens
• A class in java is defined by a set of declaration statements

and methods containing executable statements.

• Most statements contain expressions, which describe the

actions carried out on data.

• Smallest individual units in a program are known as tokens.

• In simplest terms, a java program is a collection of tokens,

comments, and white spaces.

• Java has five types of tokens: Reserved Keywords,

Identifiers, Literals, Separators and Operators .
1. Keywords
• Are essential part of a language definition and can not be
used as names for variables, classes, methods and so on.
• Java language has reserved 60 words as keywords.
2. Identifiers
• Are programmer-designed tokens.

• Are used for naming classes, methods, variables, objects,

labels, packages and interfaces in a program.

• Java identifiers follow the following rules:

• They can have alphabets, digits, and the underscore

and dollar sign characters.

• They must not begin with a digit

• Uppercase and lowercase letters are distinct.

• They can be of any length.

• Which of the following are valid Identifiers?

1)$amount 5) score
2)6tally 6) first Name
3)my*Name 7) total#
4)salary 8) cast
3. Literals
• Literals in Java are a sequence of characters(digits, letters and
other characters) that represent constant values to be stored in
variables.
• Five major types of literals in Java:

I. Integer Literals: refers to a sequence of digits (decimal

integer, octal integer and hexadecimal integer)
II. Floating-point Literals
III.Character Literals
IV.String Literals
V. Boolean Literals
4. Separators
• Are symbols used to indicate where groups of code are divided

and arranged.

• They basically define the shape and functions of our code.

• Java separators include:

I. Parenthesis ( ) :- used to enclose parameters, to define

precedence in expressions, surrounding cast types

II. Braces { } :- used to contain the values of automatically

initialized arrays and to define a block of code for classes,
methods and local scopes.
Contd…
III. Brackets [ ] :- are used to declare array types and for
dereferencing array values.

IV. Semicolon ; :- used to separate statements.

V. Comma , :- used to separate consecutive identifiers in a

variable declaration, also used to chain statements
together inside a “for” statement.

VI. Period . :- Used to separate package names from sub-

package names and classes; also used to separate a
variable or method from a reference variable.
5. Operators
• Are symbols that take one or more arguments (operands)

and operates on them to a produce a result.

• Are used to in programs to manipulate data and variables.

• They usually form a part of mathematical or logical

expressions.

• Expressions can be combinations of variables, primitives

and operators that result in a value.

Java Operators
• There are 8 different groups of operators in Java:
• Arithmetic operators

• Relational operators

• Logical operators

• Assignment operator

• Increment/Decrement operators

• Conditional operators

• Bitwise operators

• Special operators
A. Arithmetic Operators
• Java has five basic arithmetic operators
Operator Meaning
+ Addition or unary plus
– Subtraction or unary minus
* Multiplication
/ Division
% Modulo division

• They all work the same way as they do in other languages.

• We cannot use these operators on boolean type .
• Unlike C and C++, modulus operator can be applied to the
floating point data.
• Order of operations (or precedence) when evaluating an
expression is the same as you learned in school (BODMAS).
B. Relational Operators
• Relational operators compare two values
• Produces a boolean value (true or false) depending on the
relationship.
• Java supports six relational operators:

Operator Meaning
< Is less than
<= Is less than or equal to
> Is greater than
>= Is greater than or equal to
== Is equal to
!= Is not equal to

• Relational expressions are used in decision statements such as,

if and while to decide the course of action of a running program.
Examples of Relational Operations
int x = 3;
int y = 5;
boolean result;

1) result = (x > y);

now result is assigned the value false because 3 is not greater
than 5

2) result = (15 == x*y);

now result is assigned the value true because the product of 3
and 5 equals 15

3) result = (x != x*y);
now result is assigned the value true because the product of x
and y (15) is not equal to x (3)
 C. Logical Operators
Symbol Name
&& Logical AND
|| Logical OR
! Logical NOT

• Logical operators can be referred to as boolean

operators, because they are only used to combine
expressions that have a value of true or false.
• The logical operators && and || are used when we want
to form compound conditions by combining two or more
relations.
• An expression which combines two or more relational
expressions is termed as a logical expression or a
compound relational expression.
Examples of Logical Operators
boolean x = true;
boolean y = false;
boolean result;

1.Let result = (x && y);

now result is assigned the value false

(see truth table!)
2.Let result = ((x || y) && x);
(x || y) evaluates to true
(true && x) evaluates to true
now result is assigned the value true
4. Assignment Operator
• Are used to assign the value of an expression to a
variable.
• In addition to the usual assignment operator(=), java has a
set of ‘shorthand’ assignment operators which are used in
the form:
var op = expr ;
Where var is a variable, op is a binary operator and
expr is an expression. The operator op = is known as
shorthand assignment operator.
• The assignment statement: var op= expr; is
equivalent to var=var op(expr);
• Examples:
x += y + 5; is equivalent to x = x+(y+5);
y *= 7;is equivalent to y = y * 7;
5. Increment/Decrement Operators
count = count + 1;
can be written as:
++count; or count++;
++ is called the increment operator.

count = count - 1;
can be written as:
--count; or count--;
-- is called the decrement operator.

• Both ++ and -- are unary operators.

Increment/Decrement operator has two forms:
• The prefix form ++count, --count
first adds/subtracts1 to/from the variable and then
continues to any other operator in the expression
int numOranges = 5;
int numApples = 10;
int numFruit;
numFruit = ++numOranges + numApples;
numFruit has value 16
numOranges has value 6
• The postfix form count++, count--
first evaluates the expression and then adds 1 to the
variable
int numOranges = 5;
int numApples = 10;
int numFruit;
numFruit = numOranges++ + numApples;
numFruit has value 15
numOranges has value 6
6. Conditional Operators
• The character pair ?: is a ternary operator available in
java.
• It is used to construct conditional expression of the form:
exp1 ? exp2: exp3;
where exp1, exp2 and exp3 are expressions.
• The operator ?: works as follows:
• exp1 is evaluated first. If it is nonzero (true), then the expression
exp2 is evaluated and becomes the value of the conditional
expression. exp3 is evaluated and becomes the value of the
conditional expression if exp1 is false.
• Example:
Given a=10, b=15 the expression
x=(a>b)? a:b; will assign the value of b to x. i.e.
x=b=15;
6. Bitwise Operators
• One of the unique features of java compared to other high-level
languages is that it allows direct manipulation of individual bits
within a word.
• Bitwise operators are used to manipulate data at values of bit
level.
• They are used for testing the bits, or shifting them to the right or
left.
• They may not be applied to float or double data types.

Operator Meaning
& Bitwise AND
| Bitwise OR
^ Bitwise exclusive OR
~ One’s complement
<< Shift left
>> Shift right
>>> Shift right with zero fill
7. Special Operators
• Java supports some special operators of interest such as
instanceof operator and member selection operator(.).

7.1 instanceof Operator: is an object reference operator and

returns true if the object on the left-hand side is an instance of the
class given on the right-hand side.
Example : person instanceof student;
is true if the object person belongs to the class student; otherwise it
is false

7.2 Dot Operator: is used to access the instance variables and

methods of class objects.
Example:
person.age; // Reference to the variable age.
person1.salary(); // Reference to the method salary.
Type Conversion in Expressions
A.Automatic Type Conversion: If the operands of an
expression are of different types, the ‘lower’ type is automatically
converted to the ‘higher’ type before the operation proceeds.

That is, the result is of the ‘higher’ type.

Example :

int a=110;

float b=23.5;

the expression a+b yields a floating point number 133.5 since the
‘higher’ type here is float.
Contd…
B.Casting a value: is used to force type conversion.

 The general form of a cast is:

(type-name)expression;

where type-name is one of the standard data types.

Example :

x=(int)7.5; will assign 7 to x

a=(int)21.3/(int)3.5; a will be 7
Operator Precedence and Associativity.
Operator Description Associativity Rank
. Member Selection
() Function call
Left to right 1
[] Array elements reference
- Unary Minus
++ Increment
-- Decrement
! Logical negation Right to left 2
~ One’s complement
(type) Casting
* Multiplication
/ Division Left to right 3

% Modulus
Contd…
Operator Description Associativity Rank
+ Addition
Left to right 4
- Subtraction
<< Left Shift
>> Right Shift Left to right 5

>>> Right shift with zero fill

< Less than
<= Less than or equal to
> Greater than Left to right 6
>= Greater than or equal to
instanceof Type comparison
== Equality
!= Inequality Left to right 7
Operator Precedence and Associativity
Operator Description Associativity Rank
& Bitwise AND Left to right 8
^ Bitwise XOR Left to right 9
| Bitwise OR Left to right 10

&& Logical AND Left to right 11

|| Logical OR Left to right 12

?: Conditional Left to right 13
Operator
= Assignment Left to right 14
operator
Op= Shorthand Left to right 15
assignment
 QUIZ
1) What is the value of number? -12
int number = 5 * 3 – 3 / 6 – 9 * 3;
2) What is the value of result?
int x = 8; false
int y = 2;
boolean result = (15 == x * y);

3) What is the value of result? true

boolean x = 7;
boolean result = (x < 8) && (x > 4);

4) What is the value of numCars?

int numBlueCars = 5; 27
int numGreenCars = 10;
int numCars = numGreenCars++ + numBlueCars +
++numGreeenCars;
Variables
• A variable is an identifier that denotes a storage location
used to store a data value.
• Unlike constants, that remain unchanged during the
execution of a program, a variable may take different
values at different times during the execution of the
program.
• It is good practice to select variable names that give a
good indication of the sort of data they hold:
• For example, if you want to record the size of a hat,
hatSize is a good choice for a name whereas qqq
would be a bad choice.
Contd…
• Variable names may consist of alphabets, digits, the
underscore (_) and dollar ($) characters, subject to the
following conditions:
1. They should not begin with a digit.
2. Keywords should not be used as a variable name.
3. White spaces are not allowed.
4. Uppercase and lowercase are distinct. i.e. A rose is
not a Rose is not a ROSE.
5. Variable names can be of any length.
Data Types
• Every variable in Java has a data type.

• Data types specify the size and type of values that can
be stored.
• Java language is rich in the data types.

• Java data types are of two type:

 Primitive Data Types (also called intrinsic or built-in data

types)
 Non-Primitive data Types (also known as Derived or
reference types)
 Data Types in Java

Primitive Non-Primitive
(Intrinsic) (Derived)

Numeric Non-Numeric Classes Arrays

Interfaces
Integer Floating-Point Character Boolean

Data Types in Java

Primitive Data Types
 There are eight built-in data types in Java:
• 4 integer types (byte, short, int, long)
• 2 floating point types (float, double)
• Boolean (boolean)
• Character (char)
 All variables must be declared with a data type before
they are used.
 Each variable's declared type does not change over
the course of the program.
A. Integer Data types
 There are four data types that can be used to store integers.
 The one you choose to use depends on the size of the
number that we want to store.
B. Floating-Point Types
 Integer types can hold only whole numbers and therefore
we need another type known as floating point type to hold
numbers containing fractional parts.

 There are two data types that can be used to store decimal
values (real numbers).
C. Character Type
 Is used to store character constants in memory.
 Java provides a character data type called char
 The char data type assumes a size of 2 bytes but, basically,
it can hold only a single character.

 Note that you need to use singular quotation marks while

initializing a variable whose data type is char.
Example:
char firstLetterOfName = 'e' ;
char myQuestion = '?' ;
D. Boolean Type
 Boolean is a data type used when we want to test a
particular condition during the execution of the program.

 There are only two values that a Boolean can take: true or
false.

 Boolean type is denoted by the keyword boolean and uses

only one bit of storage.

 All comparison operators return boolean type values.

 Boolean values are often used in selection and iteration
statements.
Declaration of Variables
 After designing suitable variable names, we must declare them to
the compiler. Declaration does three things:
1. It tells the compiler what the variable name is
2. It specifies what type of data the variable will hold
3. The place of declaration (in the program) declares the scope of the variable.

 A variable must be declared before it is used in the program.

 The general form of declaration of Variables is:
type variable1, variable2,...., variableN;

Example:
int count, x,y; //Declaration
char firstLetterOfName = 'e' ; // Declaration & initialization
 Assigning Values to Variables
 A variable must be given a value after it has been declared
but before it is used in an expression in two ways:
 By using an assignment statement
 By using a read statement
Assignment Statement
 A simple method of giving value to a variable is through the
assignment statement as follows:
variableName = value;
Example: x = 123, y = -34;
 It is possible to assign a value to a variable at the time of
declaration as:
type variableName = value;
Read Statement
 It is also to assign value for variables interactively through
the keyboard using the readLine() method which belongs to
the DataInputStream class.
 The readLine() method reads the input from the keyboard as
a string which is then converted into the corresponding data
type using the data type wrapper classes.
 The wrapper classes are contained in the java.lang
package.
 Wrapper classes wrap a value of the primitive types into an
object.
 The keywords try and catch are used to handle any errors
that might occur during the reading process.
// A program to read data from the Keyboard
import java.io.DataInputStream;
public class Reading{
public static void main(String[] args)
{
DataInputStream in = new DataInputStream(System.in);
int intNumber=0;
float floatNumber=0.0f;
double doubleNumber=0.0;
String Name=null;
try{
System.out.println("Enter your Name: ");
Name=in.readLine();
System.out.println("Enter an Integer Number: ");
intNumber=Integer.parseInt(in.readLine());
System.out.println("Enter a float Number: ");
floatNumber=Float.parseFloat(in.readLine());
System.out.println("Enter a Double Number Number: ");
doubleNumber=Double.parseDouble(in.readLine());
}
catch(Exception e){}
System.out.println("Hello : "+Name);
System.out.println("The Integer Number is : "+intNumber);
System.out.println("The Float Number is : "+floatNumber);
System.out.println("The Double Number is : "+doubleNumber);
}
}
Scope of Variables
1. Instance Variables: are declared in a class, but outside a method,
constructor or any block.
• are created when an object is created with the use of the key word
'new' and destroyed when the object is destroyed.
• They take different values for each object
2. Class Variables: are also known as static variables, are declared with
the static keyword in a class, but outside a method, constructor or a
block.
• Are global to a class and belong to the entire set of objects that
class creates.
• Only one memory location is created for each class variable.
3. Local Variables: are variables declared and used inside methods.
• Can also be declared inside program blocks that are define between
{ and }.
Control Statements
 Generally, the statements inside source programs are
executed from top to bottom, in the order that they appear.
• Control flow statements, however, alter the flow of
execution and provide better control to the programmer on
the flow of execution.
• In Java control statements are categorized into 3 groups:
1. Selection or Decision Making Statements : allow the program to
choose different parts of the execution based on the outcome of an
expression
2. Iteration Statements enable program execution to repeat one or
more statements
3. Jump Statements enable your program to execute in a non-linear
fashion
Selection Statements
• These statements allow us to control the flow of program
execution based on condition.
 Java supports 2 selection statements:
 if statements
 switch statements
If statement:
• It performs a task depending on whether a condition is true or
false.
• It is basically a two-way decision making statement and is used
in conjunction with an expression.
• The if statement may be implemented in different forms
depending on the complexity of conditions to be tested:

Test False
expression
?

True
1. Simple if Statement
 An if statement consists of a Boolean expression followed
by one or more statements.

 The syntax of an if statement is:

if (expression)
{
statement-block;
}
rest_of_program;

• If expression is true, statement-block is executed

and then rest_of_program.
• If expression is false, statement-block will be
skipped & the execution will jump to the
rest_of_program
2. if … else Statement
 The syntax of an if…else statement is:
if (expression)
{
True-block statement(s);
}
else
{
False-block statement(s);
}
rest_of_program;

 If expression is true, True-block statement is executed

and followed by rest_of_program block.

 If expression is false, False-block Statement is executed

followed by rest_of_program block.
3. if … else if (else if Ladder) Statement
 Is used when multiple decisions are involved.
 A multiple decision is a chain of ifs in which the statement
associated with each else is an if.
 The conditions are evaluated from the top(of the ladder),
downwards.
 As soon as the true condition is found, the statement
associated with it is executed and the control will skip the
rest of the ladder.
 When all the conditions become false, then the final else
containing the default statement will be executed.
 The syntax of an if …. else if statement is:
if (expression 1)
{
statement(s)-1;
}
else if (expression 2)
{
statement(s)-2;
}
...
else if (expression n)
{
statement(s)-n;
}
else
default-statement;
rest_of_program;
4. Nested if … else Statement
 if…else statements can be put inside other if…else
statements. such statements are called nested if …
else statements.
 Is used whenever we need to make decisions after
checking a given decision.
 The syntax of a nested if…else statement is shown in
the next slide.
 True-block statement 1.1 is executed if both expression
1 and expression 1.1 are true. But if expression 1 is
true and if expression 1.1 is false, then it is False-
block statement 1.1 which is going to be executed.
if (expression 1)
{
statement(s)-1;
if (expression 1.1)
{
True-block Statement 1.1
} Nested if statement
else
{
False-block Statement 1.1
}
}
else if (expression 2)
{
statement(s)-2;
}
...
else if (expression n)
{
statement(s)-n;
}
else
default-statement;
rest_of_program;
Switch statement
 We can design a program with multiple alternatives using if
statements to control the selection.
 But the complexity of such programs increases dramatically
when the number alternatives increases.
 Java has a multi-way decision statement called switch
statement.
 The switch statement tastes the value of a given
variable(expression) against a list of case values and when a
match is found, a block of statements associated with that
case is executed.
Switch syntax
switch (expression)
{
case value-1:
statement-block 1;
break;
case value-2:
statement-block 2;
break;
......
......
default:
default_statement;
break;
}
rest_of_program
Contd…
 The expression must evaluate to a char, short or int, but not
long, float or double.

 The values value-1, value-2, value-3, … are constants or

constant expressions (evaluable to an integral constant) and
are known as case labels.

 Each of the case labels should be unique within the switch

statement.

 statement-block1,statement-block2,…. Are statement lists

and may contain zero or more statements.
Contd…
 There is no need to put braces around the statement blocks of a switch
statement but it is important to note that case labels end with a colon (:).

 When the switch is executed, the value of the expression is successfully

compared against the values value-1, value-2, ….

 If a case is found whose value matches with the value of the expression,
then the block of the statement(s) that follows the case are executed;
otherwise the default-statement will be executed.

 The break statement at the end of each block signals the end of a
particular case and causes an exit from the switch statement.
The ?: (Conditional) Operator
 Is useful for making a two-way decisions.
 This operator is a combination of ? and : and takes three
operands.

General formula:
conditional expression ? Expression1:expression2;

 The conditional expression is evaluated first. If the result is

true, expression1 is evaluated and is returned as the value of
the conditional expression. Otherwise, expression2 is
evaluated and its value is returned.
Contd…
 For example:
if (x<=40)
if(x<40)
slary=4*x+100; Can be written as:
salary=(x!=40)? (x<40)?
else
(4*x+100):(4.5*x+100)):300;
salary=300;
else
slary=4.5*x+100;
 When the conditional operator is used, the code becomes
more concise and perhaps, more efficient. However, the
reliability is poor.
 It is better to use if statement when more than a single
nesting of conditional operator is required.
Iterative/Loop Statements
 The process of repeatedly executing a block of statements is
known as looping.
 A loop allows you to execute a statement or block of
statements repeatedly until a termination condition is met.
 The statements in the block may be executed any number of
times, from zero to infinite number.
 If a loop continues forever, it is called an infinite loop.
 A program loop consists of two statements:
 Body of the loop.
 Control statements.
 A looping process, in general, would include the four steps:
1. Setting and initialization of a counter .
2. Execution of the statements in the loop.
3. Test for a specified condition for execution of the loop.
4. Increment/Decrement the counter.
Contd…
• Depending on the position of the control statement in the
loop, a control structure can be either as the entry-
controlled loop or as exit-controlled loop.
• In entry-controlled loop, the control conditions are tested
before the start of the loop execution.
• In exit-controlled loop, the test is performed at the end of
the body of the loop and therefore the body is executed
unconditionally for the first time.
 Three types of loops in java:
1.while loops
2.do …while loops
3.for loops
1. The while loop
 Is the simplest of all the looping structures in Java.
 The while loop is an entry-controlled loop statement.
 The while loop executes as long as the given logical
expression between parentheses is true. When expression
is false, execution continues with the statement
immediately after the body of the loop block.
 The expression is tested at the beginning of the loop, so if
it is initially false, the loop will not be executed at all.
 The basic format of the while statement is:
Example:
initialization; int sum=0,n=1;
while (expression) while(n<=100)
{
{
sum+=n;
Body of the loop;
n++;
}
}
System.out.println(“Sum=“+sum;)
Contd…
 The body of the loop may have one or more statements.
 The braces are needed only if the body contains two or
more statements. However it is a good practice to use
braces even if the body has only one statement.

2. The do…while loop

 Unlike the while statement, the do… while loop executes
the body of the loop before the test is performed.
Syntax:
initialization;
do
{
Body of the loop;
}
while (expression);
Contd…
 On reaching the do statement, the program proceeds to evaluate
the body of loop first.
 At the end of the loop, the test condition in the while statement is
evaluated. If it is true, the program continues to evaluate the body
of the loop once again.
 When the condition becomes false, the loop will be terminated
and the control goes to the statement that appears immediately
after the while statement.
 The while loop is an exit-controlled loop statement.
Example:
int sum=0,n=1;
do
{
sum+=n;
n++;
} while(n<=100);
System.out.println(“Sum=“+sum);
3. The for loop
 Is another entry-controlled loop that provides a more
concise loop controlled structure.
 Syntax for the for loop is:

for(initialization; test condition; increment)

{
Body of the loop;
}

 We use the for loop if we know in advance for how many

times the body of the loop is going to be executed.
 But use do…. while loop if you know the body of the loop is
going to be executed at least once.
Contd…
 The execution of the for loop statement is as follows:
1. Initialization of the control variable(s) is done first, using assignment
statement.
2. The value of the control variable is tested using the test condition. The
test condition is a relation operation that determines when the loop
will exit.
 If the condition is true, the body of the loop is executed;
otherwise the loop is terminated and the execution continues with
the statement that immediately follows the loop.
3. When the body of the loop is executed, the control is transferred back
to the for statement after evaluating the last statement in the loop.
 Now the new value of the control variable is again tested to see
whether it satisfies the loop condition; if it does, the body of the
loop is again executed.
Contd…
int sum=0;
Example
for(n=1; n<=100; n++)
{
sum=sum+n;
}
System.out.println(“Sum is:”+sum);

Additional Features of for loop

A. More than one variable, separated by comma, can be
initialized at a time in the for statement.
Example:
for(sum=0, i=1; i<=100; i++)
{
sum=sum+i;
}
Contd…
B. Increment section may also have more than one part.
Example:
for(i=0, j=0; i*j < 100; i++, j+=2)
{
System.out.println(i * j);
}
C. The test condition may have any compound relation and the testing
need not be limited only to the loop control variable.

Example:
for(sum=0, i=1; i<20 && sum<100; ++i)
{
sum=sum+i;
}
Contd…
D. You do not have to fill all three control sections, one or
more sections can be omitted but you must still have two
semicolons.
Example:
int n = 0;
for(; n != 100;) {
System.out.println(++n);
}
Nesting of for loops
 You can nest loops of any kind one inside another to any
depth.
Example:
for(int i = 10; i > 0; i--)
{
while (i > 3)
{
if(i == 5){ Inner Outer
break; Loop Loop
}
System.out.println(i);
i--;
}
System.out.println(i*2);
}
Jumps in Loops
 Jump statements are used to unconditionally transfer the
program control to another part of the program.
 Java has three jump statements: break, continue, and return.
1. The break statement
• A break statement is used to abort the execution of a loop. The
general form of the break statement is given below:
break label;
• It may be used with or without a label.
• When it is used without a label, it aborts the execution of the
innermost switch, for, do, or while statement enclosing the
break statement. When used with a label, the break statement
aborts the execution of any enclosing statement matching the
label.
• A label is an identifier that uniquely identifies a block of code.
Examples

1. Outer: for( int k=1; k< 10; k++){

int i=k;
while ( i < 5) {
if(i%5==0) break Outer; // jump out of both loops
System.out.print(“ “+i);
i++;
}
System.out.println(“Outer Loop”);
}
2. int i=1;
while ( i < 10) {
if(i%2==0) break;
System.out.println(“ “+i);
}
System.out.println(“Out of the while loop”);
2. The continue statement
• is used to alter the execution of the for, do, and while

statements.

• The general form of the continue statement is:

continue label;

• It may be used with or without a label. When used without a

label, it causes the statement block of the innermost for, do, or

while statement to terminate and the loop’s boolean
expression to be re-evaluated to determine whether the next
loop repetition should take place.
Contd…
• When it is used with a label, the continue statement
transfers control to an enclosing for, do, or while statement
matching the label.
Example:
int sum = 0;
for(int i = 1; i <= 10; i++)
{
if(i % 3 == 0)
{
continue;
}
sum += i;
}
What is the value of sum?
1 + 2 + 4 + 5 + 7 + 8 + 10 = 37
3. The return Statement
• A return statement is used to transfer the program control to

the caller of a method.

• The general form of the return statement is given below:

return expression;

• If the method is declared to return a value, the expression

used after the return statement must evaluate to the return

type of that method. Otherwise, the expression is omitted.
Contd…
2. Write a Java application program that asks the user to enter an
integer number from the keyboard and computes the sum of the digits
of the number. [ Hint: if the user types 4567as input , then the output will be 22 ]
3. Given a number, write a program using while loop to reverse the
digits of the number. [ Hint: Use Modulus Operator to extract the last digit and the
integer division by 10 to get the n-1 digit number from the n digit]
4. Using a two-dimensional array, write codes that could print the
following outputs? c) 5
a) 454
$ $ $ $ $ 34543
$ $ $ $ 2345432
$ $ $ 123454321
$ $
$
b) 1 d) 1 2 3 4 5 4 3 2 1
1 2 1234321
1 2 3 12321
1 2 3 4 121
1 2 3 4 5 1
Arrays
 An array is a group of contiguous or related data items that
share a common name.
 is a container object that holds a fixed number of values of a
single type.
 Unlike C++ in Java arrays are created dynamically.
 An array can hold only one type of data!
Example:
int[] can hold only integers
char[] can hold only characters
• A particular values in an array is indicated by writing a number
called index number or subscript in brackets after the array
name.
Example:
salary[10] represents salary of the 10th employee.
Contd…
• The length of an array is established when the array is

created. After creation, its length is fixed.

• Each item in an array is called an element, and each element

is accessed by its numerical index.

• Array indexing starts from 0 and ends at n-1, where n is the

size of the array.

index values

primes[0] primes[1] primes[2] primes[3] primes[4] primes[9]

 One-Dimensional Arrays
• A list of items can be given one variable name using only
one subscript and such a variable is called a single-
subscripted variable or a one-dimensional array.

Creating an Array
 Like any other variables, arrays must be declared and
created in the computer memory before they are used.
 Array creation involves three steps:
1. Declare an array Variable
2. Create Memory Locations
3. Put values into the memory locations.
 1. Declaration of Arrays
• Arrays in java can be declared in two ways:
i. type arrayname [ ];
ii. type[ ]arrayname;

Example:
int number[];
float slaray[];
float[] marks;
• when creating an array, each element of the array receives

a default value zero (for numeric types) ,false for boolean

and null for references (any non primitive types).
 2. Creation of Arrays
• After declaring an array, we need to create it in the
memory.
• Because an array is an object, you create it by using the
new keyword as follows:
arrayname =new type[ size];
Example:
number=new int[5];
marks= new float[7];
• It is also possible to combine the above to steps , declaration
and creation, into on statement as follows:
type arrayname =new type[ size];
Example: int num[ ] = new int[10];
3. Initialization of Arrays
• Each element of an array needs to be assigned a value;
this process is known as initialization.
• Initialization of an array is done using the array subscripts as
follows:
• arrayname [subscript] = Value;
Example:
number [0]=23;
number[2]=40;
• Unlike C, java protects arrays from overruns and underruns.

• Trying to access an array beyond its boundaries will generate

an error.
Contd.
• Java generates an ArrayIndexOutOfBoundsException when

there is underrun or overrun.

• The Java interpreter checks array indices to ensure that they

are valid during execution.

• Arrays can also be initialized automatically in the same way as

the ordinary variables when they are declared, as shown below:

type arrayname [] = {list of Values};
Example:
int number[]= {35,40,23,67,49};
Contd.
• It is also possible to assign an array object to another array
object.
Example:
int array1[]= {35,40,23,67,49};
int array2[];
array2= array1;
Array Length
 In Java, all arrays store the allocated size in a variable
named length.
 We can access the length of the array array1using
array1.length. Example:
int size = array1.length;
 if (num[i] < num [j])
//sorting of a list of Numbers {
class Sorting //Interchange Values
{
int temp = num[i];
public static void main(String [ ]args)
{ num [i] = num [j];
int num[ ]= {55, 40, 80, 12, 65, 77}; num [j] = temp;
int size = num.length;
System.out.print(“Given List: “); }
for (int i=0; i<size; i++) }
{ }
System.out.print(" " + num[ i ] );
} System.out.print("SORTED LIST"
System.out.print("\n"); );
//Sorting Begins for (int i=0; i<size; i++)
for (int i=0; i<size; i++)
{
{
for (int j=i+1; j<size; j++) System.out.print(" " " + num
{ [i]);
}
System.out.println(" ");
Two-Dimensional Arrays
• A 2-dimensional array can be thought of as a grid (or matrix) of

values.
• Each element of the 2-D array is accessed by providing two

indexes: a row index and a column index

• A 2-D array is actually just an array of arrays.

• A multidimensional array with the same number of columns in

every row can be created with an array creation expression:

Example:
int myarray[][]= int [3][4];
Contd…
• Like the one-dimensional arrays, two-dimensional arrays may be

initialized by following their declaration with a list of initial values

enclosed in braces. For example,
int myarray[2][3]= {0,0,0,1,1,1};
or
int myarray[][]= {{0,0,0},{1,1,1}};
• We can refer to a value stored in a two-dimensional array by using

indexes for both the column and row of the corresponding element.
For Example,
int value = myarray[1][2];
Contd…
//Application of two-dimensional Array
class MulTable{
final static int ROWS=12;
final static int COLUMNS=12;
public static void main(String [ ]args) {
int pro [ ] [ ]= new int [ROWS][COLUMNS];
int i=0,j=0;
System.out.print("MULTIPLICATION TABLE");
System.out.println(" ");
for (i=1; i<ROWS; i++)
{
for (j=1; j<COLUMNS; j++)
{
pro [i][j]= i * j;
System.out.print(" "+ pro [i][j]);
}
System.out.println(" " );
}
}
}
Strings
• Strings represent a sequence of characters.
• The easiest way to represent a sequence of characters in
Java is by using a character:
char ch[ ]= new char[4];
ch[0] = ‘D’;
ch[1] = ‘a’;
ch[2] = ‘t;
ch[3] = ‘a;
• This is equivalent to String ch=“Hello”;
• Character arrays have the advantage of being able to query
their length.
• But they are not good enough to support the range of
operations we may like to perform on strings.
Contd…
• In Java, strings are class objects and are implemented using
two classes:
 String class
 StringBuffer
• Once a String object is created it cannot be changed. Strings
are Immutable.
• To get changeable strings use the StringBuffer class.
• A Java string is an instantiated object of the String class.
• Java strings are more reliable and predictable than C++
strings.
• A java string is not a character array and is not NULL
terminated.
Contd…
• In Java, strings are declared and created as follows:

String stringName;
stringName= new String(“String”);
Example:
String firstName;
firstName = new String(“Jhon”);
• The above two statements can be combined as follows:

String firstName= new String(“Jhon”);

• The length() method returns the length of a string.

Example: firstName.length(); //returns 4

String Arrays
• It is possible to create and use arrays that contain strings as

follows:
String arrayname[] = new String[size];
Example:
String item[]= new String[3];
item[0]= “Orange”;
item[1]= “Banana”;
item[2]= “Apple”;
• It is also possible to assign a string array object to another

string array object.

String Methods
1. The length(); method returns the length of the string.
Eg: System.out.println(“Hello”.length()); // prints 5
 The + operator is used to concatenate two or more strings.
Eg: String myname = “Harry”
String str = “My name is” + myname+ “.”;
2. The charAt(); method returns the character at the
specified index.
Syntax : public char charAt(int index)
Ex: char ch;
ch = “abc”.charAt(1); // ch = “b”
Contd…
3. The equals(); method returns ‘true’ if two strings are
equal.
Syntax : public boolean equals(Object anObject)
Ex: String str1=“Hello”,str2=“hello”;
(str1.equals(str2))? System.out.println(“Equal”); : System.out.println(“Not
Equal”); // prints Not Equal
4. The equalsIgnoreCase(); method returns ‘true’ if two
strings are equal, ignoring case consideration.
Syntax : public boolean equalsIgnoreCase(String str)
Ex: String str1=“Hello”,str2=“hello”;
if (str1.equalsIgnoreCase(str2))
System.out.println(“Equal”);
System.out.println(“Not Equal”); // prints Equal as an output
Contd…
5. The toLowerCase(); method converts all of the characters in
a String to lower case.
Syntax : public String toLowerCase( );
Ex: String str1=“HELLO THERE”;
System.out.println(str1.toLowerCase()); // prints hello there
6. The toUpperCase(); method converts all of the characters in
a String to upper case.
Syntax : : public String toUpperCase( );
Ex: System.out.println(“wel-come”.toUpperCase()); // prints WEL-
COME
7. The trim(); method removes white spaces at the beginning
and end of a string.
Syntax : public String trim( );
Ex: System.out.println(“ wel-come ”.trim()); //prints wel-come
Contd…
8. The replace(); method replaces all appearances of a given
character with another character.
Syntax : public String replace( ‘ch1’, ’ch2’);
Ex: String str1=“Hello”;
System.out.println(str1.replace(‘l’, ‘m’)); // prints Hemmo
9. compareTo(); method Compares two strings lexicographically.
• The result is a negative integer if the first String is less than the second
string.
• It returns a positive integer if the first String is greater than the second
string. Otherwise the result is zero.
Syntax : public int compareTo(String anotherString);
public int compareToIgnoreCase(String str);
Ex: (“hello”.compareTo(“Hello”)==0) ? System.out.println(“Equla”); :
System.out.println(“Not Equal”); //prints Not Equal
Contd…
10. The concat(); method concatenates the specified string to
the end of this string.
Syntax : public String concat(String str)
Ex: System.out.println("to".concat("get").concat("her“)); // returns
together
Contd…
12. The substring(); method creates a substring starting from
the specified index (nth character) until the end of the string
or until the specified end index.
Syntax : public String substring(int beginIndex);
public String substring(int beginIndex, int endIndex);
Ex: "smiles".substring(2); //returns "ile“
"smiles".substring(1, 5); //returns "mile“
13. The startsWith(); Tests if this string starts with the specified
prefix.
Syntax: public boolean startsWith(String prefix);
Ex: “Figure”.startsWith(“Fig”); // returns true
14. The indexOf(); method returns the position of the first
occurrence of a character in a string either starting from the
beginning of the string or starting from a specific position.
Contd.
 public int indexOf(int ch); Returns the index of the first
occurrence of the character within this string starting
from the first position.
 public int indexOf(String str); - Returns the index of the
first occurrence of the specified substring within this
string.
 public int indexOf(char ch, int n); - Returns the index of
the first occurrence of the character within this string
starting from the nth position.
Ex: String str = “How was your day today?”;
str.indexOf(‘t’); // prints 17
str.indexOf(‘y’, 17); // prints 21
str.indexOf(“was”); // Prints 4
str.indexOf("day",10)); //Prints 13
Contd…
15. The lastIndexOf(); method Searches for the last occurrence of
a character or substring.
 The methods are similar to indexOf() method.
16. valueOf(); creates a string object if the parameter or converts the
parameter value to string representation if the parameter is a
variable.
Syntax: public String valueOf(variable);
public String valueOf(variable);
Ex: char x[]={'H','e', 'l', 'l','o'};
System.out.println(String.valueOf(x));//prints Hello
System.out.println(String.valueOf(48.958)); // prints 48.958

17. endsWith(); Tests if this string ends with the specified suffix.
Syntax: public boolean endsWith(String suffix);
Ex: “Figure”.endsWith(“re”); // true
Exercise
1. Consider a two-by-three integer two-dimensional array named array3.
a) Write a statement that declares and creates array3.
b) Write a single statement that sets the elements of array3 in row 1 and
column 2 as zero.
c) Write a series of statements that initializes each element of array3 to
1.
d) Write a nested for statement that initializes each element of array3 to
two.
e) Write a nested for statement that inputs the values for the elements
of array3 from the user.
f) Write a series of statements that determines and prints the smallest
value in array3.
g) Write a statement that displays the elements of the first row of array3.
h) Write a statement that totals the elements of the third column array3.
Contd…
2. Write a Java application program which adds all the numbers ,
except those numbers which are multiples of three, between 1 and
100. (Hint: use continue statement)

3. Write a program which reads the values for two matrices and
displays their product.

4. Write a program, which will read a string and rewrite it in

alphabetical order.

5. Write a java application program which reads a paragraph and

displays the number of words within the paragraph.
THANK YOU