Java Foundation with Data Structures

Lecture 2 : Getting Started

a) About Eclipse

Eclipse is an integrated development environment (IDE) for developing

applications using the Java programming language and many other programming
languages. The Java Development Tools (JDT) project provides a plug-in that
allows Eclipse to be used as a Java IDE.

A new Java class can be created using the New Java Class wizard. The Java Class
wizard can be invoked in different ways –
1. By clicking on the File menu and selecting New → Class, or
2. By right clicking in the package explorer and selecting New → Class, or
3. By clicking on the class drop down button and selecting class.

Note : W​ e will understand what classes are when we will study Object Oriented
Programming. For now you can assume them as a file. Also name of class and
.java file inside which we have this class should be same.

b) About Main

Consider the following line of code:

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

1. This is the line at which the program will begin executing. This statement
is similar to start block in flowcharts. All Java programs begin execution
by calling main()
2. We will understand what public, static, void mean in subsequent
lectures. For now we should assume that we have to write main as it is.
3. The curly braces {} indicate start and end of main.

c) print / println

In order to print things to console we have to write - System.​out​.println("Hello

World"). Again for now we should leave System.out.print mean, and should write
it as it is.
The built-in method print() is used to display the string which is passed to it. This
output string is not followed by a newline, i.e., the next output will start on the
same line. The built-in method println() is similar to print(), except that println()
outputs a newline after each call.
Example Code:

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

System.​out​.println("Hello World");
System.​out​.println("Programming is fun");
}

Output:
Hello World
Programming is fun

Variables
a) Add two numbers

Consider the following code for adding two numbers

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

int num1 = 10;
int num2 = 5;
int ans = num1 + num2;
System.​out​.println("Sum =" +ans);
}

Output:
15

Here, we used variables to store values of two integers and their sum. Thus, a
variable is a basic unit of storage in a Java program.

Syntax for Declaring a Variable:

type variable_name [ = value];

Here, type is one of Java’s primitive datatypes. The variable_name is the name of
a variable. We can initialize the variable by specifying an equal sign and a value
(Initialization is optional). However, the compiler never assigns a default value to
an uninitialized local variable in Java.

While writing variable names you should be careful and follow the rules for
naming them. Following are the rules for writing variable names -
 1. All variable names may contain uppercase and lowercase letters (a-z, A-Z),
underscore ( _ ), dollar sign ($) and the digits 0 to 9. The dollar sign character
is not intended for general use. No spaces and no other special characters
are allowed.
2. The variable names must not begin with a number.
3. Java is case-sensitive. Uppercase characters are distinct from lowercase
characters.
4. A Java keyword (reserved word) cannot be used as a variable name.

b) Data types of variables

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, we can store integers, decimals, or characters in
these variables.

There are eight primitive data types in Java:

DATA TYPE DEFAULT VALUE DEFAULT SIZE

char '\0' (null 2 bytes

character)
byte 0 1 byte
short 0 2 bytes
int 0 4 bytes
long 0L 8 bytes
Float 0.0f 4 bytes
Double 0.0d 8 bytes
Boolean false Not specified

c) Code for calculating Simple Interest

Example Code:

public class SimpleInterest {

public static void main​(String[] args) {
double principal = 2500.0, rate = 6.0, time = 5.0;
double si = (principal * rate * time) / 100;
System.​out​.println("Simple Interest = " + si);
}
}
 Output:
Simple Interest = 750.0

Taking Input
a) Scanner

The Java Scanner class breaks the input into tokens using a delimiter that is
whitespace by default. It provides many ways to read and parse various
primitive values.
In order to use scanner you have to write this import statement at the top –
import java.util.Scanner;

Example Code:

//Code for adding two integers entered by the user

import java.util.Scanner;
class AddTwoNumbers
{
public static void ​main(String args[])
{
int a, b, c;
System.​out​.println("Enter two integers to calculate their sum: ");

// Create a Scanner
Scanner s = new Scanner(System.​in​);
a = s.nextInt();
b = s.nextInt();
c = a + b;
System.​out​.println("Sum of entered integers = "+c);
}
}

Sample Input:
10 5
Output:
15
Here, s.nextInt() scans and returns the next token as int. A token is part of entered
line that is separated from other tokens by space, tab or newline. So when input
line is: “10 5” then s.nextInt() returns the first token i.e. “10” as int and s.nextInt()
again ​returns the next token i.e. “5” as int.
b) Code for calculating simple interest taking input from user

Example Code:

import java.util.Scanner;

public class SimpleInterest {

public static void main​(String[] args) {
Scanner input = new Scanner(System.​in​);
double si, principal, rate, time;
principal = input.nextDouble();
rate = input.nextDouble();
time = input.nextDouble();
si = (principal * rate * time) / 100;
System.​out​.println("Simple Interest= " + si);
}
}

Sample Input:
2500.0 6.0 5.0

Output:
750.0

c) Taking character input

To read a character as input, we use next().charAt(0). The next() function returns

the next token in the input as a string and charAt(0) function returns the first
character in that string.

Example code to read a character as input:

import java.util.Scanner;
public class ScannerDemo1 {
public static void main​(String[] args) {
Scanner s = new Scanner(System.​in​);
char ch = s.next().charAt(0); // character input
System.​out​.println("input character = " +ch);
}
}

Sample Input:
k
Output:
input character = k

Example code to take a string as input:

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

Scanner s = new Scanner(System.​in​);
String str;
str = s.next();
System.​out​.print(str);
}

Sample Input:
Coding Ninjas
Output:
Coding

Here, s.next() returns the next token as String. A token is part of entered line that
is separated from other tokens by space, tab or newline. So when input line is -
“Coding Ninjas” then s.next() returns the first token i.e. “Coding”.

d) Other scanner options

Some commonly used Scanner class methods are as follows:

METHOD DESCRIPTION

public String next() It returns the next token from the Scanner.
public String nextLine() It moves the Scanner position to the next line
and returns the value as a string.
public byte nextByte() It scans the next token as a byte.
public short nextShort() It scans the next token as a short value.
public int nextInt() It scans the next token as an int value.
public long nextLong() It scans the next token as a long value.
public float nextFloat() It scans the next token as a float value.
public double It scans the next token as a double value.
nextDouble()

Example code:

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

Scanner s = new Scanner(System.​in​);
int a = s.nextInt();
 String str = s.nextLine();
System.out.println(a);
System.out.println(str);
}

Sample Input:
100 Hello World
Output:
100
Hello World

Here, s.nextInt() scans and returns the next token as int. A token is part of entered
line that is separated from other tokens by space, tab or newline. So when input
line is - “100 Hello World” then s.nextInt() returns the first token as int i.e. “100”
and s.nextLine() returns remaining part of line i.e “ (space)Hello World”

How is Data Stored ?

a) How are integers stored ?

The most commonly used integer type is int which is a signed 32-bit type.
When you store an integer, its corresponding binary value is stored. The way
integers are stored differs for negative and positive numbers. For positive
numbers the integral value is simple converted into binary value and for negative
numbers their 2’s compliment form is stored.
Let’s discuss How are Negative Numbers Stored?

Computers use 2's complement in representing signed integers because:

1. There is only one representation for the number zero in 2's complement,
instead of two representations in sign-magnitude and 1's complement.

2. Positive and negative integers can be treated together in addition and

subtraction. Subtraction can be carried out using the "addition logic".

Example:

int i = -4;
Steps to calculate Two’s Complement of -4 are as follows:

Step 1: Take Binary Equivalent of the positive value (4 in this case)

0000 0000 0000 0000 0000 0000 0000 0100
Step 2: Write 1's complement of the binary representation by inverting the bits

1111 1111 1111 1111 1111 1111 1111 1011

Step 3: Find 2's complement by adding 1 to the corresponding 1's complement

1111 1111 1111 1111 1111 1111 1111 1011

+0000 0000 0000 0000 0000 0000 0000 0001
------------------------------------------------------------
1111 1111 1111 1111 1111 1111 1111 1100

Thus, integer -4 is represented by the binary sequence (1111 1111 1111 1111
1111 1111 1111 1100) in Java.

b) Float and Double values

In Java, any value declared with decimal point is by default of type double (which
is of 8 bytes). If we want to assign a float value (which is of 4 bytes), then we must
use ‘f’ or ‘F’ literal to specify that current value is “float”.

Example:
float float_val = 10.4f; //float value
double val = 10.4; //double value

c) How are characters stored

Java uses Unicode to represent characters. As we know system only understands

binary language and thus everything has to be stored in the form binaries. So for
every character there is corresponding code – Unicode/ASCII code and binary
equivalent of this code is actually stored in memory when we try to store a char.
Unicode defines a fully international character set that can represent all the
characters found in all human languages. In Java, char is a 16-bit type. The range
of a char is 0 to 65,536.

Example code:

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

char ch1, ch2;
ch1 = 88; //ASCII value for ‘X’
ch2 = ‘Y’;
System.out.println(ch1 +" " +ch2);
}
Output:
XY

Adding int to char

When we add int to char, we are basically adding two numbers i.e. one
corresponding to the integer and other is corresponding code for the char.

Example code:

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

System.out.println(‘a’ + 1);
}

Output:
98

Here, we added a character and an int, so it added the ASCII value of char ‘a’ i.e
97 and int 1. So, answer will be 98.

Similar logic applies to adding two chars as well, when two chars are added their
codes are actually added i.e. ‘a’ + ‘b’ wil give 195.

Typecasting

1. Widening or Automatic type conversion:

In Java, automatic type conversion takes place when the two types are compatible
and size of destination type is larger than source type.

2. Narrowing or Explicit type conversion:

When we are assigning a larger type value to a variable of smaller type, then we
need to perform explicit type casting.

Example code:

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

int i = 100;
long l1 = i; //automatic type casting

double d = 100.04;
long l2 = (long)d; //explicit type casting
System.out.println(i);
System.out.println(l1);
 System.out.println(d);
System.out.println(l2);
}

Output:
100
100
100.04
100

Operators
a) Arithmetic operators

Arithmetic operators are used in mathematical expression in the same way that
are used in algebra.

OPERATOR DESCRIPTION
+ Adds two operands
- Subtracts second operand from first
* Multiplies two operands
/ Divides numerator by denominator
% Calculates Remainder of division

b) Relational operators

Relational Operators are the operators that used to test some king of relation
between two entities. The following table lists the relation operators supported
by Java.

OPERATOR DESCRIPTION
== Check if two operands are equal
!= Check if two operands are not equal.
> Check if operand on the left is greater than operand on
the right
< Check if operand on the left is smaller than right
operand
>= Check if left operand is greater than or equal to right
operand
<= Check if operand on left is smaller than or equal to right
operand
 c) Logical operators

Java supports following 3 logical operators. The result of logical operators is a

Boolean i.e. true or false.

OPERATOR DESCRIPTION
&& al AND
|| al OR
! al NOT

Example:
Suppose a = true and b= false, then:
(a && b) is false
(a || b) is true
(!a) is false
 Java Foundation with Data Structures
Lecture 4 : Loops, Keywords, Associativity and Precedence

for loop
Loop statements allows us to execute a block of statements several number of
times depending on certain condition. ​for ​loop is kind of loop in which we give
initialization statement, test expression and update statement can be written in
one line.

Inside for, three statements are written –

a. Initialization – used to initialize your loop control variables. This statement is
executed first and only once.
b. Test condition – this condition is checked everytime we enter the loop.
Statements inside the loop are executed till this condition evaluates to true. As
soon as condition evaluates to false, loop terminates and then first statement
after for loop will be executed next.
c. Updation – this statement updates the loop control variable after every
execution of statements inside loop. After updation, again test conditon is
checked. If that comes true, the loop executes and process repeats. And if
condition is false, the loop terminates.

for​ (​initializationStatement​; test_expression; ​updateStatement​) {

// Statements to be executed till test_expression is true
}

Example Code :

public​ ​static​ v​ oid​ main(String[] args) {

​for​(​int​ i = 0; i < 3; i++) {
System.​out.​ print(​"Inside for loop : "​);
System.​out.​ println(i);
}
System.​out.​ println(​"Done"​);
}
 Output:
Inside for Loop : 0
Inside for Loop : 1
Inside for Loop : 2
Done

In for loop its not compulsory to write all three statements i.e.
initializationStatement, ​test_expression and u​ pdateStatement. We can skip one
or more of them (even all three)

Above code can be written as:

public​ ​static​ v​ oid​ main(String[] args) {
int i = 1; //initialization is done outside the for loop
​for​(; i < =5; i++) {
System.​out.​ println(i);
}
}

OR
public​ ​static​ v​ oid​ main(String[] args) {
int i = 1; //initialization is done outside the for loop
​for​(; i < =5; ) {
System.​out.​ println(i);
i++; // update Statement written here
}
}

We can also skip the test_expression. See the example below :

Variations of for loop

● The three expressions inside for loop are optional. That means, they can be
omitted as per requirement.

Example code 1: ​Initialization part removed –

public​ ​static​ v​ oid​ main(String[] args) {

​int​ i = 0;
​for​( ; i < 3; i++) {
System.​out​.println(i);
 }
}

Output:
0
1
2

Example code 2: ​Updation part removed

public​ ​static​ v​ oid​ main(String[] args) {

​for​(​int​ i = 0; i < 3; ) {
System.​out.​ println(i);
i++;
}
}

Output:
0
1
2

Example code 3: ​Condition expression removed , thus making our loop infinite –

public​ ​static​ v​ oid​ main(String[] args) {

​for​(​int​ i = 0; ; i++) {
System.​out​.println(i);
}
}

Example code 4:
We can remove all the three expression, thus forming an infinite loop-

public​ ​static​ v​ oid​ main(String[] args) {

​for​( ; ; ) {
System.​out.​ print(​"Inside for loop"​);
}
}
● Multiple statements inside for loop

We can initialize multiple variables, have multiple conditions and multiple update
statements inside a ​for loop​. We can separate multiple statements using
comma, but not for conditions. They need to be combined using logical
operators.

Example code:

public​ ​static​ v​ oid​ main(String[] args) {

​for​(​int​ i = 0, j = 4; i < 5 && j >= 0; i++, j--) {
System.​out.​ println(i + ​" "​ + j);
}
}

Output:

04
13
22
31
40

break and​ c​ ontinue

1. break statement​: ​The break statement terminates the loop (for, while and
do. while loop) immediately when it is encountered. As soon as break is
encountered inside a loop, the loop terminates immediately. Hence the
statement after loop will be executed next.
2. continue statement: ​The continue statement skips some statements inside
the loop. The continue statement is used with decision making statement
such as if...else. (caution always update the counter in case of while loop
else loop will never end)
while​(test_expression) {
// codes
if (condition for break) {
break​;
}
//codes
 }

for​ (​initializationStatement​; test_expression; ​updateStatement​) {

// codes
if (condition for break) {
break​;
}
//codes
}
❖ break
● Example: (using break inside for loop)
public​ ​static​ v​ oid​ main(String[] args) {
​for​(​int​ i = 1; i < 10; i++) {
System.​out.​ println(i);
​if​(i == 5) {
​break​;
}
}
}

Output:
1
2
3
4
5

● Example: (using break inside while loop)

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

int​ i = 1;
while​ (i <= 10) {
System.​out​.println(i);
if(i==5)
{
break​;
}
i++;
}
}

Output​:

1
2
3
4
5

● Inner loop break:

When there are two more loops inside one another. Break from innermost loop
will just exit that loop.

Example Code 1:

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

for (int i=1;​ i <=3; i++) {
System.​out.​ println(i);
for (int j=1;​ j<= 5; j++)
{
System.​out​.println(​“in”​);
if(j==1)
{
break​;
}
}
}
}
Output:
1
in…
2
in…
3
in…

Example Code 2:
public​ ​static​ ​void​ main(String[] args) {
int i=1;
while (​i <=3) {
System.​out.​ println(i);
int j=1;
while (j​ <= 5)
{
System.​out.​ println(​“in”​);
if(j==1)
{
break​;
}
j++;
}
i++;
}
}

Output:
1
in…
2
in…
3
in…

❖ Continue
The ​continue​ keyword can be used in any of the loop control structures. It causes
the loop to immediately jump to the next iteration of the loop.

● Example: (using for loop)

public​ ​static​ ​void​ main(String[] args){
for (int i=1;​ i <= 5; i++) {
if(i==3)
{
continue​;
}
 System.​out.​ println(i);
}
}

Output:
1
2
4
5

● Example: (using while loop)

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

int i=1;
while (​i <= 5) {
if(i==3)
{
i++;
// if increment isn’t done here then loop will run
infinite time for i=3
continue​;
}
System.​out.​ println(i);
i++;
}
}

Output​:
1
2
4
5

Scope of variables
Scope of variables is the curly brackets {} inside which they are defined. Outside
which they aren’t known to the compiler. Same is for all loops and conditional
statement (if).

❖ Scope of variable - for loop

for​ (​initializationStatement​; test_expression; ​updateStatement​) {
// Scope of variable defined in loop
}

Example:
public​ ​static​ ​void​ main(String[] args) {
for​ (​int i=0​; i<5; ​i++​) {
int j=2; // Scope of i and j are both inside the loop they can’t be used outside
}

❖ Scope of variable for while loop

while​(test_expression) {
// Scope of variable defined in loop
}

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

int i=0;
while(i<5)
{
int j=2; // Scope of i is main and scope of j is only the loop
i++;
}
}

❖ Scope of variable for conditional statements

if​(test_expression) {
// Scope of variable defined in the conditional statement
}

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

int i=0;
if (i<5)
{
int j=5; // Scope of j is only in this block
}
// cout<<j; This statement if written will give an error because
 scope of j is inside if and is not accessible outside if.
}

Increment Decrement operator

Explanation
Pre-increment​ and ​pre-decrement​ operators’ increments or decrements the value
of the object and returns a reference to the result.
Post-increment​ and ​post-decrement​ creates a copy of the object, increments or
decrements the value of the object and returns the copy from before the
increment or decrement.

Post-increment(a++):
This increases value by 1, but uses old value of a in any statement.
Pre-increment(++a):
This increases value by 1, and uses increased value of a in any statement.

Post-decrement(a--):
This decreases value by 1, but uses old value of a in any statement.

Pre-decrement(++a):
This decreases value by 1, and uses decreased value of a in any statement.

public​ ​static​ v​ oid​ main(String[] args) {

int I=1, J=1, K=1, L=1;

cout<<I++<<' '<<J-- <<' '<<++K<<' '<< --L<<endl;

cout<<I<<' '<<J<<' '<<K<<' '<<L<<endl;

}
Output:
1120
2020
Bitwise Operators
Bitwise operators are used to perform operations at bit level. Following is the
summary of various bitwise operations​:

Operator Name Example Result Description

a​ & ​b and 4&6 4 1 if both bits are 1.
a​ | ​b or 4|6 6 1 if either bit is 1.
a​ ^ ​b xor 4^6 2 1 if both bits are different.
~​a not ~4 -5 Inverts the bits. (Unary bitwise compliment)
left Shifts the bits of ​n​ left ​p​ positions. Zero bits
n​ << ​p 3 << 2 12
shift are shifted into the low-order positions.
Shifts the bits of ​n​ right ​p​ positions. If ​n​ is a
right
n​ >> ​p 5 >> 2 1 2's complement signed number, the sign bit
shift
is shifted into the high-order positions.
right Shifts the bits of ​n​ right ​p​ positions. Zeros are
n​ >>> ​p -4 >>> 28 15
shift shifted into the high-order positions.

Example Code:

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

​int​ a ​=​ 1 ​ 9​; // 19 = 10011
​int​ b ​=​ ​28​; // 28 = 11100
​int​ c ​=​ ​0;​

c ​=​ a ​&​ b​;​ // 16 = 10000

System.​out​.​println​(​"a & b = "​ ​+​ c ​);

c ​=​ a ​|​ b​;​ // 31 = 11111

System.​out​.​println​(​"a | b = "​ ​+​ c ​);

c ​=​ a ​^​ b​;​ // 15 = 01111

System.​out​.​println​(​"a ^ b = " ​+​ c ​);

c ​=​ ​~​a​;​ // -20 = 01100

System.​out​.​println​(​"~a = " ​+​ c ​);
 c ​=​ a ​<<​ ​2​;​ // 76 = 1001100
System.​out​.​println​(​"a << 2 = " ​+​ c ​);

c ​=​ a ​>>​ ​2;​ ​ // 4 = 00100

System.​out​.​println​(​"a >> 2 = " ​+​ c ​);

c ​=​ a ​>>>​ 2
​ ​;​ // 4 = 00100
System.​out​.​println​(​"a >>> 2 = " ​+​ c ​);
​}

Output
a & b = 16
a | b = 31
a ^ b = 15
~a = -20
a << 2 = 76
a >> 2 = 4
a >>> 2 = 4

Precedence and Associativity

Operator precedence determines which operator is performed first in an
expression with more than one operators with different precedence.
For example, 10 + 20 * 30 is calculated as 10 + (20 * 30) and not as (10 + 20) * 30.
Associativity is used when two operators of same precedence appear in an
expression. Associativity can be either ​L​eft​ t​o ​R​ight or​ R​ight​ t​o ​L​eft. For
example, ‘*’ and ‘/’ have same precedence and their associativity
is ​L​eft​ t​o ​R​ight, so the expression “100 / 10 * 10” is treated as “(100 / 10) *
10”.

Precedence and Associativity are two characteristics of operators that determine

the evaluation order of subexpressions in absence of brackets.
Note : We should generally use add proper brackets in expressions to avoid
confusion and bring clarity.

1) Associativity is only used when there are two or more operators of same
precedence.
The point to note is associativity doesn’t define the order in which operands of a
single operator are evaluated. For example, consider the following program,
associativity of the + operator is left to right, but it doesn’t mean f1() is always
called before f2(). The output of following program is in-fact compiler dependent.
// Associativity is not used in the below program. Output is compiler dependent.
static int x = 0;
public​ ​static​ ​int​ F1() {
x = 5;
return x;
}
public​ ​static int​ F2() {
x = 10;
return x;
}
public​ ​static​ ​void​ main(String[] args) {
int p = F1() + F2();
System.​out​.println(x);
}

2) All operators with same precedence have same associativity

This is necessary, otherwise there won’t be any way for compiler to decide
evaluation order of expressions which have two operators of same precedence
and different associativity. For example, + and – have same associativity.

3) There is no chaining of comparison operators in Java

Trying to execute the statement a>b>c will give an error and the code will not compile

Following is the Precedence table along with associativity for different operators.

OPERATOR DESCRIPTION ASSOCIATIVITY

() Parentheses (function call) (see
[] Note 1)
. Brackets (array subscript)
++ — Member selection via object name
Postfix increment/decrement (see
Note 2) left-to-right
++ —
+– Prefix increment/decrement
!~ Unary plus/minus
(​type​) Logical negation/bitwise
complement right-to-left
 Cast (convert value to temporary
value of ​type)​
* / % Multiplication/division/modulus left-to-right
+ – Addition/subtraction left-to-right
<< >> Bitwise shift left, Bitwise shift right left-to-right
Relational less than/less than or
equal to
< <= Relational greater than/greater
> >= than or equal to left-to-right
== != Relational is equal to/is not equal to left-to-right
& Bitwise AND left-to-right
^ Bitwise exclusive OR left-to-right
| Bitwise inclusive OR left-to-right
&& Logical AND left-to-right
|| Logical OR left-to-right
?: Ternary conditional right-to-left
= Assignment
+= -= Addition/subtraction assignment
*= /= Multiplication/division assignment
%= &= Modulus/bitwise AND assignment
^= |= Bitwise exclusive/inclusive OR
<<= >>= assignment
Bitwise shift left/right assignment right-to-left
 Java Foundation with Data Structures
Lecture 5 : Functions, Variables and Scope
s​Functions

​A Function is a collection of statements designed to perform a specific task.

Function is like a black box that can take certain input(s) as its parameters and
can output a value which is the return value. A function is created so that one
can use it as many time as needed just by using the name of the function, you
do not need to type the statements in the function every time required.

Defining Function
return_type​ function_name​(​parameter 1, parameter 2, ………​) {
statements​;
}

● return type:​ ​A function may return a value. The ​return type​ of the
function is the data type of the value that function returns. Sometimes
function is not required to return any value and still performs the
desired task. The return type of such functions is ​void​.

Example:
Following is the example of a function that sum of two numbers. Here input to
the function are the numbers and output is their sum.
 1. public​ ​static​ ​int​ findSum​( ​int ​a​, ​int b
​ ​){
2. int ​sum ​= ​a ​+ ​b​;
3. return ​ ​sum​;
4. }

Function Calling
Now that we have read about how to create a function lets see how to call the
function. To call the function you need to know the name of the function and
number of parameters required and their data types and to collect the
returned value by the function you need to know the return type of the
function.
Example

1. public​ ​static​ ​int​ findSum​( ​int ​a​, ​int b

​ ​){
2. ​int​ sum ​= ​a ​+ ​b​;
3. ​return ​ ​sum​;
4. }
5. public​ s​ tatic​ ​void​ main​ () {
6. ​int ​a ​= 1​ 0, b ​= ​20​;
7. ​int ​c​= ​findSum​ (​a,​ ​b)​ ; // function findSum () is called using its name and
by knowing
8. System.​out​.print(​c​);​//​ the number of parameters and their data type.
9. } // ​integer c is used to collect the returned value by
the function

Output:
30

IMPORTANT POINTS:
● Number of parameter​ ​and their​ ​data type​ ​while calling must match with
function signature. Consider the above example, while calling function
findSum ()​ ​the number of parameters are two and both the parameter
are of integer type.

● It is okay not to collect the return value of function. For example, in the
above code to find the sum of two numbers it is right to print the return
value directly.
“System.​out.​ print(​c​);”

● void return type functions: ​These are the functions that do not return
any value to calling function. These functions are created and used to
perform specific task just like the normal function except they do not
return a value after function executes.

Following are some more examples of functions and their use to give you a
better idea.

Function to find area of circle

1. public​ ​static​ ​double​ findArea(​double​ ​radius​){

2. double ​area​ =​ ​radius​*​radius​*3.14; ​//return type is double
3. ​return ​area​;
4. }
5.
6. public​ ​static​ ​void​ main(String[] ​args​) {
7. double​ ​radius​ = 5.8;
8. ​double​ ​c​ = ​findArea(​ ​radius​);
9. System.​out.​ print(​c​);
10.}
11.

Function to print average

1. public​ ​static​ ​void​ printAverage​(int a, int b ){ //​return type of the

function is void
12. ​int​ avg = (a + b) / 2;
13. System.​out​.print(​avg​);
2. } // ​This function does not return any value
3.
4. public​ ​static​ ​void​ main​ () {
5. ​int​ a = 15, b = 25;
6. printAverage​ (​a, b​);
7. }
Why do we need function?
● Reusability: ​Once a function is defined, it can be used over and over
again. You can call the function as many time as it is needed, which saves
work. Consider that you are required to find out the area of the circle,
now either you can apply the formula every time to get the area of circle
or you can make a function for finding area of the circle and invoke the
function whenever it is needed.
● Neat code: ​A code created with function is easy to read and dry run. You
don’t need to type the same statements over and over again, instead
you can invoke the function whenever needed.
● Modularisation – ​ ​Functions help in modularising code. Modularisation
means to divides the code in small modules each performing specific
task. Functions helps in doing so as they are the small fragments of the
programme designed to perform the specified task.
● Easy Debugging:​ It is easy to find and correct the error in function as
compared to raw code without function where you must correct the
error (if there is any) everywhere the specific task of the function is
performed.

How does function calling works?

Consider the following code where there is a function called findsum which
calculates and returns sum of two numbers.

//Find Sum of two integer numbers

1. public​ ​static​ ​int​ findSum​( ​int ​a​, ​int b
​ ​){
2. ​int​ sum ​= ​a ​+ ​b​;
3. ​return ​ ​sum​;
4. }
5. public​ ​static​ ​void​ main​ () {
6. ​int ​a ​= ​10, b ​= ​20​;
7. ​int ​c​= ​findSum​ (a ​ ,​ ​b​);
8. System.​out​.print(​c​);
9.

The function being called is called

callee(​here it is findsum function) and the
function which calls the callee is called
the​ caller ​(here main function is the caller) .
When a function is called, programme control goes to the entry point of the
function. Entry point is where the function is defined. So focus now shifts to
callee and the caller function goes in paused state .

For Example: In above code entry point of the function ​findSum ()​ ​is at line
number 3. So when at line number 9 the function call occurs the control goes
to line number 3, then after the statements in the function ​findSum ()​ are
executed the programme control comes back to line number 9.

​Role of stack in function calling (call stack)

​A call stack is a storage area

that store information about
the ​active function and
paused functions. It stores
parameters of the function,
return address of the
function and variables of the
function that are created
statically.
Once the function
statements are terminated
or the function has returned
a value, the call stack
removes all the information about that function from the stack.

Benefits of functions
● Modularisation
● Easy Debugging:​ It is easy to find and correct the error in function as
compared to raw code without function where you must correct the
error (if there is any) everywhere the specific task of the function is
performed.
● ​Neat code: ​A code created with function is easy to read and dry run.

Variables and Scopes

Local Variables
Local variable is a variable that is given a local scope. Local variable belonging
to a function or a block has its scope only within the function or block inside
which it is declared. Scope of a variable is part of a programme for which this
variable is accessible.
Example:
1. #include<iostream>
2. using namespace ​std​;
3. public​ ​static​ ​void​ ​main​(){
4. ​int ​a ​= ​10​;
5. ​System.​out.​ print(​a​);
6.
7. }

Output
5
In the above code the variable ​a​ declared inside the block after if statement is
a local variable for this block.

Lifetime of a Variable
The lifetime of a variable is the time period for which the declared variable has
a valid memory. Scope and lifetime of a variable are two different concepts,
scope of a variable is part of a programme for which this variable is accessible
whereas lifetime is duration for which this variable has a valid memory.

Loop variable
Loop variable is a variable which defines the loop index for each iteration.
Example
“for ​(​int ​i​ ​= ​0; i ​< ​3; i​++) { // variable ​i i​ s the loop variable
…….;
……..;
statements;
​} ​“
For this example, variable ​i ​is the loop variable.

Variables in the same scope

Scope is part of programme where the declared variable is accessible. In the
same scope, no two variables can have name. However, it is possible for two
variables to have same name if they are declared in different scope.
Example:

1. public​ ​static​ v​ oid​ main(String[] ​args​) {

2. int​ ​a​ = 10;
3. double​ ​a​ = 5;​ // two variables with same name, the code will not
compile
4. System.​out​.println(​a​);
5. }
For the above code, there are two variables with same name ​a​ in the same
scope of main () function. Hence the above code will not compile.

Pass by value:

When the parameters are passed to a function by pass by value method, then
the formal parameters are allocated to a new memory. These parameters have
same value as that of actual parameters. Since the formal parameters are
allocated to new memory any changes in these parameters will not reflect to
actual parameters.

Example:
​//Function to increase the parameters value
1. public​ ​static​ v​ oid​ increase(​int​ ​x,​ ​int​ ​y​){
2. x​++;
3. y​ = ​y​ + 2;
4. System.​out.​ println(​x​ + ​":"​ + ​y​); ​/​/ x and y are formal
parameters
5. }
6. public​ ​static​ v​ oid​ main(String[] ​args​) {
7. int​ ​a​ = 10;
8. int​ ​b​ = 20;
9. increase​(​a​,​b​);
10. System.​out.​ println(​a​ + ​":"​ + ​b​); ​ // a and b are actual
parameters
11.
12.}

Output:
11: 22
10: 20
For the above code, changes in the values of ​x ​and​ y ​are not reflected to ​a ​and
b​ because x and y are formal parameters and are local to function increment so
any changes in their values here won’t affect variables a and b inside main.
  

 
 
 
 
 

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

Java  Foundation  with  Data  Structures  

Lecture  7:  Strings  
   

 
  

Strings  in  Java  

Strings,   which   are   widely   used   in   Java   programming,   are   a   sequence   of  
characters.   In   the   Java   programming   language,   strings   are   objects(we   study  
about  objects  in  detail  in  OOPS  lecture).     The  Java  platform  provides  the  String  
class   to   create   and   manipulate   strings.   The   most   direct   and   easiest   way   to  
create  a  string  is  to  write:  

String  str  =  "Hello  world";  

 
In  the  above  example,  "Hello  world!"  is  a  string  literal—a  series  of  characters  in  
code  that  is  enclosed  in  double  quotes.  Whenever  it  encounters  a  string  literal  
in  code,  the  compiler  creates  a  String  object  with  its  value—in  this  case,  Hello  
world!.  
 
Note:   Strings   in   Java   are   immutable,   thus   we   cannot   modify   its   value.   If   we  
want   to   create   a   mutable   string   we   can   use   StringBuffer   and   StringBuilder  
classes.  
 
A  String  can  be  constructed  by  either:  
1.   directly   assigning   a   string  literal  to   a  String  reference   -­‐  just   like   a   primitive,  
or  
2.   via   the   "new"   operator   and   constructor,   similar   to   any   other   classes(like  
arrays   and   scanner).   However,   this   is   not   commonly-­‐used   and   is   not  
recommended.  
 
For  example,  
String   str1   =   “Java   is   Amazing!”;               //   Implicit   construction   via   string  
literal  
String  str2  =  new  String(“Java  is  Cool!”);  //  Explicit  construction  via  new  
 
In  the  first  statement,  str1  is  declared  as  a  String  reference  and  initialized  with  
a   string   literal  "Java   is   Amazing".   In   the   second   statement,  str2  is   declared   as  
a  String  reference  and  initialized  via  the  new  operator  to  contain  "Java  is  Cool".  
String  literals   are   stored   in  a   common   pool   called   String   pool.   This  
facilitates  sharing   of   storage  for   strings   with   the   same   contents   to   conserve  
storage.     String  objects   allocated   via  new  operator   are   stored   in   the   heap  
memory(all   non   primitives   created   via   new   operator   are   stored   in   heap  
memory),  and  there  is  no  sharing  of  storage  for  the  same  contents.  
 
 
  
1.  String  Literal  v/s  String  Object  
 
As  mentioned,  there  are  two  ways  to  construct  a  string:  implicit  construction  by  
assigning   a   string   literal   or   explicitly   creating   a  String  object   via  
the  new  operator  and  constructor.  For  example,  
 
 
String  s1  =  "Hello";                             //  String  literal  
String  s2  =  "Hello";                             //  String  literal  
String  s3  =  s1;                                       //  same  reference  
String  s4  =  new  String("Hello");     //  String  object  
String  s5  =  new  String("Hello");     //  String  object  
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Java   has   provided   a   special   mechanism   for   keeping   the  String  literals   -­‐   in   a  
so-­‐called  string   common   pool.   If   two   string   literals   have   the   same   contents,  
they   will   share   the   same   storage   inside   the   common   pool.   This   approach   is  
adopted   to  conserve   storage  for   frequently-­‐used   strings.   On   the   other  
hand,  String  objects   created   via   the  new  operator   and   constructor   are   kept   in  
the  heap  memory.  Each  String  object  in  the  heap  has  its  own  storage  just  like  
any   other   object.   There   is   no   sharing   of   storage   in   heap   even   if  
two  String  objects  have  the  same  contents.  
 
You  can  use  the  method  equals()  of  the  String  class  to  compare  the  contents  of  
two   Strings.   You   can   use   the   relational   equality   operator   '=='   to   compare   the  
references   (or   pointers)   of   two   objects.   Study   the   following   codes   for   s1   and   s2  
defined  in  code  above:  
 
s1  ==  s1;                   //  true,  same  pointer  
 
  
s1  ==  s2;                   //  true,  s1  and  s1  share  storage  in  common  pool  
s1  ==  s3;                   //  true,  s3  is  assigned  same  pointer  as  s1  
s1.equals(s3);         //  true,  same  contents  
s1  ==  s4;                   //  false,  different  pointers  
s1.equals(s4);         //  true,  same  contents  
s4  ==  s5;                   //  false,  different  pointers  in  heap  
s4.equals(s5);         //  true,  same  contents  
 
 
2.  String  is  Immutable  
 
Since  string  literals  with  the  same  contents  share  storage  in  the  common  pool,  
Java's  String  is  designed  to  be  immutable.  That  is,  once  a  String  is  constructed,  
its  contents  cannot  be  modified.  Otherwise,  the  other  String  references  sharing  
the   same   storage   location   will   be   affected   by   the   change,   which   can   be  
unpredictable   and   therefore   is   undesirable.   Methods   such   as   toUpperCase()  
might   appear   to   modify   the   contents   of   a   String   object.   In   fact,   a   completely  
new   String   object   is   created   and   returned   to   the   caller.   The   original   String  
object   will   be   deallocated,   once   there   is   no   more   references,   and   subsequently  
garbage-­‐collected.  
 
Because   String   is   immutable,   it   is   not   efficient   to   use   String   if   you   need   to  
modify  your  string  frequently  (that  would  create  many  new  Strings  occupying  
new  storage  areas).    
 
For  example,  
 
//  inefficient  code  
String  str  =  "Hello";  
for  (int  i  =  1;  i  <  1000;  ++i)  {  
      str  =  str  +  i;  
}  
 
3.  StringBuilder  &  StringBuffer  
 
As   explained   earlier,   Strings   are   immutable   because   String   literals   with   same  
content   share   the   same   storage   in   the   string   common   pool.   Modifying   the  
content   of   one   String   directly   may   cause   adverse   side-­‐effects   to   other   Strings  
sharing  the  same  storage.  
 
JDK   provides   two   classes   to   support   mutable   strings:   StringBuffer   and  
StringBuilder   (in   core   package   java.lang)   .   A   StringBuffer   or   StringBuilder   object  
is   just   like   any   ordinary   object,   which   are   stored   in   the   heap   and   not   shared,  
 
  
and   therefore,   can   be   modified   without   causing   adverse   side-­‐effect   to   other  
objects.  
 
StringBuilder  class  was  introduced  in  JDK  1.5.  It  is  the  same  as  StringBuffer  class,  
except   that   StringBuilder   is   not   synchronized   for   multi-­‐thread   operations(you  
can   read   more   about   multi   threading).   However,   for   single-­‐thread   program,  
StringBuilder,  without  the  synchronization  overhead,  is  more  efficient.  
 
 
4.  Important  Java  Methods  

1.   String  "Length"  Method  

String  class  provides  an  inbuilt  method  to  determine  the  length  of  the  Java  
String.  For  example:  

    String  str1  =  "test  string";  

    //Length  of  a  String  
    System.out.println("Length  of  String:  "  +  str.length());  

2.   String  "indexOf"  Method  

String  class  provides  an  inbuilt  method  to  get  the  index  of  a  character  in  
Java  String.  For  example:  

    String  str1  =  "the  string";  

System.out.println("Index  of  character  's':  "  +  str_Sample.indexOf('s'));  //  
returns  5  

3.   String  "charAt"  Method  

Similar   to   the   above   question,   given   the   index,   how   do   I   know   the   character  
at  that  location?  Simple  one  again!!  Use  the  “charAt”  method  and  provide  
the  index  whose  character  you  need  to  find.  

    String  str1  =  "test  string";  

          System.out.println("char  at  index  3  :  "  +  str.charAt());    
    //  output  –  ‘t’  

4.   String  "CompareTo"  Method  

This   method   is   used   to   compare   two   strings.   Use   the   method  

“compareTo”  and  specify  the  String  that  you  would  like  to  compare.  

 
  
Use   “compareToIgnoreCase”   in   case   you   don’t   want   the   result   to   be   case  
sensitive.  

The   result   will   have   the   value   0   if   the   argument   string   is   equal   to   this   string;  
a   value   less   than   0   if   this   string   is   lexicographically   less   than   the   string  
argument;   and   a   value   greater   than   0   if   this   string   is   lexicographically  
greater  than  the  string  argument.  

        String  str  =  "test";  

    System.out.println("Compare  To  “test”:  "  +  str.compareTo("test"));  
     
//Compare  to  -­‐  Ignore  case  
    System.out.println("Compare   To   “test”:     -­‐   Case   Ignored:   "   +  
str.compareToIgnoreCase("Test"));  

5.   String  "Contain"  Method  

Use  the  method  “contains”     to  check  if  a  string  contains  another  string  and  
specify  the  characters  you  need  to  check.  

Returns  true  if  and  only  if  this  string  contains  the  specified  sequence  of  char  
values.  
String  str  =  "test  string";  
      System.out.println("Contains  sequence  ing:  "  +  str.contains("ing"));  

6.   String  "endsWith"  Method  

This  method  is  used  to  find  whether  a  string  ends  with  particular  prefix  or  
not.  

Returns  true  if  the  character  sequence  represented  by  the  argument  is  a  
suffix  of  the  character  sequence  represented  by  this  object.  

          String  str  =  "star";  

    System.out.println("EndsWith  character  'r':  "  +  str.endsWith("r"));  

7.   String  "replaceAll"  &  "replaceFirst"  Method  

Java  String  Replace,  replaceAll  and  replaceFirst  methods.  You  can  specify  
the  part  of  the  String  you  want  to  replace  and  the  replacement  String  in  the  
arguments.  

String  str  =  "sample  string";  

System.out.println("Replace  sample  with  test:  "  +  str.replace("sample",  
"test"));  
 
  
8.   String  Java  "tolowercase"  &  Java  "touppercase"  

Use  the  “toLowercase()”  or  “ToUpperCase()”  methods  against  the  Strings  that  
need  to  be  converted.  

String  str  =  "TEST  string";  

System.out.println("Convert  to  LowerCase:  "  +  str.toLowerCase());  
//Convert  to  UpperCase  
System.out.println("Convert  to  UpperCase:  "  +  str.toUpperCase());}}  
 
 
Other  Important  Java  String  methods:  
 
No.   Method   Description  

1   String   substring(int   returns   substring   for   given  

beginIndex)   begin  index  

2   String   substring(int   returns   substring   for   given  

beginIndex,  int  endIndex)   begin  index  and  end  index  

3   boolean  isEmpty()   checks  if  string  is  empty  

4   String  concat(String  str)   concatinates  specified  string  

5   String   replace(char   old,   replaces   all   occurrences   of  

char  new)   specified  char  value  

6   String   replaces   all   occurrences   of  

replace(CharSequence   old,   specified  CharSequence  
CharSequence  new)  

7   String[]  split(String  regex)   returns   splitted   string  

matching  regex  

8   String[]   split(String   regex,   returns   splitted   string  

int  limit)   matching  regex  and  limit  

9   int  indexOf(int  ch)   returns   specified   char   value  

index  

10   int   indexOf(int   ch,   int   returns   specified   char   value  

fromIndex)   index  starting  with  given  index  

 
  

11   int   indexOf(String   returns   specified   substring  

substring)   index  

12   int   indexOf(String   returns   specified   substring  

substring,  int  fromIndex)   index  starting  with  given  index  

13   String  trim()   removes  beginning  and  ending  

spaces  of  this  string.  

14   static   String   valueOf(int   converts  given  type  into  string.  

value)   It  is  overloaded.  
 
 
 
Some  of  the  key  points  about  Java  Strings:  
 
1.   Strings  are  not  NULL  terminated  in  Java:  
Unlike  C  and  C++,  String  in  Java  doesn't  terminate  with  null  character.  
Instead  String  is  an  Object  in  Java  and  backed  by  character  array.  You  can  
get  the  character  array  used  to  represent  String  in  Java  by  
calling  toCharArray()  method  of  java.lang.String  class  of  JDK.  
2.   Internally,  String  is  stored  as  a  character  array  only.  
3.   String  is  a  Immutable  and  Final  class;  i.e  once  created  the  value  cannot  be  
altered.  Thus  String  objects  are  called  immutable.  
4.   The  Java  Virtual  Machine(JVM)  creates  a  memory  location  especially  for  
Strings  called  String  Constant  Pool.  That’s  why  String  can  be  initialized  
without  ‘new’  key  word.  
 

 
  

 
 
 
 
 
 
 
 
 
 
 

 
 
 
 
 
 
 
 
 
 
 
 
Topic  :  Object  Oriented  Programming
   

 
  
 

1.   Objects are the real world entities about which we code. Objects have
properties and they perform functions. For example in a student management
system the real world entities about which the system revolves are – students,
instructor, course, batch etc.

2.   A Class is a template or a blue print and the objects are specific copies of it.
For example a Vehicle class might look like :

public class Vehicle {

public String brand;
protected String model;
private double price;
int numWheels;
int yearOfManufactor;
String color;

public double getPrice(){

return price;
}
public void printDescription(){
System.out.println(brand +" " + model +"
"+price+" "+numWheels);
}
  }!
 
Now each vehicle will be a specific copy of this template. The syntax to
create an object of vehicle is as follows :
public static void main(String args[]){
Vehicle v = new Vehicle();
//v.fieldName – will give access to this vehicle’s
// fields
}!

Constructors – Constructor is a special method that is called when an object

is instantiated i.e created. It is used to initialize an object. Its name is same as
the class name. Even though in the above vehicle example we haven’t created
an explicit constructor there is a default constructor implicitly there. We can
create our own constructor as well. Also we can define multiple constructors
in a class as well. E.g :

public Vehicle(Double price){

this.price = price;
}

Here this is a keyword that refers to current object, So this.price refers to the
data member (i.e. price) of this object and not the argument variable price.

 
  
One important point to note here is that as soon as we create our
constructor the default constructor goes off.
Now when we have defined the above constructor and if it is the only
constructor in the class, then we can’t create any object of Vehicle without
giving its price. In a way we can actually restrict users that they can’t create a
vehicle without giving its price.
We can have more than one constructors within the same class (i.e
constructor overloading), which constructor will be called will be decided on
runtime depending on the type and number of arguments specified while
creating the object.

3.   Modifiers

1.   Static and Non-Static : Static properties are those that belong to the
class rather each specific object. So their separate copies aren’t
created. They are shared by all the objects of the class. You need to
write static keyword before it in order to make it static.
For e.g :

static int numStudents;

Here number of students in a batch is a property that isn’t specific

to each student and hence is static.
Whereas properties like name, rollNumber etc can have different
values for each object and are object specific and thus are non static.

2.   Access Modifiers

1.   Private : It is visible only within the class i.e it can be accessed

by and through the methods of the same class. So we can provide
setters and getters function through which they can be accessed
outside the class. For e.g the datafield price in the vehicle class
shown above. So we can have getter and setter function for it .

public double getPrice(){

return price;
}

public void setPrice(double price){

if(price < 5000){
return;
}
this.price = price;
}

2.   Default : When we explicitly don’t write any modifier it is default .

This modifier is package friendly i.e it can be accessed within the
same package.

 
  
3.   Protected : It is accessible within the same package and outside
the package but only through inheritance.
4.   Public : It is accessible everywhere.

An important point to note here is that its better to make a variable

private and then provide getters and setters in case we wish allow
others to view and change it than making the variable public. Because
by provding setter we can actually add constraints to the function and
update value only if they are satisfied (say vehicle price can’t be
updated if its less than 5k).

3.   Final Keyword : Final keyword can be applied before a variable,

method and a class. A final variable is one whose value can’t be
changed. So we can either initialise a final variable at the time of
declaration or in a constructor. A final method is one that can’t be
overriden. Making a class final means it can’t be inherited. (E.g : String
class in java is final)

4.   Abstract : An abstract method is one which does not have

implementation.
E.g
abstract void getType();

A class having even one abstract method has to be declared abstract,

and since a abstract class is incomplete so you cannot create an
instance of abstract class, but it can be extended. Also we can create
reference of an abstract class. We will discuss more about in
polymorphism.

Components Of OOPS

1.   Encapsulation - Binding (or wrapping) code and data together into a single
unit i.e a class is known as encapsulation. It lets us hide the implementation
details using different access modifiers. Also it lets us change the implementation
without breaking the code of users.

2.   Inheritance – Inheritance is a mechanism by which one class can extend

functionality from an existing class. It provides code reusability. The derived class
inherits the states and behaviors from the base class. The derived class can add
its own additional variables and methods. Syntax for inheritance is shown below –

! ! public class Car extends Vehicle {

private int numDoors;
String company;

public int numDoors(){

return numDoors;
}
}!
!
 
  

Here car (sub class) extends Vehicle (base class / super class) since every car
is a vehicle. So car will now have all the properties and functions that a vehicle
has except the private fields of vehicle class(since they are not inherited , but
they can be accessed via functions of base class that aren’t private).

•   What if both the base class and sub class have function with same signature
i.e same name and arguments ? Say even car has a printDescription function
as in vehicle.

public void printDescription(){

System.out.println("Car :" + company +" " + model +"
"+getPrice()+" "+numDoors);
}

then
Car c = new Car();
c.printDescription(); // This will call car’s printDescription

If we wish to call base class printDescription inside Car’s printDescription then

“super “ keyword should be used.

super.printDescription(); // This will call Vehicle’s printDescription

•   Constructors – Suppose Vehicle has one constructor as shown below

:

public Vehicle(Double price){

this.price = price;
}

then Car, which extends Vehicle needs to have a constructor that passes value
to the vehicle constructor which is implicitly called when we create an object
of car.

public Car(double price){

super(price); // should be the first line
numWheels = 4;
company = "";
}
!

3.   Polymorphism – It refers to one thing taking multiple forms. Following are

different types of polymorphism that we should know about :

3.1.   Ability of a variable to take different forms – A base class’ reference can refer
to the object of its sub class i.e we can do something like this –

Vehicle v = new Car(1000);

 
  
Since every car is a vehicle so a vehicle(i.e. reference of type vehicle) can
refer to a car. And not just the car, reference “v” here can refer to object
of any other class that extends vehicle. But through this refernce “v” we
can access only those properties of car which even a vehicle has i.e.

v.numDoors = 4; // This will give error as numDoors is

// car’s specific property

3.2.   Overriding the base class functions(Virtual Functions) – We have already seen
its example above in inheritance. When both base class and sub class have
functions of same signature then base class’ function is overriden by the
subclass’ function.

Vehicle v1 = new Vehicle();

Vehicle v2 = new Car(1000);

v1.printDescription(); // Will call vehicle's printDescription

v2.printDescription(); // Will call car's printDescription!

In case of v2, which printDescription should be called is decided on runtime

(Runtime Polymorphism) based on the type of the object and not the type of
reference. Same is the case with abstract class, a reference of abstract
class can refer to objects of all its sub classes which themselves aren’t
abstract.

3.3.   Ability of a function to behave differently on basis of different parameters.

3.3.1.  Function Overloading

public int add(int a,int b){

return a+b;
}

public double add(double a,double b){

return a+b;
}

public char add(char a,char b){

return (char)(a+b);
}!

Amongst these three add functions which add will be called finally, will
be decided on runtime based on the type of parameters.

3.3.2.  Constructor Overloading

 
  
Constructor overloading is similar to function overloading. At runtime
while creating an object the number and type of parameters passed will
decide that which constructor will be called.

public Vehicle(String color, double price){

this.color = "white";
this.price = price;
}

public Vehicle(double price){

this.price = price;
}

public Vehicle(){

}!

3.4.   Ability of a function to work with parameters of subtypes – This one is just an
extension of first type.

public void print(Vehicle v){

v.printDescription();
}

This print function expects a vehicle, so we can pass a car(or object of any
of its subtype) to it i.e.

Car c = new Car();

print(c);

Exceptions

An exception is an event, which occurs during the execution of a program, that

disrupts the normal flow of the program's instructions. The exception handling in
java is one of the powerful mechanism to handle the runtime errors so that normal
flow of the application can be maintained.
When an error occurs within a method, the method creates an object and hands it
off to the runtime system. The object, called an exception object, contains
information about the error, including its type and the state of the program when
the error occurred. Creating an exception object and handing it to the runtime
system is called throwing an exception.
After a method throws an exception, the runtime system attempts to find
something to handle it. The block of code that handles an exception is called
exception handler. When an exception occurs the run time system first tries to find
an exception handler in the method where the exception occurred and then
searches the methods in the reverse order in which they were called for the
exception handler. The list of methods is known as the call stack(shown below). If
no method handles the exception then exception appears on the console (like we
see ArrayIndexOutOfBoundsException etc)

 
  

Types of Exception

1.   Checked Exceptions : These are exceptional conditions that we can

anticipate when user makes mistake . For example computing factorial of a
negative number. A well-written program should catch this exception and
notify the user of the mistake, possibly prompting for a correct input. Checked
exceptions are subject to the Catch or Specify Requirement i.e either the
function where exception can occur should handle or specify that it can throw
an exception (We will look into it in detail later).
2.   Error : These are exceptional conditions that are external to the application,
and that the application usually cannot anticipate or recover from. For
example, suppose that an application successfully opens a file for input, but is
unable to read the file because of a hardware or system malfunction.
3.   Unchecked Exception : These are exceptional conditions that might occur at
runtime but we don’t expect them to occur while writing code. These usually
indicate programming bugs, such as logic errors or improper use of an API.
For example StackOverflowException.

Exception Handling

Exception handling is achieved by using try catch and/or finally block.

Try block - The code which can cause an exception is enclosed within try block.

Catch block - The action to be taken when an exception has occurred is done in
catch block. It must be used after the try block only.

Finally block - Java finally block is a block that is used to execute important
code such as closing connection, stream etc. Java finally block is always executed
whether exception is handled or not.

Here is a sample code to explain the same.

public static void main(String[] args){

 
  
Scanner s = new Scanner(System.in);
System.out.println("Enter dividend ");
int dividend = s.nextInt();
System.out.println("Enter divisor ");
int divisor = s.nextInt();
try{
int data= dividend/divisor;
System.out.println(data);
}
catch(ArithmeticException e){
System.out.println(“Divide by zero error”);
}
finally{
System.out.println("finally block is always
executed");
}
System.out.println("rest of the code...");
}

Note :
1.   Whenever an exception occurs statements in the try block after the
statement in which exception occurred are not executed
2.   For each try block there can be zero or more catch blocks, but only one
finally block.

Creating an Exception / User Defined Exceptions

A user defined exception is a sub class of the exception class. For creating an
exception you simply need to extend Exception class as shown below :

public class InvalidInputException extends Exception {

private static final long serialVersionUID = 1L;
}

Throwing an Exception

Sometimes, it's appropriate for code to catch exceptions that can occur within it. In
other cases, however, it's better to let a method further up the call stack handle the
exception. For example if input to the factorial method is a negative number, then it
makes more sense for the factorial to throw an exception and the method that has
called factorial method to handle the exception.
Here is the code for the factorial method :

public static int fact(int n) throws InvalidInputException{

if(n < 0){
InvalidInputException e = new InvalidInputException();
throw e;
}
if(n == 0){
return 1;
}
 
  
return n*fact(n-1);
}

The fact method throws an InvalidInputException that we created above

and we will handle the exception in main.

public static void main(String[] args) {

Scanner s = new Scanner(System.in);
System.out.println("Enter number ");
int n = s.nextInt();
int a = 10;
try{
System.out.println(fact(n));
a++;
}
catch(InvalidInputException e){
System.out.println("Invalid Input !! Try again");
return;
}
}

 
  
 
 
 
 
 
 
 
 

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Java  Foundation  with  Data  Structures  
Topic:  Recursion    
 
 
 
 
 
 
 
 
 
 
 
 
 
 

 
  

Recursion  
 
a.   What  is  Recursion?  
 
In  previous  lectures,  we  used  iteration  to  solve  problems.  Now,  we’ll  learn  about  
recursion   for   solving   problems   which   contain   smaller   sub-­‐problems   of   the   same  
kind.    
Recursion   in   computer   science   is   a   method   where   the   solution   to   a   problem  
depends  on  solutions  to  smaller  instances  of  the  same  problem.  By  same  nature  it  
actually  means  that  the  approach  that  we  use  to  solve  the  original  problem  can  be  
used  to  solve  smaller  problems  as  well.    
So   in   other   words   in   recursion   a   function   calls   itself   to   solve   smaller   problems.  
Recursion  is  a  popular  approach  for  solving  problems  because  recursive  solutions  
are   generally   easier   to   think   than   their   iterative   counterparts   and   the   code   is   also  
shorter  and  easier  to  understand.  
 
b.   How  Does  Recursion  Work?  
 
We  can  define  the  steps  of  a  recursive  solution  as  follows:  
1.   Base  Case:    
A  recursive  function  must  have  a  terminating  condition  at  which  the  function  
will  stop  calling  itself.  Such  a  condition  is  known  as  a  base  case.  
2.   Recursive  Call:  
The  recursive  function  will  recursively  invoke  itself  on  the  smaller  version  of  
problem.   We   need   to   be   careful   while   writing   this   step   as   it   is   important   to  
correctly   figure   out   what   your   smaller   problem   is   on   whose   solution   the  
original  problem’s  solution  depends.  
3.   Small  Calculation:  
Generally  we  perform  a  some  calculation  step  in  each  recursive  call.  We  can  
perform   this   calculation   step   before   or   after   the   recursive   call   depending  
upon  the  nature  of  the  problem.  
 
 
It  is  important  to  note  here  that  recursion  uses  stack  to  store  the  recursive  calls.  
So,  to  avoid  memory  overflow  problem,  we  should  define  a  recursive  solution  with  
minimum   possible   number   of   recursive   calls   such   that   the   base   condition   is  
achieved  before  the  recursion  stack  starts  overflowing  on  getting  completely  filled.  
 
Now,  let  us  look  at  an  example  to  calculate  factorial  of  a  number  using  recursion.  

 
  
 
Example  Code  1:  
 
public  class  Solution{  
 
public  static  int  fact(int  n)  
{  
       if(n==0)                                                                                //Base  Case  
       {  
               return  1;  
       }  
       return  n  *  fact(n-­‐1);                                    //Recursive  call  with  small  
calculation  
}  
 
public  static  void  main()  
{  
       int  num;  
       Scanner  s  =  new  Scanner(Syatem.in);  
       num  =  s.nextInt();  
       System.out.println(fact(num));  
       return  0;  
}  
}  
Output:  
120                                //For  num=5  
 
Explanation:  
Here,  we  called  factorial  function  recursively  till  number  became  0.  Then,  the  
statements  below  the  recursive  call  statement  were  executed.  We  can  visualize  
the  recursion  tree  for  this  function,  where  let  n=5,  as  follows:  
 
 
 
 
 
 
 
 
 
 
  
 
  fact(5)  finally  returns  5  *  24  =  120  to  the  
code  which  called  the  function  fact(n)    
fact(5)  
 
Returns  4  *  6  =  24    
 
fact(4)  
 
Returns  3  *  2  =  6  
 
 
fact(3)  
 
Returns  2  *  1  =  2    
fact(2)    

Returns  1  *  1  =  1  

fact(1)
Returns  1  

fact(0)
 
We   are   calculating   the   factorial   of   n=5   here.   We   can   infer   that   the   function  
recursively   calls   fact(n)   till   n   becomes   0,   which   is   the   base   case   here.   In   the  
base  case,  we  returned  the  value  1.  Then,  the  statements  after  the  recursive  
calls   were   executed   which   returned   n*fact(n-­‐1)   for   each   call.   Finally,   fact(5)  
returned   the   answer   120   to   main()   from   where   we   had   invoked   the   fact()  
function.  
 
 
Now,  let  us  look  at  another  example  to  find  nth  Fibonacci  number  .  In  Fibonacci  
series  to  calculate  nth  Fibonacci  number  we  can  use  the  formula  F(n)  =  F(n  –  1)  +  
F(n  –  2)    i.e.  nth  Fibonacci  term  is  equal  to  sum  of  n-­‐1  and  n-­‐2  Fibonacci  terms.  So  
let’s  use  this  to  write  recursive  code  for  nth  Fibonacci  number.    
 
 
Example  Code  2:  
 
  
//  Recursive  function:  
 
int  fibo(int  n)  {  
       if(n==0  ||  n==1)  {     //Base  Case  
               return  n;  
       }  
       int  a  =  fibo(n-­‐1);       //Recursive  call  
       int  b  =  fibo(n-­‐2);       //Recursive  call  
       return  a+b;       //Small  Calculation  and  return  statement  
}  
 
Explanation:  
As  we  are  aware  of  the  Fibonacci  Series  (0,  1,  1,  2,  3,  5,  8,…  and  so  on),  let  us  assume  
that   the   index   starts   from   0,   so,   5th   Fibonacci   number   will   correspond   to   5;   6th  
Fibonacci  number  will  correspond  to  8;  and  so  on.  
 
Here,  in  recursive  Fibonacci  function,  we  have  made  two  recursive  calls  which  are  
depicted  as  follows:  
 
  fibo(n)    
   
 
  fibo(n-­‐1)   fibo(n-­‐2)  
     
 
 
Note:  One  thing  that  we  should  be  clear  about  is  that  both  recursive  calls  don’t  
happen  simultaneously.  First  fibo(n-­‐1)  is  called,  and  only  after  we  have  its  result  
and  store  it  in  “a”  we  move  to  next  statement  to  calculate  fibo(n  –  2).  
 
It  is  interesting  to  note  here  that  the  concept  of  recursion  is  based  on  the  
mathematical  concept  of  PMI  (Principle  of  Mathematical  Induction).  When  we  
use  PMI  to  prove  a  theorem,  we  have  to  show  that  the  base  case  (usually  for  x=0  
or  x=1)  is  true  and,  the  induction  hypothesis  for  case  x=k  is  true  must  imply  that  
case  x=k+1  is  also  true.  We  can  now  understand  how  the  steps  which  we  followed  
in  recursion  are  based  on  the  induction  steps,  as  in  recursion  also,  we  have  a  base  
case  while  the  assumption  corresponds  to  the  recursive  call.