History of JAVA.

 Java was initially developed in 1991 named as “oak” but was renamed “Java” in 1995.
 Originally designed for small, embedded systems in electronic appliances like set-top boxes.
 The primary motivation was the need for a platform-independent language that could be used
to create software to be embedded in various consumer electronic devices.
 Java programming language was originally developed by Sun Microsystems which was
initiated by James Gosling and released in 1995 as core component of Sun Microsystems' Java
platform (Java 1.0 [J2SE]).
 It promised Write Once, Run Anywhere (WORA), providing no-cost run-times on popular
platforms.
 Java 2, new versions had multiple configurations built for different types of platforms. J2EE
included technologies and APIs for enterprise applications typically run in server
environments, while J2ME featured APIs optimized for mobile applications.
 The desktop version was renamed J2SE. In 2006, for marketing purposes, Sun renamed new
J2 versions as Java EE, Java ME, and Java SE, respectively.
 On 13 November 2006, Sun released much of Java as free and open-source software (FOSS),
under the terms of the GNU General Public License (GPL).
 On 8 May 2007, Sun finished the process, making all of Java's core code free and open-source,
aside from a small portion of code to which Sun did not hold the copyright.

What is Java?
 Java is a programming language that:
 Is exclusively object oriented
 Has full GUI support
 Has full network support
 Is platform independent
 Executes stand-alone or “on-demand” in web browser as applets
JDK, JRE, Byte code & JVM.

Compiler
(Javac.exe) Java
JVM
Java Packages
Application
(math,
Launcher
(java.exe), Runtime
AppletViewer, Libraries
etc..)
Development tools JRE

JDK

 Java Development Kit (JDK)

o JDK contains tools needed ,
 To develop the Java programs and
 JRE to run the programs.
o The tools include compiler (javac.exe), Java application launcher (java.exe),
Appletviewer, etc…
o Java application launcher (java.exe),
 Opens a JRE, loads the class, and invokes its main method.
 Java Runtime Environment (JRE)
o The Java Runtime Environment (JRE) is required to run java applications.
o It combines the Java Virtual Machine (JVM), platform core classes and supporting
libraries.
o JRE is part of the Java Development Kit (JDK), but can be downloaded separately.
o It does not contain any development tools such as compiler, debugger, etc.
 Byte code
o Byte code is intermediate representation of java source code.
o It produce by java compiler by compiling java source code.
o Extension for java class file or byte code is ‘.class’.
o It is platform independent.
  JVM (Java Virtual Machine)
o JVM is virtual because It provides a machine interface that does not depend on the
operating system and machine hardware architecture.
o JVM interprets the byte code into the machine code.
o JVM itself is platform dependent, but Java is Not.

Java Code (.java)

JAVAC Compiler

Byte Code (.class)

Windows Linux Mac

JVM JVM JVM

Explain features of JAVA.

Features of java are discussed below:
• The Features of Java programming are as below

1. Simple
2. Secure
3. Portable
4. Object-oriented
5. Robust
6. Multithreaded
7. Architecture-natural
8. Interpreted
9. High performance
10. Distributed
11. Dynamic
 Simple
o It’s simple because it contains many features of other languages like C and C++
o It also removed complexities like pointers, Storage classes, goto statement and multiple
Inheritance.
 Secure
o Java is best known for its security. With Java, we can develop virus-free systems. Java is
secured because:
1. No explicit pointer
2. Java Programs run inside virtual machine sandbox
3. Bytecode Verifier
 Portable
o Java is portable because it facilitates you to carry the java bytecode to any platform.
 Object oriented
o Java is Object-oriented programming language. Everything in Java is an object.
 Robust
o Robust simply means strong. Java is robust because:
1. It uses strong memory management.
2. There are lack of pointers that avoids security problem.
3. There is automatic garbage collection in java.
4. There is exception handling and type checking mechanism in java. All these points makes
java robust
 Multithreaded
o A thread is like a separate program, executing concurrently.
o We can write Java programs that deal with many tasks at once by defining multiple threads.
o The main advantage of multi-threading is that it doesn't occupy memory for each thread.
o It shares a common memory area. Threads are important for multi-media, Web applications
etc…
 Architecture-neutral
o Java is architecture neutral because there is no implementation dependent features e.g. size
of primitive types is fixed.
o Example : in c int occupy 2 byte for 32 bit OS and 4 bytes for 64 bit OS whereas in JAVA it
occupy 4 byte for int both in 32 bit and 64 bit OS.
 Interpreted
o Java enables the creation of cross-platform programs by compiling into an intermediate
representation called Java bytecode.
o This code can be executed on any system that implements the Java Virtual Machine.
 High-Performance
o Most previous attempts at cross-platform solutions have done so at the expense of
performance.
o As explained earlier, the Java bytecode was carefully designed so that it would be easy to
translate directly into native machine code for very high performance by using a just-in-time
compiler.
 Dynamic
o Java programs carry with them substantial amounts of run-time type information that is used
to verify and resolve accesses to objects at run time.
o This makes it possible to dynamically link code in a safe and expedient manner.
 Distributed
o Java is distributed because it facilitates us to create distributed applications in java.
o RMI and EJB are used for creating distributed applications.
o We may access files by calling the methods from any machine on the internet.
 Platform Independent
o Java is a platform independent programming language, because when you install JDK in the
system then JVM is also installed automatically on the system.
o For every operating system separate JVM is available which is capable to read the .class file
or byte code.
o When we compile Java code then .class file is generated by java compiler (javac) these codes
are readable by the JVM and every operating system have its own JVM so JVM is platform
dependent but due to JVM java is platform independent.

Explain Operators in JAVA

Sr. Operator Examples

1 Arithmetic Operators +, -, *, /, %
2 Relational Operators <, <=, >, >=, ==, !=
3 Logical Operators &&, ||, !
4 Assignment Operators =, +=, -=, *=, /=
5 Increment and Decrement Operators ++, --
6 Conditional Operator ?:
7 Bitwise Operators &, |, ^, <<, >>

Arithmetic Operator
 An arithmetic operator performs basic mathematical calculations such as addition,
subtraction, multiplication, division etc. on numerical values (constants and variables).
 Increment / Decrement Operators
o Increment and decrement operators are unary operators that add or subtract one,
to or from their operand.
o the increment operator ++ increases the value of a variable by 1, e.g. a++ means
a=a+1
o the decrement operator -- decreases the value of a variable by 1. e.g. a–– means
a=a–1
o If ++ operator is used as a prefix (++a) then the value of a is incremented by 1 first
then it returns the value.
o If ++ operator is used as a postfix (a++) then the value of a is returned first then it
increments value of a by 1.
Operator Description Example

+ Addition - Adds values on either side of the operator A + B will give

30
- Subtraction - Subtracts right hand operand from left hand operand A - B will give
-10
* Multiplication - Multiplies values on either side of the operator A * B will give
200
/ Division - Divides left hand operand by right hand operand B / A will give
2
% Modulus - Divides left hand operand by right hand operand and returns B % A will
remainder give 0
++ Increment - Increases the value of operand by 1 B++ gives 21
-- Decrement - Decreases the value of operand by 1 B-- gives 19
Arithmetic Operators in JAVA, consider A as 10 & B as 20

Expression Evaluation (Let’s say a=10, c=15)

b = a++ Value of b would be 10 and value of a would be 11.
b = ++a Value of b & a would be 11.
b = a-- Value of b would be 10 and value of a would be 9.
b = --a Value of b & a would be 9.
Increment / Decrement Operators
Relational Operators
 A relational operators are used to compare two values.
 They check the relationship between two operands, if the relation is true, it returns 1; if the
relation is false, it returns value 0.
 Relational expressions are used in decision statements such as if, for, while, etc
Operator Description Example
== Checks if the values of two operands are equal or not, if yes then (A == B) is not
condition becomes true. true.
!= Checks if the values of two operands are equal or not, if values are not (A != B) is
equal then condition becomes true. true.
> Checks if the value of left operand is greater than the value of right (A > B) is not
operand, if yes then condition becomes true. true.
< Checks if the value of left operand is less than the value of right (A < B) is true.
operand, if yes then condition becomes true.
>= Checks if the value of left operand is greater than or equal to the value (A >= B) is not
of right operand, if yes then condition becomes true. true.
<= Checks if the value of left operand is less than or equal to the value of (A <= B) is
right operand, if yes then condition becomes true. true.
Relational Operators in JAVA, consider A as 10 & B as 20
Bitwise Operators
Operator Description Example
& Binary AND Operator copies a bit to the result if it (A & B) will give 12 which is 0000
exists in both operands. 1100
| Binary OR Operator copies a bit if it exists in either (A | B) will give 61 which is 0011
operand. 1101
^ Binary XOR Operator copies the bit if it is set in one (A ^ B) will give 49 which is 0011
operand but not both. 0001
~ Binary Ones Complement Operator is unary and (~A ) will give -61 which is 1100
has the effect of 'flipping' bits. 0011 in 2's complement form
due to a signed binary number.
<< Binary Left Shift Operator. The left operands value A << 2 will give 240 which is 1111
is moved left by the number of bits specified by the 0000
right operand.
>> Binary Right Shift Operator. The left operands value A >> 2 will give 15 which is 1111
is moved right by the number of bits specified by
the right operand.
>>> Shift right zero fill operator. The left operands value A >>>2 will give 15 which is 0000
is moved right by the number of bits specified by 1111
the right operand and shifted values are filled up
with zeros.
Bitwise Operators in JAVA, consider A as 60 & B as 13

Logical Operators
 Logical operators are decision making operators.
 They are used to combine two expressions and make decisions.
 An expression containing logical operator returns either 0 or 1 depending upon whether
expression results false or true.

Operator Description Example

&& Called Logical AND operator. If both the operands are non-zero, then (A && B) is
the condition becomes true. false.
|| Called Logical OR Operator. If any of the two operands are non-zero, (A || B) is
then the condition becomes true. true.
! Called Logical NOT Operator. Use to reverses the logical state of its !(A && B) is
operand. If a condition is true then Logical NOT operator will make false. true.
Logical Operators in JAVA, consider A as true & B as false
Assignment Operators
 Assignment operators are used to assign a new value to the variable.
 The left side operand of the assignment operator is a variable and right side operand of the
assignment operator is a value or a result of an expression.
 Meaning of = in Maths and Programming is different.
o Value of LHS & RHS is always same in Math.
o In programming, value of RHS is assigned to the LHS
Operator Description Example
= Simple assignment operator, Assigns values from right side C = A + B will assign
operands to left side operand value of A + B into C
+= Add AND assignment operator, It adds right operand to the C += A is equivalent to C
left operand and assign the result to left operand =C+A
-= Subtract AND assignment operator, It subtracts right C -= A is equivalent to C
operand from the left operand and assign the result to left =C-A
operand
*= Multiply AND assignment operator, It multiplies right C *= A is equivalent to C
operand with the left operand and assign the result to left =C*A
operand
/= Divide AND assignment operator, It divides left operand with C /= A is equivalent to C
the right operand and assign the result to left operand =C/A
%= Modulus AND assignment operator, It takes modulus using C %= A is equivalent to
two operands and assign the result to left operand C=C%A
<<= Left shift AND assignment operator C <<= 2 is same as C = C
<< 2
>>= Right shift AND assignment operator C >>= 2 is same as C = C
>> 2
&= Bitwise AND assignment operator C &= 2 is same as C = C
&2
^= bitwise exclusive OR and assignment operator C ^= 2 is same as C = C ^
2
|= bitwise inclusive OR and assignment operator C |= 2 is same as C = C |
2
Assignment Operators in JAVA
Operator Precedence & Associativity
 How does java evaluate 1 + 10 * 9 ?
(1 + 10 ) * 9 = 99 OR 1 + (10 * 9) = 91
 To get the correct answer for the given problem Java came up with Operator precedence. (
multiplication have higher precedence than addition so correct answer will be 91 in this case)
 For Operator, associativity means that when the same operator appears in a row, then to
which direction the expression will be evaluated.

Category Operator Associativity

Postfix () [] . (dot operator) Left to right
Unary ++ - - ! ~ Right to left
Multiplicative */% Left to right
Additive +- Left to right
Shift >> >>> << Left to right
Relational > >= < <= Left to right
Equality == != Left to right
Bitwise AND & Left to right
Bitwise XOR ^ Left to right
Bitwise OR | Left to right
Logical AND && Left to right
Logical OR || Left to right
Conditional ?: Right to left
Assignment = += -= *= /= %= >>= <<= &= ^= |= Right to left
Comma , Left to right

 Operators Precedence and Associativity are two characteristics of operators that determine
the evaluation order of sub-expressions in absence of brackets.
 Operator precedence determines which operation is performed first in an expression with
more than one operators with different precedence.
 a=10 + 20 * 30 is calculated as 10 + (20 * 30) and not as (10 + 20) * 30 so answer is 610.
 Operators Associativity is used when two operators of same precedence appear in an
expression. Associativity can be either Left to Right (L to R) or Right to Left (R to L).
 E.g. a=100 / 10 * 10
If Left to Right means (100 / 10) * 10 then answer is 100
If Right to Left means 100 / (10 * 10) then answer is 1
Division (/) & Multiplication (*) are Left to Right associative so the answer is 100.
Explain short circuit operators.
 Java provides two interesting Boolean operators not found in many other computer languages.
These are secondary versions of the Boolean AND and OR operators, and are known as
shortcircuit logical operators.
 The OR operator results in true when A is true, no matter what B is. Similarly, the AND operator
results in false when A is false, no matter what B is. If you use the || and && forms, rather than
the | and & forms of these operators, Java will not bother to evaluate the right-hand operand
when the outcome of the expression can be determined by the left operand alone.
 This is very useful when the right-hand operand depends on the value of the left one in order to
function properly. For example, the following code fragment shows how you can take advantage
of short-circuit logical evaluation to be sure that a division operation will be valid before
evaluating it:
if (denom != 0 && num / denom > 10)
 Since the short-circuit form of AND (&&) is used, there is no risk of causing a run-time exception
when denom is zero. If this line of code were written using the single & version of AND, both sides
would be evaluated, causing a run-time exception when denom is zero. It is standard practice to
use the short-circuit forms of AND and OR in cases involving Boolean logic, leaving the single-
character versions exclusively for bitwise operations. However, there are exceptions to this rule.
For example, consider the following statement:
if(c==1 & e++ < 100) d = 100)
 Here, using a single & ensures that the increment operation will be applied to e whether c is equal
to 1 or not.

Explain primitive Data types of JAVA.

Java defines 8 primitive types:
Data Type Size Range Example
byte 1 Byte -128 to 127 byte a = 10;
short 2 Bytes -32,768 to 32,767 short a = 200;
int 4 Bytes -2,147,483,648 to 2,147,483,647 int a = 50000;
long 8 Bytes -9,223,372,036,854,775,80 to 9,223,372,036,854,775,807 long a = 20;
float 4 Bytes 1.4e-045 to 3.4e+038 float a = 10.2f;
double 8 Bytes 4.9e-324 to 1.8e+308 double a = 10.2;
char 2 Bytes 0 to 65536 (Stores ASCII of character) char a = ‘a’;
boolean Not true or false boolean a = true;
defined
 byte
o Smallest integer type
o It is a signed 8-bit type (1 Byte)
o Range is -128 to 127
o Especially useful when working with stream of data from a network or file
o Example: byte b = 10;
 short
o short is signed 16-bit (2 Byte) type
o Range : -32768 to 32767
o It is probably least used Java type
o Example: short vId = 1234;
 int
o The most commonly used type
o It is signed 32-bit (4 Byte) type
o Range: -2,147,483,648 to 2,147,483,647
o Example: int a = 1234;
 long
o long is signed 64-bit (8 Byte) type
o It is useful when int type is not large enough to hold the desired value
o Example: long soconds = 1234124231;
 char
o It is 16-bit (2 Byte) type
o Range: 0 to 65,536
o Example: char first = ‘A’; char second = 65;
 float
o It is 32-bit (4-Byte) type
o It specifies a single-precision value
o Example: float price = 1234.45213f
 double
o It uses 64-bit (8-Byte)
o All math functions such as sin(),cos(),sqrt() etc… returns double value
o Example: double pi = 3.14141414141414;
 boolean
o The boolean data type has only two possible values: true and false.
o This data type represents one bit of information, but its "size" isn't something that's precisely
defined.
Explain Variable in Java
 The variable is the basic unit of storage in a java program.
 A variable is defined by the combination of identifiers, a type and an optional initialize.
 All variables have a scope, which defines their visibility and a life time.
 Naming Rules for a variable: -
 It should start with a lowercase letter such as id, name.
 It should not start with the special characters like & (ampersand), $ (dollar), _ (underscore).
 If the name contains multiple words, start it with the lowercase letter followed by an
uppercase letter such as firstName, lastName.
 Avoid using one-character variables such as x, y, z.
 Declaring a Variable: -
 All variables must be declared before they can be used. The basic form of a variable
declaration is shown here.
 Type identifier [= value] [, identifier [=value]...];
 Int a,b,c; // declare 3 integers
 Byte z = 22; // initialize z
 Char x = ‘X’; // the variable x has the value ‘X’

Escape Sequences
 Escape sequences in general are used to signal an alternative interpretation of a series of
characters.
 For example, if you want to put quotes within quotes you must use the escape sequence, \",
on the interior quotes.
System.out.println("Good Morning \"World\" ");
Escape Sequence Description
\’ Single quote
\” Double quote
\\ Backslash
\r Carriage return
\n New Line
\t Tab
Program Structure, Compilation and Run Process

 Simple Java Program Structure

public class Example

{
public static void main(String args[])
{
System.out.println(“First Example”);
}
}

 class Example
Here name of the class is Example.
 public static void main(String args[])
 public: The public keyword is an access specifier, which means that the content of
the following block accessible from all other classes.
 static: The keyword static allows main() to be called without having to instantiate
a particular instance of a class.
 void: The keyword void tells the compiler that main() does not return a value. The
methods can return value.
 main(): main is a method called when a java application begins,
 String args []
Declares a parameter named args, which is an array of instance of the class string.

Args[] receives any command-line argument present when the program is executed.

 System.out.println()
 System is predefined class that provides access to the system.
 Out is the output stream that is connected to the console.
 Output is accomplished by the built-in println() method. Println() displays the string
which is passed to it.

 Compilation of Java Program

Source Code bytecode compiler bytecode file Interpreter (VM)

Example Example
javac java
.java .class

Figure 1.4. Java Program Compilation Process

  Command 1: Javac Example.java
This command will compile the source file and if the compilation is successful, it will
generate a file named example.class containing bytecode. Java compilers translate
java program to bytecode form.
 Command 2: Java Example
The command called ‘java’ takes the bytecode and runs the bytecode on JVM
 Output
First Example

Type Casting
 Assigning a value of one type to a variable of another type is known as Type Casting.
 In Java, type casting is classified into two types,
 Widening/Automatic Type Casting (Implicit)

Widening/Automatic Type Casting (Implicit)

Narrowing Type Casting (Explicitly done)

Automatic Type Casting
 When one type of data is assigned to other type of variable , an automatic type conversion
will take place if the following two conditions are satisfied:
 The two types are compatible
 The destination type is larger than the source type
 Such type of casting is called “widening conversion”.
 Example:
int can always hold values of byte and short
public static void main(String[] args) {
byte b = 5;
// √ this is correct
int a = b;
}
Casting Incompatible Types
 To create a conversion between two incompatible types, you must use a cast
 A cast is an explicit type conversion.
 Such type is called “narrowing conversion”.
 Syntax:(target-type) value
 Example:
public static void main(String[] args) {
int a = 5;
// × this is not correct
byte b = a;
// √ this is correct
byte b = (byte)a ;
}
Decision Making Statements
 Compiler executes program statements sequentially.
 Decision making statements are used to control the flow of program execution.
 It allows us to control whether a set of program statement should be executed or not.
 It evaluates condition or logical expression first and based on its result (true or false), the
control is transferred to the particular statement.
 If result is true then it takes one path else it takes another path.

Commonly used decision making statements are:

1. One way Decision: if (Also known as simple if)
2. Two way Decision: if…else
3. Multi way Decision: if…else if…else if…else
4. Decision within Decision: nested if
5. Two way Decision: ?: (Conditional Operator)
6. n-way Decision: switch…case

If Statement
 if statement is the most simple decision-making statement also known as simple if.
 if statement consists of a Boolean expression followed by one or more statements.
 If the expression is true, then 'statement-inside' will be executed, otherwise
'statement-inside' is skipped and only 'statement-outside' will be executed.
 It is used to decide whether a block of statements will be executed or not i.e. if a
certain condition is true then a block of statement is executed otherwise not.
WAP to print if a number is positive
1. import java.util.*;
2. class MyProgram{
3. public static void main (String[] args){
4. int x;
5. Scanner sc = new Scanner(System.in);
6. x = sc.nextInt();
7. if(x > 0){
8. System.out.println("number is a positive");
9. }
10. }

WAP to print if a number is odd or even

1. import java.util.*;
2. class MyProgram{
3. public static void main (String[] args){
4. int x;
5. Scanner sc = new Scanner(System.in);
6. x = sc.nextInt();
7. if( x % 2 == 1 ){
8. System.out.println("number is a odd");
9. }
10. if( x % 2 == 0 ){
11. System.out.println("number is a even");
12. }
13. }
14.

If…else: Two way Decision

 For a simple if, if a condition is true, the compiler executes a block of statements, if
condition is false then it doesn’t do anything.
 What if we want to do something when the condition is false? if…else is used for the
same.
 If the 'expression' is true then the 'statement-block-1' will get executed else 'statement-
block-2' will be executed
if(condition)
{
// statement-block-1
// to execute if condition is
true
}
else
{
// statement-block-2
// to execute if condition is
false
}
WAP to print if a number is positive
1. import java.util.*;
2. class MyProgram{
3. public static void main (String[] args){
4. int x;
5. Scanner sc = new Scanner(System.in);
6. x = sc.nextInt();
7. if (x > 0){
System.out.println("Number is positive");
8. }//if
else{
9. System.out.println("Number is negative");
}//else
}//main
10. }//class

WAP to print if a number is odd or even

1. import java.util.*;
2. class MyProgram{
3. public static void main (String[] args){
4. int x;
5. Scanner sc = new Scanner(System.in);
6. x = sc.nextInt();
7. if( x % 2 == 1 ){
8. System.out.println("number is a odd");
9. }
10. else{
System.out.println("number is a even");
11. }
12. }
13.
if-else-if ladder
 if…else if…else statement is also known as if-else-if ladder which is used for multi way
decision making.
 It is used when there are more than two different conditions.
 It tests conditions in a sequence, from top to bottom.
 If first condition is true then the associated block with if statement is executed and rest
of the conditions are skipped.
 If condition is false then then the next if condition will be tested, if it is true then the
associated block is executed and rest of the conditions are skipped. Thus it checks till last
condition.
 Condition is tested only and only when all previous conditions are false.
 The last else is the default block which will be executed if none of the conditions are
true.
 The last else is not mandatory. If there are no default statements then it can be skipped.

if(condition 1)
{
statement-block1;
}
else if(condition 2)
{
statement-block2;
}
else if(condition 3)
{
statement-block3;
}
else if(condition 4)
{
statement-block4;
}
else
default-statement;
WAP to print if a number is zero or positive or negative
1. import java.util.*;
2. class MyProgram{
3. public static void main (String[] args){
4. int x;
5. Scanner sc = new Scanner(System.in);
6. x = sc.nextInt();
7. if(x > 0){
8. System.out.println(" number is a positive");
9. }
10. else if(x < 0) {
11. System.out.println(" number is a negative");
12. }
13. else{
14. System.out.println(" number is a zero");
15. }
16. }

WAP to print day name from day number

1. public class Demo {
2. public static void main(String[] args) {
3. int d;
4. Scanner sc = new Scanner(System.in);
5. d = sc.nextInt();
6. if (d == 1 ) System.out.println(“Monday”);
7. else if (d == 2) System.out.println(“Tuesday“);
8. else if (d == 3) System.out.println(“Wednesday“);
9. else if (d == 4) System.out.println(“Thursday“);
10. else if (d == 5) System.out.println(“Friday“);
11. else if (d == 6) System.out.println(“Saturday“);
12. else System.out.println(“Sunday“);
13. }
14. }

Nested If statement
 A nested if is an if statement that is the target of another if statement.
 Nested if statements mean an if statement inside another if statement.
 The statement connected to the nested if statement is only executed when -:
o Condition of outer if statement is true, and
o Condition of the nested if statement is also true.
 Note: There could be an optional else statement associated with the outer if statement,
which is only executed when the condition of the outer if statement is evaluated to be
false and in this case, the condition of nested if condition won't be checked at all
 if(condition 1)
{
if(condition 2)
{
nested-block;
}
else
{
nested-block;
}
}//if
else if(condition 3)
{
statement-block3;
}
else(condition 4)
{
statement-block4;
}

Nested If Program
1. int username = Integer.parseInt(args[0]);
2. int password = Integer.parseInt(args[1]);
3. double balance = 123456.25;
4. if(username==1234){
5. if(password==987654){
6. System.out.println("Your Balance is ="+balance);
7. }//inner if
8. else{
9. System.out.println("Password is invalid");
10. }
}//outer if
11. else{
12. System.out.println("Username is invalid");
13. }
14.
Switch case
n-way Decision
 switch…case is a multi-way decision making statement.
 It is similar to if-else-if ladder statement.
 It executes one statement from multiple conditions.
switch (expression)
{
case constant 1:
// Statement-1
break;
case constant 2:
// Statement-2
break;
case constant 3:
// Statement-3
break;
default:
// Statement-default
// if none of the above case matches then this block would be
executed.
}

WAP to print day based on number entered

1. public class Demo {
2. public static void main(String[] args){
3. int d;
4. Scanner sc= new Scanner(System.in);
5. d = sc.nextInt();
6. switch (d) {
7. case 1:
8. System.out.println(“Monday“); break;
9. case 2:
10. System.out.println(“Tuesday“); break;
11. case 3:
12. System.out.println(“Wednesday“); break;
13. case 4:
14. System.out.println(“Thursday“); break;
15. case 5:
16. System.out.println(“Friday“); break;
17. case 6:
18. System.out.println(“Saturday“); break;
19. case 7:
20. System.out.println(“Sunday“); break;
21. default:
22. System.out.println(“Invalid Day“);
23. } //switch
24. }
25. }
 WAP to print day based on number entered
1. public class SwitchExampleDemo {
2. public static void main(String[] args)
3. {
4. int number = 20;
5. switch (number) {
6. case 10:
7. System.out.println("10");
8. break;
9. case 20:
10. System.out.println("20");
11. break;
12. default:
13. System.out.println("Not 10 or 20");
14. }//switch
15. }
16. }

Points to remember for switch case

 The condition in the switch should result in a constant value otherwise it would be invalid.
 In some languages, switch statements can be used for integer values only.
 Duplicate case values are not allowed.
 The value for a case must be of the same data type as the variable in the switch.
 The value for a case must be a constant.
 Variables are not allowed as an argument in switch statement.
 The break statement is used inside the switch to terminate a statement sequence.
 The break statement is optional, if eliminated, execution will continue on into the next case.
 The default statement is optional and can appear anywhere inside the switch block.

Introduction to loop
Repeatedly execute a block of statements
Looping Statements
 Sometimes we need to repeat certain actions several times or till the some criteria is satisfied.
 Loop constructs are used to iterate a block of statements several times.
 Loop constructs repeatedly execute a block of statements for a fixed number of times or till
some condition is satisfied
 Following are looping statements in any programming language,
o Entry Controlled while, for
o Exit Controlled do…while
o Unconditional Jump goto (It is advised to never use goto in a program)
Entry Controlled Loop: While
 While is an entry controlled loop.
 It executes a block of statements till the condition is true.
while(condition)
{
// true-block
}

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

 If the number of iteration is not fixed, it is recommended to use while loop.

//code will print 1 to 9
1. public class WhileLoopDemo {
2. public static void main(String[] args) {
3. int number = 1;
4. while(number < 10) {
5. System.out.println(number);
6. number++;
7. }
8. }
9. }

WAP to print day based on number entered

1. public class SwitchExampleDemo {
2. public static void main(String[] args)
3. {
4. int number = 20;
5. switch (number) {
6. case 10:
7. System.out.println("10");
8. break;
9. case 20:
10. System.out.println("20");
11. break;
12. default:
13. System.out.println("Not 10 or 20");
14. }//switch
15. }
16. }
WAP to print odd numbers between 1 to n
1. import java.util.*;
2. class WhileDemo{
3. public static void main (String[] args){
4. int n,i=1;
5. Scanner sc = new Scanner(System.in);
6. System.out.print("Enter a number:");
7. n = sc.nextInt();
8. while(i <= n){
9. if(i%2==1)
10. System.out.println(i);
11. i++;
12. }
13. }}

WAP to print factors of a given number

1. import java.util.*;
2. class WhileDemo{
3. public static void main (String[] args){
4. int i=1,n;
5. Scanner sc = new Scanner(System.in);
6. System.out.print("Enter a Number:");
7. n = sc.nextInt();
8. System.out.print(" Factors:");
9. while(i <= n){
10. if(n%i == 0)
11. System.out.print(i +",");
12. i++;
13. }
14. }}
Entry Controlled Loop: for (;;) Loop
 for is an entry controlled loop
 Statements inside the body of for are repeatedly executed till the condition is true
for (initialization; condition; increment/decrement)
{
// statements
}

for(i=1; i <= 5; i++)

{
System.out.print("Hello World!");
}
 The initialization statement is executed only once, at the beginning of the loop.
 Then, the condition is evaluated.
o If the condition is true, statements inside the body of for loop are executed
o If the condition is false, the for loop is terminated.
 Then, increment / decrement statement is executed
 Again the condition is evaluated and so on so forth till the condition is true.
 If the number of iteration is fixed, it is recommended to use for loop.
//code will print 1 to 9
1. public class ForLoopDemo {
2. public static void main(String[] args){
3. for(int number=1;number<10;number++)
4. {
5. System.out.println(number);
6. }
7. }
8. }

WAP to print odd numbers between 1 to n

1. import java.util.*;
2. class MyProgram{
3. public static void main (String[] args){
4. int i=1;
5. Scanner sc = new Scanner(System.in);
6. n = sc.nextInt();
7. for(i=1; i<=n; i++) {
8. if(i%2==1)
9. System.out.println(i);
10. }//for
11. }//
12. }
WAP to print factors of a given number
1. import java.util.*;
2. class MyProgram{
3. public static void main (String[] args){
4. int i=1;
5. Scanner sc = new Scanner(System.in);
6. n = sc.nextInt();
7. for(i=1; i<=n; i++){
8. if(n%i == 0)
9. System.out.println(i);
10. }
11. }
12. }

Exit Controlled Loop: do…while

 do…while is an exit controlled loop.
 do-while loop is executed at least once because condition is checked after loop body.
 Statements inside the body of do…while are repeatedly executed till the condition is true.
 while loop executes zero or more times, do…while loop executes one or more times.
do
{
// true-block
}
while(condition) ;

//code will print 1 to 9

1. public class DoWhileLoopDemo {
2. public static void main(String[] args) {
3. int number = 1;
4. do {
5. System.out.println(number);
6. number++;
7. }while(number < 10) ;
8. }
9. }
WAP to print 1 to 10 using do-while loop
1. import java.util.*;
2. class MyProgram{
3. public static void main (String[] args){
4. int i=1;
5. Scanner sc = new Scanner(System.in);
6. n = sc.nextInt();
7. for(i=1; i<=n; i++){
8. if(n%i == 0)
9. System.out.println(i);
10. }
11. }
12. }

Continue: Skip the statement in the iteration

 Sometimes, it is required to skip the remaining statements in the loop and continue with the
next iteration.
 continue statement is used to skip remaining statements in the loop.
 continue is keyword in java.
WAP to calculate the sum of positive numbers. 
1. import java.util.*;
2. class ContinueDemo{
3. public static void main(String[] args) {
4. int a,n,sum=0;
5. Scanner sc = new Scanner(System.in);
6. n = sc.nextInt();
7. for(int i=0;i<n;i++){
8. a = sc.nextInt();
9. if(a<0){
10. continue;
11. System.out.println("a="+a); //error:unreachable
statement
12. }//if
13. sum=sum+a;
14. }//for
15. System.out.println("sum="+sum);
16. }
17. }
 Break: Early exit from the loop
 Sometimes, it is required to early exit the loop as soon as some situation occurs.
 E.g. searching a particular number in a set of 100 numbers. As soon as the number is found it
is desirable to terminate the loop.
 break is keyword in java.
 break statement is used to jump out of a loop.
 break statement provides an early exit from for, while, do…while and switch constructs.
 break causes exit from the innermost loop or switch.
WAP to calculate the sum of given numbers. User will enter -1 to terminate. 
1. import java.util.*;
2. class BreakDemo{
3. public static void main (String[] args){
4. int a,sum=0;
5. System.out.println("enter numbers_ enter -1 to break");
6. Scanner sc = new Scanner(System.in);
7. while(true){
8. a = sc.nextInt();
9. if(a==-1)
10. break;
11. sum=sum+a;
12. }//while
13. System.out.println("sum="+sum);
14. }
15. }

Nested loop
loop within a loop
Pattern Programs
WAP to print given pattern (nested loop)
1. public static void main(String[] args) {
2. int n=5;
3. for(int i=1;i<=n;i++){
4. for(int j=1;j<=i;j++){
5. System.out.print("*");
6. }//for j
7. System.out.println();
8. }//outer for i
9. }
10. }
WAP to print given pattern (nested loop)
1. class PatternDemo{
2. public static void main(String[] args) {
3. int n=5;
4. for(int i=1;i<=n;i++){
5. for(int j=1;j<=i;j++){
System.out.print(j+"\t");
6. }//for j
7. System.out.println();
8. }//outer for i
9. }
10. }
Mathematical functions
 The Java Math class provides more advanced mathematical calculations other than
arithmetic operator.
 The java.lang.Math class contains methods which performs basic numeric operations such
as the elementary exponential, logarithm, square root, and trigonometric functions.
 All the methods of class Math are static.
 Fields :
o Math class comes with two important static fields
 E : returns double value of Euler's number (i.e 2.718281828459045).
 PI : returns double value of PI (i.e. 3.141592653589793).
Math class Method:
Method Description
Math.abs() It will return the Absolute value of the given value.
Math.max() It returns the Largest of two values.
Math.min() It is used to return the Smallest of two values.
Math.round() It is used to round of the decimal numbers to the nearest value.
Math.sqrt() It is used to return the square root of a number.
Math.cbrt() It is used to return the cube root of a number.
Math.pow() It returns the value of first argument raised to the power to second
argument.
Math.signum() It is used to find the sign of a given value.
Math.ceil() It is used to find the smallest integer value that is greater than or equal to
the argument or mathematical integer.
Math.copySign() It is used to find the Absolute value of first argument along with sign
specified in second argument.
Math.nextAfter() It is used to return the floating-point number adjacent to the first
argument in the direction of the second argument.
Math.nextUp() It returns the floating-point value adjacent to d in the direction of positive
infinity.
Math.nextDown() It returns the floating-point value adjacent to d in the direction of
negative infinity.
Math.floor() It is used to find the largest integer value which is less than or equal to the
argument and is equal to the mathematical integer of a double value.
Math.floorDiv() It is used to find the largest integer value that is less than or equal to the
algebraic quotient.
Math.random() It returns a double value with a positive sign, greater than or equal
to 0.0 and less than 1.0.
Math.rint() It returns the double value that is closest to the given argument and equal
to mathematical integer.
Math.hypot() It returns sqrt(x2 +y2) without intermediate overflow or underflow.
Math.ulp() It returns the size of an ulp of the argument.
Math.getExponent() It is used to return the unbiased exponent used in the representation of
a value.
Math.IEEEremainder() It is used to calculate the remainder operation on two arguments as
prescribed by the IEEE 754 standard and returns value.
Math.addExact() It is used to return the sum of its arguments, throwing an exception if the
result overflows an int or long.
 Math.subtractExact() It returns the difference of the arguments, throwing an exception if the
result overflows an int.
Math.multiplyExact() It is used to return the product of the arguments, throwing an exception if
the result overflows an int or long.
Math.incrementExact() It returns the argument incremented by one, throwing an exception if the
result overflows an int.
Math.decrementExact() It is used to return the argument decremented by one, throwing an
exception if the result overflows an int or long.
Math.negateExact() It is used to return the negation of the argument, throwing an exception if
the result overflows an int or long.
Math.toIntExact() It returns the value of the long argument, throwing an exception if the
value overflows an int.

Logarithmic Math Method

Method Description
Math.log() It returns the natural logarithm of a double value.
Math.log10() It is used to return the base 10 logarithm of a double value.
Math.log1p() It returns the natural logarithm of the sum of the argument and 1.
Math.exp() It returns E raised to the power of a double value, where E is Euler's number and it is
approximately equal to 2.71828.
Math.expm1() It is used to calculate the power of E and subtract one from it.

Trigonometric Math Method

Method Description
Math.sin() It is used to return the trigonometric Sine value of a Given double value.
Math.cos() It is used to return the trigonometric Cosine value of a Given double value.
Math.tan() It is used to return the trigonometric Tangent value of a Given double value.
Math.asin() It is used to return the trigonometric Arc Sine value of a Given double value
Math.acos() It is used to return the trigonometric Arc Cosine value of a Given double value.
Math.atan() It is used to return the trigonometric Arc Tangent value of a Given double value.
Math Example
1. public class MathDemo {
2. public static void main(String[] args) {
3. double sinValue = Math.sin(Math.PI / 2);
4. double cosValue = Math.cos(Math.toRadians(80));
5. int randomNumber = (int)(Math.random() * 100);
6. // values in Math class must be given in Radians
7. // (not in degree)
8. System.out.println("sin(90) = " + sinValue);
9. System.out.println("cos(80) = " + cosValue);
10. System.out.println("Random = " + randomNumber);
11. }
12. }
Arrays in Java

Definition: An array is a fixed size sequential collection of elements of same data type grouped
under single variable name.
 An array is a group of like-typed variables that are referred by a common name.
 Arrays of any type can be created and may have one or more dimensions.
 A specific element in an array is accessed by its index.
 Arrays offer a convenient means of grouping related information.
int percentage[10];

 Often we need to deal with relatively large set of data.

 E.g.
 Percentage of all the students of the college. (May be in thousands)
 Age of all the citizens of the city. (May be lakhs)
 We need to declare thousands or lakhs of the variable to store the data which is practically
not possible.
 We need a solution to store more data in a single variable.
 Array is the most appropriate way to handle such data.
 As per English Dictionary, “Array means collection or group or arrangement in a specific
order.”

Array declaration

Array declaration:
type var-name[];
Example:
Int student_marks[];
Above example will represent array with no value (null) To link student_marks
with actual, physical array of integers, we must allocate one using new keyword.
Example:
int student_marks[] = new int[20];
 Normal Variable Declaration: int a;
 Array Variable Declaration: int b[10];
 Individual value or data stored in an array is known as an element of an
array.
 Positioning / indexing of an elements in an array always starts with 0 not 1.
o If 10 elements in an array then index is 0 to 9
o If 100 elements in an array then index is 0 to 99
o If 35 elements in an array then index is 0 to 34
  Variable a stores 1 integer number where as variable b stores 10 integer
numbers which can be accessed as b[0], b[1], b[2], b[3], b[4], b[5], b[6], b[7],
b[8] and b[9].
Important point about Java array
o An array is derived datatype.
o An array is dynamically allocated.
o The individual elements of an array is refereed by their
index/subscript value.
o The subscript for an array always begins with 0.

One-Dimensional Array
 An array using one subscript to represent the list of elements is called one
dimensional array.
 A One-dimensional array is essentially a list of like-typed variables.
 Array declaration: type var-name[];
 Example: int student_marks[];
 Above example will represent array with no value (null).
 To link student_marks with actual array of integers, we must allocate one
using new keyword.
 Example:
int student_marks[] = new int[20];

Example (One-Dimensional Array)

1. public class ArrayDemo{
2. public static void main(String[] args) {
3. int a[]; // or int[] a
4. // till now it is null as it does not assigned any
memory
5. a = new int[5]; // here we create an array
6. a[0] = 5;
7. a[1] = 8;
8. a[2] = 15;
9. a[3] = 84;
10. a[4] = 53;
11. /* in java we use length property to determine the
length
12. * of an array, unlike c where we used sizeof
function */
13. for (int i = 0; i < a.length; i++) {
14. System.out.println("a["+i+"]="+a[i]);
15. }
16. }
17. }
Example (One-Dimensional Array)
1. Class AutoArray{
2. public static void main (String args[ ])
3. {
4. int month_days[]={31,28,31,30,31,30,31,31,
5. 30,31,30,31};
6. System.out.println(“April has” +
month_days[3] + “days.”);
7. } }

WAP to store 5 numbers in an array and print them

1. import java.util.*;
2. class ArrayDemo1{
3. public static void main (String[] args){
4. int i, n;
5. int[] a=new int[5];
6. Scanner sc = new Scanner(System.in);
7. System.out.print("enter Array Length:");
8. n = sc.nextInt();
9. for(i=0; i<n; i++) {
10. System.out.print("enter a["+i+"]:");
11. a[i] = sc.nextInt();
12. }
13. for(i=0; i<n; i++)
14. System.out.println(a[i]);
15. }
16. }
Output:
enter Array Length:5
enter a[0]:1
enter a[1]:2
enter a[2]:4
enter a[3]:5
enter a[4]:6
1
2
4
5
6
WAP to print elements of an array in reverse order
1. import java.util.*;
2. public class RevArray{
3. public static void main(String[] args) {
4. int i, n;
5. int[] a;
6. Scanner sc=new Scanner(System.in);
7. System.out.print("Enter Size of an Array:");
8. n=sc.nextInt();
9. a=new int[n];
10. for(i=0; i<n; i++){
11. System.out.print("enter a["+i+"]:");
12. a[i]=sc.nextInt();
13. }
14. System.out.println("Reverse Array");
15. for(i=n-1; i>=0; i--)
16. System.out.println(a[i]);
17. }
18. }

WAP to count positive number, negative number and zero from an array of n size
1. import java.util.*;
2. class ArrayDemo1{
3. public static void main (String[] args){
4. int n,pos=0,neg=0,z=0;
5. int[] a=new int[5];
6. Scanner sc = new Scanner(System.in);
7. System.out.print("enter Array Length:");
8. n = sc.nextInt();
9. for(int i=0; i<n; i++) {
10. System.out.print("enter a["+i+"]:");
11. a[i] = sc.nextInt();
12. if(a[i]>0)
13. pos++;
14. else if(a[i]<0)
15. neg++;
16. else
17. z++;
18. }
19. System.out.println("Positive no="+pos);
20. System.out.println("Negative no="+neg);
21. System.out.println("Zero no="+z);
22. }}
Multidimensional Array

 In java, Multidimensional arrays are actually array of arrays.

 To declare a multidimensional array variable, specify each additional index
using another set of square brackets.
 For example, following declares two dimensional array:
int twoD[ ] [ ] = new int [4] [5];
 This allocates a 4 by 5 array and assigns it to twoD. Internally this matrix is
implemented as an array of arrays of int.
 Alternative Array Declaration, There is a second form that may be used to
declare an array:
type[ ] var-name;
 The square brackets follow the type specifier, and not the name of the array
variable.
 For example, the following two declarations are equivalent:
int a1[ ] = new int[4];
int [ ] a1= new int[4];
char twod [ ] [ ] = new char [3] [4];
char [ ] [ ] twod = new char [3] [4];
 This alternative declaration form offers convenience when declaring several
arrays at the same time. For example,
int [ ] nums1, nums2, nums3;
 This creates 3 array variables of int type.
 Example:
int runPerOver[][] = new int[50][6];
Manually allocate different size:
Int runPerOver[][] = new int[3][];
runPerOver[0] = new int[6];
runPerOver[1] = new int[7];
runPerOver[2] = new int[6];
 Initialization :
Int runPerOver[][] = {
{0,4,2,1,0,6},
{1,56,4,1,2,4,0},
{6,4,1,0,2,2},
WAP to read 3 x 3 elements in 2d array
1. import java.util.*;
2. class Array2Demo{
3. public static void main(String[] args) {
4. int size;
5. Scanner sc=new Scanner(System.in);
6. System.out.print("Enter size of an array");
7. size=sc.nextInt();
8. int a[][]=new int[size][size];
9. for(int i=0;i<a.length;i++){
10. for(int j=0;j<a.length;j++){
11. a[i][j]=sc.nextInt();
12. }
13. }
14. for(int i=0;i<a.length;i++){
15. for(int j=0;j<a.length;j++){
16. System.out.print
("a["+i+"]["+j+"]:"+a[i][j]+"\t");
17. }
18. System.out.println();
19. }
20. }
21. }
Output:
11
12
13
14
15
16
17
18
19
a[0][0]:11 a[0][1]:12 a[0][2]:13
a[1][0]:14 a[1][1]:15 a[1][2]:16
a[2][0]:17 a[2][1]:18 a[2][2]:19
WAP to perform addition of two 3 x 3 matrices
1. import java.util.*;
2. class Array2Demo{
3. public static void main(String[] args) {
4. int size;
5. int a[][],b[][],c[][];
6. Scanner sc=new Scanner(System.in);
7. System.out.print("Enter size of an array:");
8. size=sc.nextInt();
9. a=new int[size][size];
10. System.out.println("Enter array elements:");
11. for(int i=0;i<a.length;i++){
12. for(int j=0;j<a.length;j++){
13. System.out.print("Enter
a["+i+"]["+j+"]:");
14. a[i][j]=sc.nextInt();
15. }
16. }
17. b=new int[size][size];
18. for(int i=0;i<b.length;i++){
19. for(int j=0;j<b.length;j++){
20. System.out.print("Enter b["+i+"]["+j+"]:");
21. b[i][j]=sc.nextInt();
22. }
23. }
24. c=new int[size][size];
25. for(int i=0;i<c.length;i++){
26. for(int j=0;j<c.length;j++){
27. System.out.print("c["+i+"]["+j+"]:“
+(a[i][j]+b[i][j])+"\t");
28. }
29. System.out.println();
30. }//outer for
31. }//main()
32. }//class
Output:
Enter size of an array:3
Enter array elements:
Enter a[0][0]:1
Enter a[0][1]:1
Enter a[0][2]:1
Enter a[1][0]:1
Enter a[1][1]:1
Enter a[1][2]:1
Enter a[2][0]:1
Enter a[2][1]:1
Enter a[2][2]:1
Enter b[0][0]:4
Enter b[0][1]:4
Enter b[0][2]:4
Enter b[1][0]:4
Enter b[1][1]:4
Enter b[1][2]:4
 Enter b[2][0]:4
Enter b[2][1]:4
Enter b[2][2]:4
c[0][0]:5 c[0][1]:5 c[0][2]:5
c[1][0]:5 c[1][1]:5 c[1][2]:5
c[2][0]:5 c[2][1]:5 c[2][2]:5

Initialization of an array elements

One dimensional Array
 int a[5] = { 7, 3, -5, 0, 11 }; // a[0]=7, a[1] = 3, a[2] = -5, a[3] = 0, a[4] = 11
 int a[5] = { 7, 3 }; // a[0] = 7, a[1] = 3, a[2], a[3] and a[4] are 0
 int a[5] = { 0 }; // all elements of an array are initialized to 0

Two dimensional Array

 int a[2][4] = { { 7, 3, -5, 10 }, { 11, 13, -15, 2} }; // 1st row is 7, 3, -5, 10 & 2nd row is
11, 13, -15, 2
 int a[2][4] = { 7, 3, -5, 10, 11, 13, -15, 2 }; // 1st row is 7, 3, -5, 10 & 2nd row is
11, 13, -15, 2
 int a[2][4] = { { 7, 3 }, { 11} }; // 1st row is 7, 3, 0, 0 & 2nd row is 11, 0, 0, 0
 int a[2][4] = { 7, 3 }; // 1st row is 7, 3, 0, 0 & 2nd row is 0, 0, 0, 0
 int a[2][4] = { 0 }; // 1st row is 0, 0, 0, 0 & 2nd row is 0, 0, 0, 0
Searching in Array
 Searching is the process of looking for a specific element in an array. for example,
discovering whether a certain element is included in the array.
 Searching is a common task in computer programming. Many algorithms and data
structures are devoted to searching.
 We will discuss two commonly used approaches as follows:
Linear Search
The linear search approach compares the key element key sequentially with each
element in the array. It continues to do so until the key matches an element in
the
array or the array is exhausted without a match being found.

LinearSearchDemo.java
1. import java.util.*;
2. class LinearSearchDemo{
3. public static void main(String[] args) {
4. int size;
5. int a[]={1,2,3,4,5,6,7,8,9};
6. int search;
7. boolean flag=false;
8. Scanner sc=new Scanner(System.in);
9. System.out.print("Enter element to search");
10. search=sc.nextInt();
11. for(int i=0;i<a.length;i++){
12. if(a[i]==search){
13. System.out.println("element found at
"+i+"th index");
14. flag=true;
15. break;
16. } //if
17. }
18. if(!flag)
19. System.out.println("element NOT found!");
20. }
21. }
Output:
Enter element to search 6
element found at 5th index
Enter element to search 35
element NOT found!
Binary Search
The binary search first compares the key with the element in the middle of the
array. Consider the following three cases:
 If the key is less than the middle element, you need to continue to search for
the key only in the first half of the array.
 If the key is equal to the middle element, the search ends with a match.
 If the key is greater than the middle element, you need to continue to search
for the key only in the second half of the array.
Binary Search Demo
1. import java.util.*;
2. class BinaryDemo{
3. public static void main(String[] args){
4. int size;
5. int a[]={1,2,3,4,5,6,7,8,9};
6. int search;
7. boolean flag=false;
8. Scanner sc=new Scanner(System.in);
9. System.out.print("Enter element to search:");
10. search=sc.nextInt();
11. int low=0;
12. int high= a.length-1;
13. while(high>=low){
14. int mid=(high+low)/2;
15. if(search==a[mid]){
16. flag=true;
17. System.out.println("element found
at "+mid+" index ");
18. break;
19. }
20. else if(search<a[mid]){
21. high=mid-1;
22. }
23. else if(search>a[mid]){
24. low=mid+1;
25. }
26. }//while

27. if(!flag)
28. System.out.println("element not found");
29. }
30. }
Output:
Enter element to search:5
element found at 4 index
Enter element to search:9
element found at 8 index
Enter element to search:56
element not found
Note: Array should be sorted in ascending order if we want to use Binary Search.
Sorting Array
 Sorting, like searching, is a common task in computer programming. Many different
algorithms have been developed for sorting.
 There are many sorting techniques available, we are going to explore selection sort.
 Selection sort
o Finds the smallest number in the list and swaps it with the first element.
o It then finds the smallest number remaining and swaps it with the second element,
and so on, until only a single number remains.

Selection Sort Demo

1. import java.util.*;
2. class SelectionSortDemo{
3. public static void main(String[] args) {
4. int a[]={ 5, 2, 9, 3, 4, 1, 8, 6, 7 };
5. for (int i = 0; i < a.length - 1; i++) {
6. // Find the minimum in the list[i..a.length-1]
7. int min = a[i];
8. int minIndex = i;
9. for (int j = i + 1; j < a.length; j++) {
10. if (min > a[j]) {
11. min = a[j];
12. minIndex = j;
13. }
14. }//inner for loop j
15. // Swap a[i] with a[minIndex]
16. if (minIndex != i) {
17. a[minIndex] = a[i];
18. a[i] = min;
19. }
20. }//outer for i
21. for(int temp: a) { // this is foreach loop
22. System.out.print(temp + ", ");
23. }
24. }//main()
25. }//class
Output:
1, 2, 3, 4, 5, 6, 7, 8, 9,
Methods in Java
What is Method?
 A method is a group of statements that performs a specific task.
 A large program can be divided into the basic building blocks known as
method/function.
 The function contains the set of programming statements enclosed by { }.
 Program execution in many programming language starts from the main function.
main is also a method/function
void main()
{
// body part
}
Method Definition
 A method definition defines the method header and body.
 A method body part defines method logic.
Syntax: return-type method_name(datatyp1 arg1, datatype2 arg2,
…)
{
functions statements
}

Example: int addition(int a, int b);

{
return a+b;
}
WAP to add two number using add(int, int) method
1. class MethodDemo{
2. public static void main(String[] args) {
3. int a=10,b=20,c;
4. MethodDemo md=new MethodDemo();
5. c=md.add(a,b);
6. System.out.println("a+b="+c);
7. }//main()

8. int add(int i, int j){

9. return i+j;
10. }
11. }
Output:
a+b=30

Actual parameters v/s Formal parameters

 Values that are passed from the calling functions are known actual parameters.
 The variables declared in the function prototype or definition are known as formal
parameters.
 Name of formal parameters can be same or different from actual parameters.
 Sequence of parameter is important, not name.
Return Statement
 The function can return only one value.
 Function cannot return more than one value.
 If function is not returning any value then return type should be void.

WAP to calculate the Power of a Number using method

1. class MethodDemo{
2. import java.util.*;
3. public class PowerMethDemo1{
4. public static void main(String[] args){
5. int num, pow, res;
6. Scanner sc=new Scanner(System.in);
7. System.out.print("enter num:");
8. num=sc.nextInt();
9. System.out.print("enter pow:");
10. pow=sc.nextInt();
11. PowerMethDemo1 pmd=new PowerMethDemo1();
12. res = pmd.power(num, pow);
13. System.out.print("ans="+res);
14. } //main()
15. int power(int a, int b){
16. int i, r = 1;
17. for(i=1; i<=b; i++)
18. {
19. r = r * a;
20. }
21. return r;
22. }//power()
23. }//class
Output:
enter num:5
enter pow:3
ans=125
Types of Methods(Method Categories)
Functions can be divided in 4 categories based on arguments and return value.
 Method without arguments and without return value: void add();

 Method without arguments and with return value: int add();

 Method with arguments and without return value: void add(int, int);

 Method with arguments and with return value: int add(int, int);

Advantages of Method
Reduced Code Redundancy
 Rewriting the same logic or code again and again in a program can be avoided.
Reusability of Code
 Same function can be call from multiple times without rewriting code.
Reduction in size of program
 Instead of writing many lines, just function need to be called.
Saves Development Time
 Instead of changing code multiple times, code in a function need to be changed.
More Traceability of Code
 Large program can be easily understood or traced when it is divide into functions.
Easy to Test & Debug
 Testing and debugging of code for errors can be done easily in individual function.
Method Overloading
 Definition: When two or more methods are implemented that share same name but
different parameter(s), the methods are said to be overloaded, and the
process is referred to as method overloading.
 Method overloading is one of the ways that Java implements polymorphism.
 When an overloaded method is invoked, Java uses the type and/or number of arguments
as its guide to determine which version of the overloaded method to actually call.
 E.g. public void draw()
public void draw(int height, int width)
public void draw(int radius)
 Thus, overloaded methods must differ in the type and/or number of their parameters.
 While in overloaded methods with different return types and same name & parameter are
not allowed, as the return type alone is insufficient for the compiler to distinguish two
versions of a method.

Method Overloading: Compile-time Polymorphism

1. class Addition{
2. int i,j,k;
3. void add(int a){
4. i=a;
5. System.out.println("add i="+i);
6. }
7. void add(int a,int b){\\overloaded add()
8. i=a;
9. j=b;
10. System.out.println("add i+j="+(i+j));
11. }
12. void add(int a,int b,int c){\\overloaded add()
13. i=a;
14. j=b;
15. k=c;
16. System.out.println("add i+j+k="+(i+j+k));
17. }
18. }
19. class OverloadDemo{
20. public static void main(String[] args){
21. Addition a1= new Addition();
22. //call all versions of add()
23. a1.add(20);
24. a1.add(30,50);
25. a1.add(10,30,60);
26. }
27. }

Output:
add i=20
add i+j=80
add i+j+k=100
Method Overloading :Points to remember
 Method overloading supports polymorphism because it is one way that Java
implements the “one interface, multiple methods” paradigm.
 Overloading increases the readability of the program.
 There are two ways to overload the method in java
o By changing number of arguments
o By changing the data type
 In java, method overloading is not possible by changing the return type of
the method only because of ambiguity.

Can we overload java main() method?

 Yes, by method overloading. We can have any number of main methods in a
class by method overloading
 But JVM calls main () method which receives string array as arguments only.
Scope, Lifetime and Visibility of a Variable
Whenever we declare a variable, we also determine its scope, lifetime and visibility.

Scope Scope is defined as the area in which the declared variable is ‘accessible’.
There are five scopes: program, file, function, block, and class.
Scope is the region or section of code where a variable can be accessed.
Scoping has to do with when a variable is accessible and used.
Lifetime The lifetime of a variable is the period of time in which the variable is
allocated a space (i.e., the period of time for which it “lives”). There are
three lifetimes in C: static, automatic and dynamic.
Lifetime is the time duration where an object/variable is in a valid state.
Lifetime has to do with when a variable is created and destroyed
Visibility Visibility is the “accessibility” of the variable declared. It is the result of
hiding a variable in outer scopes.

Scope of a Variable

Scope Description
Local (block/function) "visible" within function or statement block from point of declaration
until the end of the block.
Class "seen" by class members.
File(program) visible within current file.
Global visible everywhere unless "hidden".
Lifetime of a variable
 The lifetime of a variable or object is the time period in which the variable/object has
valid memory.
 Lifetime is also called "allocation method" or "storage duration“.
Lifetime Stored
Static Entire duration of the program's execution. data segment
Automatic Begins when program execution enters the function or function call stack
statement block and ends when execution leaves the
block.
Dynamic Begins when memory is allocated for the object (e.g., heap
by a call to malloc() or using new) and ends when
memory is deallocated (e.g., by a call to free() or
using delete).

Variable Type Scope of a Variable Lifetime of a Variable

Instance Variable Throughout the class except in Until object is available in the
static methods memory
Class Variable Throughout the class Until end of the Class

Local Variable Throughout the block/function in Until control leaves the block
which it is declared
Introduction to Classes in java
What is Class?
 Class is derived datatype, it combines members of different datatypes into one.
 Defines new datatype (primitive ones are not enough).
 For Example: Car, College, Bus etc.
 This new datatype can be used to create objects.
 A class is a template for an object.

class Car{
String company;
String model;
double price;
double mileage;
………
}

Introduction to Objects in java

What is Object?
 An object is an instance of a class.
 An object has a state and behavior.
Example: A dog has
states - color, name, breed as well as
behaviors – barking, eating.
 The state of an object is stored in fields (variables), while methods (functions) display the
object's behavior.
 An Object is a key to understand Object Oriented Technology.
 An entity that has state and behavior is known as an object. e.g., Mobile, Car, Door,
Laptop etc
  Each and every object posses
1. Identity
2. State
3. Behavior

Philosophy of Object Oriented

 Our real world is nothing but classification of objects
 E.g. Human, Vehicle, Library, River, Watch, Fan, etc.
 Real world is organization of different objects which have their own characteristics,
behavior
 Characteristic of Human: Gender, Age, Height, Weight, Complexion, etc.
 Behavior of Human: Walk, Eat, Work, React, etc.
 Characteristic of Library: Books, Members, etc.
 Behavior of Library: New Member, Issue Book, Return Book etc.
 The OO philosophy suggests that the things manipulated by the program should
correspond to things in the real world.
 Classification is called a Class in OOP
 Real world entity is called an Object in OOP
 Characteristic is called Property in OOP
 Behavior is called Method in OOP

Classes and Objects

  Class can be defined in multiple ways
o A class is the building block.
o A class is a blueprint for an object.
o A class is a user-defined data type.
o A class is a collection of objects of the similar kind.
o A class is a user-defined data type which combines data and methods.
o A class describes both the data and behaviors of objects.
 Class contains data members (also known as field or property or data) and member
functions (also known as method or action or behavior)
 Classes are similar to structures in C.
 Class name can be given as per the Identifier Naming Conventions.

Object Definition:
 An Object is an instance of a Class.
 An Object is a variable of a specific Class
 An Object is a data structure that encapsulates data and functions in a single construct.
 Object is a basic run-time entity
 Objects are analogous to the real-world entities.
Creating Object & Accessing members
 new keyword creates new object
 Syntax:
ClassName objName = new ClassName();
 Example :
SmartPhone iPhone = new SmartPhone();
 Object variables and methods can be accessed using the dot (.) operator
 Example: iPhone.storage = 8000;

Declaring an Object
 When we create a class, we are creating a new data type.
 Object of that data type will have all the attributes and abilities that are designed in
the class.
 The new operator dynamically allocates (that is, allocates at run time) memory for an
object and returns a reference to it.
 This reference is, more or less, the address in memory of the object allocated by new.
  This reference is then stored in the variable. Thus, in Java, all class objects must be
dynamically allocated.

 new operator dynamically allocates memory for an object

 Here, s1 is a variable of the class type.
 The class name followed by parentheses specifies the constructor for the class.
 It is important to understand that new allocates memory for an object during run
time.

Assigning Object Reference

Here, r1 and r2 will both refer to the same Here, r1 has been set to null, but r2 still points
object. The assignment of r1 to r2 did not to the original object.
allocate any memory or copy any part of the
original object. It simply makes r2 refer to the
same object as does r1
WAP using class Person to display name and age
1. class MyProgram {
2. public static void main(String[] args) {
3. Person p1= new Person();
4. Person p2= new Person();
5. p1.name="modi";
6. p1.age=71;
7. p2.name="bachchan";
8. p2.age=80;
9. System.out.println("p1.name="+p1.name);
10. System.out.println("p2.name="+p2.name);
11. System.out.println("p1.age="+p1.age);
12. System.out.println("p2.age="+p2.age);
13. }//main()
14. }//class myProgram

15. class Person

16. {
17. String name;
18. int age;
19. }//class person
20.
Output:
p1.name=modi
p2.name=bachchan
p1.age=71
p2.age=80
WAP using class Person to display name and age with method
1. class MyProgram {
2. public static void main(String[] args){
3. Person p1=new Person();
4. Person p2=new Person();
5. p1.name="modi";
6. p1.age=71;
7. p2.name="bachchan";
8. p2.age=80;
9. p1.displayName();
10. p2.displayName();
11. p1.displayAge();
12. p2.displayAge();
13. } //main()
14. } //class myProgram

15. class Person{

16. String name;
17. int age;
18. public void displayName(){
19. System.out.println("name="+name);
20. }
21. public void displayAge(){
22. System.out.println("age="+age);
23. }
24. }//class person
Output:
name=modi
name=bachchan
age=71
age=80
WAP using class Rectangle and calculate area using method
1. import java.util.*;
2. class MyProgram {
3. public static void main(String[] args){
4. Rectangle r1=new Rectangle();
5. Scanner sc=new Scanner(System.in);
6. System.out.print("enter height:");
7. r1.height=sc.nextFloat();
8. System.out.print("enter width:");
9. r1.width=sc.nextFloat();
10. r1.calArea();
11. } //main()
12. }//class myProgram

13. class Rectangle{

14. float height;
15. float width;
16. public void calArea() {
17. System.out.println( "Area="+height*width);
18. } //calArea()
19. } //class

Output:
enter height:30.55
enter width:20.44
Area=624.442
WAP using class Rectangle and calculate area with Return value
1. import java.util.*;
2. class MyProgram {
3. public static void main(String[] args){
4. float area;
5. Rectangle r1=new Rectangle();
6. Scanner sc=new Scanner(System.in);
7. System.out.print("enter height:");
8. r1.height=sc.nextFloat();
9. System.out.print("enter width:");
10. r1.width=sc.nextFloat();
11. area=r1.calArea();
12. System.out.println(“Area="+area);
13. }//main()
14. }//class myProgram

15. class Rectangle{

16. float height;
17. float width;
18. public float calArea() {
19. return height*width;
20. }//calArea()
21. }//class
Output:
enter height:30.55
enter width:20.44
Area=624.442
WAP using class Cube and calculate area using method with parameter
1. import java.util.*;
2. class MyProgramCube {
3. public static void main
4. (String[] args){
5. float area;
6. Cube c1= new Cube();
7. area=c1.calArea(10,10,10);
8. System.out.println("area="+area);
9. }//main()
10. }//class myProgram
11. class Cube{
12. float height;
13. float width;
14. float depth;
15. float calArea(float h, float w, float d)
16. { height=h;
17. width=w;
18. depth=d;
19. return height*width*depth;
20. }//calArea()
21. }//class
Output:
area=1000.0
 WAP using class Cube and calculate area of two objects
1. import java.util.*;
2. class MyProgramCube {
3. public static void main(String[] args){
4. float area;
5. Cube c1= new Cube(); //Obj1
6. Cube c2= new Cube(); //Obj2
7. System.out.println(“c1 area=“+c1.calArea(10,10,10));
8. System.out.println(“c2 area=“+c2.calArea(20,20,20));
9. } //main()
10. } //class

11. class Cube{

12. float height;
13. float width;
14. float depth;
15. float calArea(float h, float w, float d)
16. { height=h;
17. width=w;
18. depth=d;
19. return height*width*depth;
20. } //calArea()
21. } //class
22.
Output:
c1 area=1000.0
c2 area=8000.0

Class vs. Object

Class Object
Class is a Blueprint or template. Object is the instance of a class.
Class creates a logical framework that defines When you declare an object of a class, you are
the relationship between its members. creating an instance of that class.
Class is a logical construct. An object has physical reality. (i.e., an object
occupies space in memory.)
Class is a group or collection of similar object. An Object is defined as real-world entity
e.g. Car e.g.: Audi, Volkswagen, Tesla, Ferrari etc.
Class is declared only once An Object can be created as many times as
required
Class doesn’t allocate memory when it is An Object allocates the memory upon creation
created.
Class can exist without its objects. An Object can’t exist without a class.

Class: Profession Object: Doctor, Teacher, Lawyer, Politician…

Class: Mobile Object: iPhone, Samsung, 1plus…
Class: Subject Object: Maths, English, Science, Computer…
Class: Student Object: John, Aarav, Smita…
Class: Color Object: Blue, Green, Red, Yellow, Violet,
Black…
Constructor
 A constructor in Java is a special type of method that is used to initialize objects.
 The constructor is called when an object of a class is created.
 A constructor initializes an object immediately upon creation.
 It has the same name as the class in which it resides and is syntactically similar to a method.
 JVM first allocates the memory for variables (objects) and then executes the constructor to
initialize instance variables.
 The JVM calls it automatically when we create an object.
 A constructor defines what happens when an object of a class is created.
class Cube{
instance variable1
instance variable1
…
Cube()
{
//initailze object

}
} //class

Properties of Constructor
 Constructor is invoked automatically whenever an object of class is created.
 Constructors do not have return types and they cannot return values, not even void.
 All classes have constructors by default: if you do not create a class constructor yourself, Java
creates one for you known as default constructor.
 Constructor is a method that is called at runtime during the object creation by using the new
operator. The JVM calls it automatically when we create an object.
 It is called and executed only once per object.
 It means that when an object of a class is created, constructor is called. When we create 2nd
object then the constructor is again called during the second time.

Types of Constructor
Default Constructor
 A constructor defines what occurs when an object of a class is created.
 Most classes explicitly define their own constructors within their class definition but if no
explicit constructor is specified then java will automatically supply a default constructor.
 Once you define your own constructor, the default constructor is no longer used.
 The default constructor automatically initializes all instance variables to zero.

Code before compilation:

class MyConst {
public static void main(String[] args) {
MyConst c=new MyConst();
}
}

Code after compilation:

class MyConst{
MyConst(){
//Default Constructor…
}
public static void main(String[] args) {
c=new MyConst();
}
}

No-Argument Constructor: MyMain.java

1. class Cube {
2. double width;
3. double height;
4. double depth;
5. Cube()
6. {
7. System.out.println("Constructing cube");
8. width = 10;
9. height = 10;
10. depth = 10;
11. }//Cube()
12. }//class
13. class MyMain{
14. public static void main(String[] args){
15. Cube c=new Cube();
16. }
17. }
Note: If you implement any constructor then you no longer receive a
default constructor from Java compiler.
Parameterized Constructor: MyMain.java
1. class Cube {
2. double width, height, depth;
3. Cube(double w, double h, double d)
4. { System.out.println("Constructing cube");
5. width = w;
6. height = h;
7. depth = d;
8. }//Cube()
9. }//class
10. class MyMain{
11. public static void main(String[] args){
12. Cube c=new Cube(10,10,10);
13. }
14. }
Copy Constructor
 It is a special type of constructor that is used to create a new object using the existing object
of a class that had been created previously.
Copy Constructor: MyProgramCopy.java
1. class Student{
2. String name;
3. int rollno;
4. Student(String s_name, int s_roll){
5. System.out.println("ConstructorInvoked");
6. this.name=s_name;
7. this.rollno=s_roll;
8. } //Constructor1

9. Student(Student s){ //CopyConstructor

10. System.out.println("CopyConstructor Invoked");
11. this.name=s.name;
12. this.rollno=s.rollno;
13. } //Constructor2

14. public void display(){

15. System.out.print("name="+name);
16. System.out.println(" rollno="+rollno);
17. } // display()
18. } //class

19. class MyProgramCopy {

20. public static void main(String[] args){
21. Student s1=new Student("darshan",101);
22. //invoking Copy Constructor
23. Student s2=new Student(s1);
24. s1.display();
25. s2.display();
26. } //main()
27. } //class myProgram
Output:
Constructor Invoked
CopyConstructor Invoked
name=darshan rollno=101
name=darshan rollno=101

 It creates a new object by initializing the object with the instance of the same class.

Advantages of Copy Constructor

 It is easier to use when our class contains a complex object with various parameters.
 Whenever we need to add all the field of a class to another object, then just send the
reference of previously created object.
 One of the most importance of copy constructors is that there is no need for any typecasting.
 Using a copy constructor, we can have complete control over object creation.
 With Copy Constructor, we can pass object of the class as a parameter(pass by reference).
Why Constructor?
 The pivotal purpose of constructor is to initialize the instance variable of the class.
 We use constructors to initialize the object with the default or initial state.
 Through constructor, we can request the user of that class for required dependencies.
 A constructor within a class allows constructing the object of the class at runtime.
 Allocates appropriate memory to objects.
 If we need to execute some code at the time of object creation, we can write them inside
the constructor.
 Example:
o If we talk about a Cube class then class variables are width, height and depth.
o But when it comes to creating its object(i.e. Cube will now exist in the
computer’s memory), then can a cube be there with no value defined for its
dimensions? The answer is “NO”.
o So constructors are used to assign values to the class variables at the time of
object creation.

When to use Constructor?

 When we need to execute some code at the time of object creation.
 Used for the initialization of instance variables.
 To assign the default value to instance variables.
 To initializing objects of the class.

Constructor() vs. Method()

Constructor() Method()
Naming Constructor name must be same as Method name can be anything.
class name.
Return Constructor does not have any return Method must have return types, at
types type, not even void. least void.
Call Constructor can be invoked implicitly Method is called by the programmer.
when object is created. Invoked explicitly.
Purpose To initialize an object To execute the code

Inheritance Constructor cannot be inherited by Method can be inherited by subclass.

subclass.
Constructor Overloading
 Constructor overloading in Java is a technique of having more than one constructor with
different parameter lists.
 They are arranged in a way that each constructor performs a different task.
 They are differentiated by the compiler by the number of parameters in the list and their
Constructor Overloading
1. class Balance{
2. int accNo;
3. double bal;
4. Balance(){
5. System.out.println("inside const1");
6. bal=0;
7. }
8. Balance(double b){
9. System.out.println("inside const2");
10. bal=b;
11. }
12. Balance(int a,double b){
13. System.out.println("inside const3");
14. bal=b;
15. accNo=a;
16. }
17. }
18. class Account{
19. public static void main(String args[]){
20. Balance b1= new Balance();
21. Balance b2= new Balance(100);
22. Balance b3=new Balance(1201,10000);
23. System.out.println("b1.bal="+b1.bal);
24. System.out.println("b2.bal="+b2.bal);
25. System.out.println("b3.bal="+b3.bal+
"b3.accNo="+b3.accNo);
26. }
27. }

types.

Destructor
 Destructor is the opposite of the constructor. Constructor is used to initialize objects while
the destructor is used to delete or destroy the object that releases the resource occupied by
the object.
 Definition: Destructor is an instance member function which is invoked automatically
whenever an object is going to be destroyed.
 In other words, a destructor is the last function that is going to be called before an object is
destroyed.
 In java, there is a special method named garbage collector that automatically called when an
object is no longer used.
 When an object completes its life-cycle the garbage collector deletes that object and de-
allocates or releases the memory occupied by the object.
  In C++, dynamically allocated objects must be manually released by use of a delete operator.
 Java takes a different approach: it handles de-allocation automatically.
 The technique that accomplishes this is known as “garbage collection”.

Why Destructor?
 When we create an object of the class(using new), it occupies some space in the memory. If
we do not delete these objects, it remains in the memory and occupies unnecessary space.
 To resolve this problem, we use the destructor.
 Remember that there is no concept of destructor in Java.
 Instead of destructor, Java provides the garbage collector that works the same as the
destructor.
 The garbage collector is a program (thread) that runs on the JVM. It automatically deletes
the unused objects (objects that are no longer used) and free-up the memory.
 The programmer has no need to manage memory, manually.

Working of garbage collector(destructor) in java

 When the object is created it occupies the space in the heap. These objects are used by the
threads.
 If the objects are no longer used by the thread it becomes eligible for the garbage collection.
 The memory occupied by that object is now available for new objects that are being created.
 When the garbage collector destroys an object, the JRE calls finalize() method to close the
connections such as database and network connection.

Static in Java

 The static keyword is used for memory management.

 We can apply static keyword with variables, methods, blocks and nested classes.
 The static keyword belongs to the class than an instance of the class.
 The static can be:
1. Variable (also known as a class variable)
2. Method (also known as a class method)
3. Block
4. Nested class
Static Variable
 Static variables have a property of preserving their value even after they are out of their
scope.
 The static variable gets memory only once in the class area at the time of class loading.
 Advantage of static variable: It makes program memory efficient (static variable saves
memory).
 Syntax: static type variable_name;

Characteristics of static variable:
 It is initialized to zero when the first object of its class is created. No other initialization is
allowed.
 Only one copy of that member is created for the entire class and is shared by all the objects
of that class, no matter how many objects are created.
 It is visible only within the class, but its lifetime is the entire program.
 Static variables are normally used to maintain values common for all objects.
 The class constructor does not initialize static variable.

Static Method vs Non-Static Method


Characteristic of static method
 A static method can call only other static methods and cannot call a non-static method from
it.
 A static method can be accessed directly by the class name and doesn’t need any object
 A static method cannot refer to “this” or “super” keywords in anyway

Restrictions on static method

1. The static method cannot use non static data member or call non-static method directly.
2. this and super cannot be used in static context.
 Static Method: WAP using class Rectangle and calculate area
1. import java.util.*;
2. class Rectangle{
3. static float height;
4. static float width;
5. static void calArea() {
6. System.out.println( "Area= "+height*width);
7. } //calArea()
8. } //class
9. class MyRectangle {
10. public static void main(String[] args){
11. Rectangle r1= new Rectangle();
12. Scanner sc= new Scanner(System.in);
13. System.out.print("enter height:");
14. r1.height=sc.nextFloat();
15. System.out.print("enter width:");
16. r1.width=sc.nextFloat();
17. Rectangle.calArea();
18. } //main()
19. } //class
Output:
enter height:30.55
enter width:20.44
Area=624.442

Static Block
 Static block is executed exactly once, when the class is first loaded.
 It is used to initialize static variables of the class.
 It will be executed even before the main() method.

How to call static block in java?

 Unlike method, there is no specified way to call a static block.
 The static block executes automatically when the class is loaded in memory.
 Example: Static Block, Method and Variable
1. class StaticDemo {
2. static int a = 4; //static variable declared & initialized
3. static int b; //static variable declared
4. static void dispValue(int x) {
5. System.out.println("Static method initialized.");
6. System.out.println("x = " + x);
7. System.out.println("a = " + a);
8. System.out.println("b = " + b);
9. } //static method

10. static {
11. System.out.println("Static block initialized.");
12. b= a * 5;
13. } //static block
14. public static void main(String args[]) {
15. System.out.println("inside main()...");
16. dispValue(44);
17. } //main()
18. } //class
Output:
Static block initialized.
inside main()...
Static method initialized.
x = 44
a = 4
b = 20

Points to remember for static keyword

1. When we declare a field static, exactly a single copy of that field is created and shared
among all instances of that class.
2. Static variables belong to a class, we can access them directly using class name. Thus,
we don't need any object reference.
3. We can only declare static variables at the class level.
4. We can access static fields without object initialization.
5. Static methods can't be overridden.
6. Abstract methods can't be static.
7. Static methods can't use this or super keywords.
8. Static methods can't access instance variables and instance methods directly. They need
some object reference to do so.
9. A class can have multiple static blocks.
Mutable and Immutable Objects
The content of mutable object can be changed, while content of immutable objects cannot be
changed.
Passing Objects as Argument
In order to understand how and why we need to pass object as an argument in methods, lets see the
Example: Passing Objects as Argument
1. class Time{
2. int hour;
3. int minute;
4. int second;
5. public Time(int hour, int minute, int second) {
6. this.second = second;
7. this.minute = minute;
8. this.hour = hour;
9. }

10. void add(Time t) {

11. this.second += t.second;
12. if(this.second>=60) {
13. this.minute++;
14. this.second-=60;
15. }
16. this.minute += t.minute;
17. if(this.minute>=60) {
18. this.hour++;
19. this.minute-=60;
20. }//if
21. this.hour += t.hour;
22. }
23. }
24. public class TimeDemo {
25. public static void main(String[] args) {
26. Time t1 = new Time(11,59,55);
27. Time t2 = new Time(0,0,5);
28. t1.add(t2);//passing Object as an argument
29. System.out.println(t1.hour + ":" + t1.minute + ":" +
t1.second);
30. }
31. }
32.
example.
Array of Objects
 We can create an array of object in java.
 Similar to primitive data type array we can also create and use arrays of derived data types
Example: Array of Objects
1. class Student{
2. int rollNo;
3. String name;
4. public Student(int rollNo, String name) {
5. this.rollNo = rollNo;
6. this.name = name;
7. }
8. void printStudentDetail() {
9. System.out.println("| "+rollNo+" | -- | "+name +" |");
10. }
11. }
12. public class ArrayOfObjectDemo {
13. public static void main(String[] args) {
14. Student[] stu = new Student[3];
15. stu[0] = new Student(101,"darshan");
16. stu[1] = new Student(102, "OOP");
17. stu[2] = new Student(103,"java");
18. stu[0].printStudentDetail();
19. stu[1].printStudentDetail();
20. stu[2].printStudentDetail();
21. }
22. }
(class).

Nested Class
 Nested Class: Class within another class
 Scope: Nested class is bounded by the scope of its enclosing class.
o E.g. class B is defined within class A, then B is known to A, but not outside of A.
 A nested class has access to the members, including private members of the class in which it
is nested.
 However, the enclosing class does not have access to the members of the nested class. i.e.
Class B can access private member of class A, while reverse is not accessible.
Types of Nested class:

Non-Static Nested Class

 The most imp type of nested class is the inner class.
 An inner class is a non-static nested class.
 It has access to all of the variables and methods of its outer class and may refer to them
directly in the same way that other non-static member of the outer class do.

Non-Static Nested Class: InnerOuterDemo.java

1. class Outer{
2. private int a=100;//instance variable
3. void outerMeth(){
4. Inner i= new Inner();
5. System.out.println("inside outerMeth()...");
6. i.innerMeth();
7. }
8. class Inner{
9. int b=20;
10. void innerMeth(){
11. System.out.println("inside innerMeth()..."
12. +(a+b));
13. }
14. } //inner class
15. } //outer class

16. class InnerOuterDemo{

17. public static void main(String[] args)
18. {
19. Outer o= new Outer();
20. o.outerMeth();
21. }
22. } //InnerOuterDemo
Output:
inside outerMeth()...
inside innerMeth()...120
Static Nested Class: InnerOuterDemo
 A static nested class is one which has the static modifier applied because it is static, it must
access the member of its enclosing class through an object. i.e. it can not refer to members
of its enclosing class directly.
 Because of this reason, static nested classes are rarely used.
Static Nested Class: InnerOuterDemo
1. class Outer{
2.
3. void outerMeth(){
4. Inner i= new Inner();
5. System.out.println("inside outerMeth()...");
6. i.innerMeth();
7. }
8. static class Inner{
9. int b=20;
10. void innerMeth(){
11. System.out.println("inside innerMeth()..."
12. +(a+b));
13. }
14. } //inner class
15. } //outer
16. class InnerOuterDemo{
17. public static void main(String[] args)
18. {
19. Outer o= new Outer();
20. o.outerMeth();
21. }
22. } //InnerOuterDemo
Output:
inside outerMeth()...
inside innerMeth()...120

Points to remember: Inner class

 Inner class implements a security mechanism in Java.
 Reduces encapsulation, more organized code by logically grouping the classes.
import keyword
 import keyword is used to import built-in and user-defined packages into your java source
file so that your class can refer to a class that is in another package by directly using its name.
 There are 3 different ways to refer to class/interface that is present in different package
o import the class/interface you want to use.
o import all the classses/interfaces from the package.
o Using fully qualified name.
 We can import a class/interface of other package using a import keyword at the first line of
code.
import java.util.Scanner;
public class DemoImport {
public static void main(String[] args)
{
Scanner s = new Scanner(System.in);
// Code
}
}

 We can import all the classes/interfaces of other package using a import keyword at the first
line of code with the wildcard (*).
import java.util.*;
public class DemoImport {
public static void main(String[] args)
{
Scanner s = new Scanner(System.in);
Date d = new Date();
// Code
}
}
 It is possible to use classes from other packages without importing the class using fully
qualified name of the class.
 Example :
java.util.Scanner s = new java.util.Scanner(System.in);
Static Import
 The static import feature of Java 5 facilitate the java programmer to access any static
member of a class directly.
 Advantage: Less coding is required if you have to access any static member of a class more
frequently.
 Disadvantage: If you overuse the static import feature, it makes the program unreadable
and unmaintainable.
import static java.lang.System.out;
public class S2{
public static void main(String args[]){
out.println("Hello main");
}
}

Access Control
What is OOP?
 OOP (Object-Oriented Programming) is a programming paradigm that is completely based
on ‘objects’.
 Object-Oriented Programs insists to have a lengthy and extensive design phase, which results
in improved designs and fewer defects.
 Object-oriented programming provides a higher level way for programmers to envision and
develop their applications.
 In an object-oriented programming language, less emphasis is placed upon the flow of
execution control. Instead, the program is viewed as a set of objects interacting with each
other in defined ways.
 An OOP programmer can bind new software objects to make completely new
programs/system.

What is Object-Orientation?
 Object-oriented modeling and design is a way of thinking about problems using models
organized around real-world concepts.
 The fundamental construct is object, which combine data structure and behavior.
 Object-Oriented Models are useful for
o Understanding problems
o Communicating with application experts
o Modeling enterprises
o Preparing documentation
o Designing System

Thinking in objects and class relationships

Few Real World Classes with behavior / action / methods
Few of Real World Objects

Procedural Programming v/s Object Oriented Programming

Procedural Programming Object Oriented Programming

Program is divided into functions Program is divided into classes & objects
The emphasis is on doing things The emphasis is on data
Poor modeling to real world problems Strong modeling to real world problems
Difficult to maintain large projects Easy to maintain large projects
Poor data security Strong data security
Code can’t be reused in another project Code can be reused across the projects
Not extensible Extensible
Productivity is low Productivity is high
Don’t provide support for new data types Provides support to new data types
Don’t provide automatic memory management Provides automatic memory management
e.g. Pascal, C, Basic, Fortran e.g. C++, C#, Java
Principles of OOP

Inheritance

 The mechanism of a class to derive properties and characteristics from another class is
called Inheritance.
 Inheritance is the process, by which a class can acquire(reuse) the properties and methods
of another class.
 The mechanism of deriving a new class from an old class is called inheritance.
 The new class is called derived class and old class is called base class.
 It is the most important feature of Object Oriented Programming.
 Base Class: The class whose properties are inherited by sub class is called Base Class/Super
class/Parent class.
 Derived Class: The class that inherits properties from another class is called Sub
class/Derived Class/Child class.
 Inheritance is implemented using super class and sub class relationship in object-oriented
languages.
 The derived class may have all the features of the base class and the programmer can add
new features to the derived class.
 Inheritance is also known as “IS-A relationship” between parent and child classes.
 For Example :
o Car IS A Vehicle
o Bike IS A Vehicle
o EngineeringCollege IS A College
 o MedicalCollege IS A College
o MCACollege IS A College

Inheritance: Advantages
 Promotes reusability
 When an existing code is reused, it leads to less development and maintenance costs.
 It is used to generate more dominant objects.
 Avoids duplicity and data redundancy.
 Inheritance makes the sub classes follow a standard interface.

Implementing Inheritance
To inherit a class, you simply incorporate the definition of one class into another by using
“extends” keyword.
Syntax:
class subclass-name extends superclass-name {
// body of class…
}

Implementing Inheritance in java

 1. class Person
2. {
3. String name;
4. long contact;
5. public void dispContact() {
System.out.println(“num=”+contact);
6. }
7. }
8. class Employee extends Person
9. {
10. int empID;
11. String designation;
12. }
13. Class Customer extends Person
14. {
15. int customerID;
16. int invoiceNo;
17. }

Property of Inheritance
 InheritanceDemo.java
1. class A{
2. protected int i;
3. int j;
4. void showij(){
5. System.out.println("i="+i+" j="+j);
6. }
7. }

8. class B extends A{ //inheritance

9. int k;
10. void showk(){
11. System.out.println("k="+k);
12. }
13. void add(){
System.out.println("i+j+k="+(i+j+k));
14. }
15. }

16. class InheritanceDemo{

17. public static void main(String[] args)
18. {
19. A superObjA= new A();
20. superObjA.i=10;
21. superObjA.j=20;
22. B subObjB= new B();
23. subObjB.k=30;
24. superObjA.showij();
25. subObjB.showk();
26. subObjB.add();
27. }
28. }

Types of Inheritance in Java

 Note: Multiple and Hybrid Inheritance
is not supported in Java with the Class
Inheritance, we can still use those
Inheritance with Interface.

Single Inheritance

Single Inheritance Example

1. class A{
2. protected int i;
3. int j;
4. void showij(){
5. System.out.println("i="+i+" j="+j);
6. }
7. }
8. class B extends A{ //inheritance
9. int k;
10. void showk(){
11. System.out.println("k="+k);
12. }
13. void add(){
System.out.println("i+j+k="+(i+j+k));
14. }
15. }
16. class InheritanceDemo{
17. public static void main(String[]
args)
18. {
19. A superObjA= new A();
20. superObjA.i=10;
21. superObjA.j=20;
22. B subObjB= new B();
23. subObjB.i=100
24. subObjB.j=100;
25. subObjB.k=30;
26. superObjA.showij();
27. subObjB.showk();
28. subObjB.add();
29. }
30. }
Hierarchical Inheritance

Hierarchical Inheritance Example

1. class A{
2. protected int i;
3. int j;
4. void showij(){
5. System.out.println("inside class A:i="+i+" j="+j);
6. }
7. }
8. class B extends A{
9. int k;
10. void showk(){
11. System.out.println("inside class B:k="+k);
12. }
13. void add_ijk(){
System.out.println(i+"+"+j+"+"+k+"="+(i+j+k));
14. }}
15. class C extends A{
16. int m;
17. void showm(){
18. System.out.println("inside class C:k="+m);
19. }
20. void add_ijm(){
21. System.out.println(i+"+"+j+"+"+m+"="+(i+j+m));
22. }
23. }
24. class InheritanceLevel{
25. public static void main(String[] args) {
26. A superObjA= new A();
27. superObjA.i=10;
28. superObjA.j=20;
29. superObjA.showij();
30. B subObjB= new B();
31. subObjB.i=100;
32. subObjB.j=200;
33. subObjB.k=300;
34. subObjB.showk();
35. subObjB.add_ijk();
36. C subObjC= new C();
37. subObjC.i=1000;
38. subObjC.j=2000;;
39. subObjC.m=3000;
40. subObjC.showm();
41. subObjC.add_ijm();
42. }
43. }
Multilevel Inheritance
Multilevel Inheritance
1. class A{
2. protected int i;
3. int j;
4. void showij(){
5. System.out.println("inside class A:i="+i+" j="+j);
6. }
7. }
8. class B extends A{
9. int k;
10. void showk(){
11. System.out.println("inside class B:k="+k);
12. }
13. void add_ijk(){
System.out.println(i+"+"+j+"+"+
k+"="+(i+j+k));
14. }}
15. class C extends B{
16. int m;
17. void showm(){
18. System.out.println("inside class C:k="+m);
19. }
20. void add_ijkm(){
21. System.out.println(i+"+"+j+
"+"+k+"+"+m+"="+(i+j+k+m));
22. }
23. }
24. class InheritanceMultilevel{
25. public static void main(String[] args) {
26. A superObjA= new A();
27. superObjA.i=10;
28. superObjA.j=20;
29. superObjA.showij();
30. B subObjB= new B();
31. subObjB.i=100;
32. subObjB.j=200;
33. subObjB.k=300;
34. subObjB.showk();
35. subObjB.add_ijk();
36. C subObjC= new C();
37. subObjC.i=1000;
38. subObjC.j=2000;
39. subObjC.k=3000;
40. subObjC.m=4000;
41. subObjC.showm();
42. subObjC.add_ijkm();
43. }
44. }
Output:
inside class A:i=10 j=20
inside class B:k=300
100+200+300=600
inside class C:k=4000
1000+2000+3000+4000=10000

Derived Class with Constructor

Derived Class with Constructor

1. class Cube{
2. protected double height,width,depth;
3. Cube(){
4. System.out.println("inside default Constructor:CUBE");
5. }
6. double volume(){
7. return height*width*depth;
8. }
9. }
10. class CubeWeight extends Cube{
11. double weigth;
12. CubeWeight(double h,double w,double d, double m)
13. {
14. System.out.println("inside Constructor:CUBEWEIGTH");
15. height=h;C
16. width=w;
17. depth=d;
18. weigth=m;
19. }}
20. class CubeInherit{
21. public static void main(String[] args) {
22. CubeWeight cw1= new CubeWeight(10,10,10,20.5);
23. CubeWeight cw2= new CubeWeight(100,100,100,200.5);
24. System.out.println("cw1.volume()=" +cw1.volume());
25. System.out.println("cw2.volume()="+cw2.volume());
26. }}

Output:
inside default Constructor:CUBE
inside Constructor:CUBEWEIGTH
inside default Constructor:CUBE
inside Constructor:CUBEWEIGTH
cw1.volume()=1000.0
cw2.volume()=1000000.0
Super Keyword
 Whenever a subclass needs to refer to its immediate superclass, it can do so by use of the
keyword super.
 Super has two general forms:
1. Calls the superclass constructor.
2. Used to access a members (i.e. instance variable or method) of the superclass.

Using super to Call Superclass Constructors

Note: Call to super must be first statement in constructor

 super to Call Superclass Constructors
1. class Cube{
2. protected double height,width,depth;
3. Cube(double h,double w,double d){
4. System.out.println("Constructor: CUBE");
5. height=h;
6. width=w;
7. depth=d;
8. }
9. double volume(){
10. return height*width*depth;
11. }
12. }
13. class CubeWeight extends Cube{
14. double weigth;
15. CubeWeight(double h,double w,double d, double m){
16. super(h,w,d); //call superclassConstructor
17. System.out.println("Constructor:CUBEWEIGTH");
18. weigth=m;
19. }
20. }
21. class CubeInheritSuper{
22. public static void main(String[] args) {
23. CubeWeight cw1= new CubeWeight(10,10,10,20.5);
24. CubeWeight cw2= new CubeWeight(100,100,100,200.5);
25. System.out.println("cw1.volume()="+cw1.volume());
26. System.out.println("cw1.weigth="+cw1.weigth);
27. System.out.println("cw2.volume()="+cw2.volume());
28. System.out.println("cw2.weigth="+cw2.weigth);
29. }
30. }
Output:
Constructor:CUBE
Constructor:CUBEWEIGTH
Constructor:CUBE
Constructor:CUBEWEIGTH
cw1.volume()=1000.0
cw1.weigth=20.5
cw2.volume()=1000000.0
cw2.weigth=200.5

Using super to access members

 The second form of super acts somewhat like this, except that it always refers to the
superclass of the subclass in which it is used.

 This second form of super is most applicable to situations in which member names of a
subclass hide members by the same name in the superclass.
 Using super to access members
1. class A{
2. int i;
3. }
4. class B extends A{
5. int i,k;
6. B(int a,int b){
7. super.i=a;
8. this.i=b;
9. }
10. void show(){
11. System.out.println("super.i="+super.i);
12. System.out.println("this.i="+this.i);
13. }
14. }
15. class SuperMemberDemo{
16. public static void main(String[] args)
17. {
18. B b= new B(12,56);
19. b.show();
20. }
21. }
Output:
super.i=12
this.i=56

Points to remember for super

 When a subclass calls super( ), it is calling the constructor of its immediate superclass.
 This is true even in a multileveled hierarchy.
 super( ) must always be the first statement executed inside a subclass constructor.
 If a constructor does not explicitly call a superclass constructor, the Java compiler
automatically inserts a call to the no-argument constructor of the superclass.
 The most common application of super keyword is to eliminate the ambiguity between
members of superclass and sub class.

Access Control
Access Modifier Description
Private(-) The access level of a private modifier is only within the class. It cannot be
accessed from outside the class.
Default(~) The access level of a default modifier is only within the package. It cannot be
accessed from outside the package. If you do not specify any access level, it will
be the default.
Protected(#) The access level of a protected modifier is within the package and outside the
package through child class. If you do not make the child class, it cannot be
accessed from outside the package.
Public(+) The access level of a public modifier is everywhere. It can be accessed from within
the class, outside the class, within the package and outside the package.
Polymorphism
 Polymorphism: It is a Greek term means, “One name many Forms”.

 Most important concept of object oriented programming

 In OOP, Polymorphism is the ability of an object to take on many forms.
 Polymorphism is the method in an object-oriented programming language that does different
things depending on the class of the object which calls it.
 Polymorphism can be implemented using the concept of overloading and overriding.

Polymorphism: Advantages
 Single variable can be used to store multiple data types.
 Easy to debug the codes.
 It allows to perform a single act in different ways.
 Polymorphism allows the object to decide which form of the function to implement at
compile-time (overloading) as well as run-time (overriding).
 Reduces coupling, increases reusability and makes code easier to read.

Implementing Polymorphism

Method Overriding
 In a class hierarchy, when a method in a subclass has the same name and type signature as a
method in its superclass, then the method in the subclass is said to override the method in the
superclass.
 Definition: If subclass (child class) has the same method as declared in the parent class, it is
known as method overriding in Java.
 Method Overriding Demo
1. class Shape{
2. void draw(){
3. System.out.println("Draw Shape");
4. }
5. }
6. class Circle extends Shape{
7. void draw(){
8. System.out.println("Draw Circle");
9. }
10. }
11. class Square extends Shape{
12. void draw(){
13. System.out.println("Draw Square");
14. }
15. }
16. class OverrideDemo{
17. public static void main(String[] args) {
18. Circle c= new Circle();
19. c.draw(); //child class meth()
20. Square sq= new Square();
21. sq.draw();//child class meth()
22. Shape sh= new Shape();
23. sh.draw();//parentClass meth()
24. }
25. }
Output:
Draw Circle
Draw Square
Draw Shape

Why Overriding?
 Method overriding is used to provide the specific implementation of a method which is already
provided by its superclass.
 Method overriding is used for runtime polymorphism.
 By combining inheritance with overridden methods, a superclass can define the general form
of the methods that will be used by all of its subclasses.
 Dynamic, run-time polymorphism is one of the most powerful mechanisms that object-
oriented design brings to bear on code reuse and robustness.

Method Overriding: Points to remember

 Method overriding occurs only when the names and the type signatures of the two methods
are identical. If they are not, then the two methods are simply overloaded.
 The method must have the same name as in the parent class
 The method must have the same parameter as in the parent class.
 There must be an IS-A relationship (inheritance).
Overloading vs Overriding
Method Overloading Method Overriding
Overloading:Method with same name Overriding:Method with same name same
different signature signature
Known as Compile-time Polymorphism Known as Run-time Polymorphism

It is performed within class. It occurs in two classes with IS-A (inheritance)

relationship.
Inheritance and method hiding is not involved Here subclass method hides the super class
here. method.
Dynamic Method Dispatch
 Dynamic method dispatch is the mechanism by which a call to an overridden method is
resolved at run time, rather than compile time.
 Dynamic method dispatch is important because this is how Java implements run-time
polymorphism.
A a = new A(); //object of parent class
B b = new B(); //object of child class

A a = new B();//Up casting(Dynamic Method Dispatch)

B b= new A(); //Error! Not Allowed

 Dynamic Method Dispatch Demo
1. class A{
2. void display(){
3. System.out.println("inside class A");
4. }
5. }
6. class B extends A{
7. void display(){
8. System.out.println("inside class B");
9. }
10. }
11. class C extends A{
12. void display(){
13. System.out.println("inside class C");
14. }
15. }
16. class DispatchDemo{
17. public static void main(String[] args) {
18. A a = new A();
19. B b = new B();
20. C c = new C();
21. A r; //obtain a reference of type A
22. r=a;
23. r.display();
24. r=b;
25. r.display();
26. r=c;
27. r.display();
28. }
29. }
Output:
inside class A
inside class B
inside class

“final” keyword
 The final keyword is used for restriction.
 final keyword can be used in many context
 Final can be:
1. Variable
If you make any variable as final, you cannot change the value of final variable (It will be
constant).
2. Method
If you make any method as final, you cannot override it.
3. Class
If you make any class as final, you cannot extend it.
“final” as a variable
Cannot change the value of final variable.

public class FinalDemo {

final int speedlimit=90;//final variable
void run(){
speedlimit=400; //ERROR!
}
public static void main(String args[]){
FinalDemo obj=new FinalDemo();
obj.run();
}
}

“final” as a method
If you make any method as final, you cannot override it.
class BikeClass{
final void run(){
System.out.println("Running Bike");
}
}

class Pulsar extends BikeClass{

void run(){
System.out.println("Running Pulsar");//ERROR!
}

public static void main(String args[]){

Pulsar p= new Pulsar();
p.run();
}
}
“final” as a Class
If you make any class as final, you cannot extend it.
final class BikeClass{
void run(){
System.out.println("Running Bike");
}
}
class Pulsar extends BikeClass //ERROR!
{
void run(){
System.out.println("Running Pulsar");
}

public static void main(String args[]){

Pulsar p= new Pulsar();
p.run();
}
}

Encapsulation
 The action of enclosing something in.
 In OOP, encapsulation refers to the bundling of data with the methods.

Data Members(e.g. int a=10)

+
Methods(e.g. add() )
 }
The wrapping up of data and functions into a single unit is known as encapsulation
 The insulation of the data from direct access by the program is called data hiding or
information hiding.
 It is the process of enclosing one or more details from outside world through access right.
Advantages
 Protects an object from unwanted access
 It reduces implementation errors.
 Simplifies the maintenance of the application and makes the application easy to understand.
 Protection of data from accidental corruption.
Abstraction
 Data abstraction is also termed as information hiding.
 Abstraction is the concept of object-oriented programming that “represents” only essential
attributes and “hides” unnecessary information.
 Abstraction is all about representing the simplified view and avoid complexity of the system.
 It only shows the data which is relevant to the user.
 In object-oriented programming, it can be implemented using Abstract Class.
Advantages:
 It reduces programming complexity.
 Example:
A car is viewed as a car rather than its numerous individual components.

Abstraction vs. Encapsulation

Abstraction Encapsulation
It means act of removing/ withdrawing It is act of binding code and data together and
something unnecessary. keep the data secure from outside
interference.
Applied at Designing stage. Applied at Implementation stage.

E.g. Interface and Abstract Class E.g. Access Modifier (public, protected,
private)
Purpose: Reduce code complexity Purpose: Data protection

Implementing Abstraction
 Abstraction is a process of hiding the implementation details from the user, only the
functionality will be provided to the user.
 In other words, the user will have the information on what the object does instead of how the
object will do it.
 Abstraction is achieved using Abstract classes and interfaces.
 A class which contains the abstract keyword in its declaration is known as abstract class.
o Abstract classes may or may not contain abstract methods, i.e., methods without
body ( public void get(); )
o But, if a class has at least one abstract method, then the class must be declared
abstract.
o If a class is declared abstract, it cannot be instantiated.
o To use an abstract class, we have to inherit it to another class and provide
implementations of the abstract methods in it.
Abstract class
Abstract class (Example)
1. abstract class Car {
2. public abstract double getAverage();
3. }
4. class Swift extends Car{
5. public double getAverage(){
6. return 22.5;
7. }
8. }
9. class Baleno extends Car{
10. public double getAverage(){
11. return 23.2;
12. }
13. }
14. public class MyAbstractDemo{
15. public static void main(String ar[]){
16. Swift s = new Swift();
17. Baleno b = new Baleno();
18. System.out.println(s.getAverage());
19. System.out.println(b.getAverage());
20. }
21. }

Why Abstract Class?

 Sometimes, we need to define a superclass that declares the structure of a given abstraction
without providing a complete implementation.
 The superclass will only define a generalized form that will be shared by all the subclasses.
 The subclasses will fill the details of every method.
 When a superclass is unable to create a meaningful implementation for a method.

Points to remember for Abstract Class

 To declare a class abstract, you simply use the abstract keyword in front of the class keyword
at the beginning of the class declaration.
 There can be no objects of an abstract class. That is, an abstract class cannot be directly
instantiated with the new operator. Such objects would be useless, because an abstract class
is not fully defined.
 Cannot declare abstract constructors, or abstract static methods.
 Any subclass of an abstract class must either implement all of the abstract methods in the
superclass, or be itself declared abstract.
Interface
 An interface is similar to an abstract class with the following exceptions
o All methods defined in an interface are abstract.
o Interfaces doesn’t contain any logical implementation
o Interfaces cannot contain instance variables. However, they can contain public
static final variables (ie. constant class variables)
 Interfaces are declared using the "interface" keyword
 Interfaces are more abstract than abstract classes
 Interfaces are implemented by classes using the "implements" keyword
 Interfaces are syntactically similar to classes, but they lack instance variables, and their
methods are declared without any body.

Interface: Syntax

access class classname

[extends superclass]
[implements interface [,interface...]] {
// class-body
}
access interface name
{
return-type method-name1(parameter-list);
type final-varname1 = value;
}
Interface (Example)
1. interface VehicleInterface {
2. int a = 10;
3. public void turnLeft();
4. public void turnRight();
5. public void accelerate();
6. public void slowDown();
7. }
8. public class DemoInterface{
9. public static void main(String[] a)
10. {
11. CarClass c = new CarClass();
12. c.turnLeft();
13. }
14. }
15. class CarClass implements VehicleInterface
16. {
17. public void turnLeft() {
18. System.out.println("Left");
19. }
20. public void turnRight() {
21. System.out.println("Right");
22. }
23. public void accelerate() {
24. System.out.println("Speed");
25. }
26. public void slowDown() {
27. System.out.println(“Brake");
28. }
29. }
Output:
Left
Interface: Partial Implementations
 If a class includes an interface but does not fully implement the methods defined by that
interface, then that class must be declared as abstract.
Interface: Partial Implementations
1. interface VehicleInterface {
2. int a = 10;
3. public void turnLeft();
4. public void turnRight();
5. public void accelerate();
6. public void slowDown();
7. }
8. public class DemoInterface{
9. public static void main(String[] a)
10. {
11. CarClass c = new CarClass();
12. c.turnLeft();
13. }
14. }
15. abstract class CarClass implements VehicleInterface
16. {
17. public void turnLeft() {
18. System.out.println("Left");
19. }
20. public void turnRight() {
21. System.out.println("Right");
22. }
23. }
 Interface:Example StackDemo.java
1. interface StackIntf{
2. public void push(int p);
3. public int pop();
4. }
5. class CreateStack implements StackIntf{
6. int mystack[];
7. int tos;
8. CreateStack(int size){
9. mystack= new int[size];
10. tos=-1;
11. }
12. public void push(int p){
13. if(tos==mystack.length-1){
14. System.out.println("StackOverflow");
15. }
16. else{
17. mystack[++tos]=p;
18. }
19. }
20. public int pop(){
21. if(tos<0){
22. System.out.println("StackUnderflow");
23. return 0;
24. }
25. else return mystack[tos--];
26. }
27. }
28. class StackDemo{
29. public static void main(String[] args) {
30. CreateStack cs1= new CreateStack(5);
31. CreateStack cs2= new CreateStack(8);
32. for(int i=0;i<5;i++)
33. cs1.push(i);
34. for(int i=0;i<8;i++)
35. cs2.push(i);
36. System.out.println("MyStack1=");
37. for(int i=0;i<5;i++)
38. System.out.println(cs1.pop());

39. System.out.println("MyStack2=");

40. for(int i=0;i<8;i++)

41. System.out.println(cs2.pop());
42. }
43. }
Interfaces Can Be Extended
 One interface can inherit another by use of the keyword extends.
 The syntax is the same as for inheriting classes.
 When a class implements an interface that inherits another interface, it must provide
implementations for all methods defined within the interface inheritance chain.
InterfaceHierarchy.java
1. interface A{
2. void method1();
3. void method2();
4. }
5. interface B extends A{
6. void method3();
7. }
8. interface C extends A{
9. void method4();
10. }
11. class InterfaceHierarchy{
12. public static void main(String[] args) {
13. MyClass1 c1=new MyClass1();
14. MyClass2 c2=new MyClass2();
15. c1.method1();
16. c1.method2();
17. c1.method3();
18. c2.method1();
19. c2.method2();
20. c2.method4();
21. }
22. }
23. class MyClass1 implements B{
24. public void method1(){
25. System.out.println("inside MyClass1:method1()");}
26.
27. public void method2(){
28. System.out.println("inside MyClass1:method2()");
29. }
30.
31. public void method3(){
32. System.out.println("inside MyClass1:method3()");
33. }
34. }
35. class MyClass2 implements C{
36. public void method1(){
37. System.out.println("inside MyClass2:method1()");}
38.
39. public void method2(){
40. System.out.println("inside MyClass2:method2()");
41. }
42.
43. public void method4(){
44. System.out.println("inside MyClass2:method4()");
45. }
46. }
Interface: Points to Remember
 Any number of classes can implement an interface.
 One class can implement any number of interfaces.
 To implement an interface, a class must create the complete set of methods defined by the
interface. However, each class is free to determine the details of its own implementation.

Abstract class vs. Interface

Abstract class Interface
Abstract class doesn't support multiple Interface supports multiple inheritance.
inheritance.
Abstract class can have abstract and non- Interface can have only abstract methods.
abstract methods.
Abstract class can have final, non-final, static Interface has only static and final variables.
and non-static variables.
An abstract class can extend another Java An interface can extend another Java interface
class and implement multiple Java interfaces. only.
A Java abstract class can have class members Members of a Java interface are public by
like private, protected, etc. default.

instanceof operator
Syntax:
(Object reference variable ) instanceof (class/interface type)
Example:
boolean result = name instanceof String;
Wrapper classes
 A Wrapper class is a class whose object wraps or contains a primitive datatypes.
 When we create an object to a wrapper class, it contains a field and in this field, we can store
a primitive datatypes.
 In other words, we can wrap a primitive value into a wrapper class object.
 Use of wrapper class :
o They convert primitive datatypes into objects.
o The classes in java.util package handles only objects and hence wrapper classes help
in this case also.
o Data structures in the Collection framework, such as ArrayList and Vector, store only
objects (reference types) and not primitive types.
o An object is needed to support synchronization in multithreading.
Primitive datatypes: Wrapper class
Primitive datatype Wrapper class Example
byte Byte Byte b = new Byte((byte) 10);
short Short Short s = new Short((short) 10);
int Integer Integer i = new Integer(10);
long Long Long l = new Long(10);
float Float Float f = new Float(10.0);
double Double Double d = new Double(10.2);
char Character Character c = new Character('a');
boolean Boolean Boolean b = new Boolean(true);

Parsing the String

Using wrapper class we can parse string to any primitive datatype (Except char).
byte b1 = Byte.parseByte("10");
short s = Short.parseShort("10");
int i = Integer.parseInt("10");
long l = Long.parseLong("10");
float f = Float.parseFloat("10.5");
double d = Double.parseDouble("10.5");
boolean b2 = Boolean.parseBoolean("true");
char c = Character.parseCharacter('a');

BigInteger and BigDecimal

 The BigInteger class found in java.math package is used for mathematical operation which
involves very big integer calculations that are outside the limit of all available primitive data
types.
o For example factorial of 100 contains 158 digits in it so we can’t store it in any
primitive data type available.
o There is no theoretical limit on the upper bound of the range because memory is
allocated dynamically
import java.math.BigInteger;
public class DemoBigNumbers {
public static void main(String[] args) {
BigInteger bi = new BigInteger("1234567891234567891234567890");
System.out.println(bi); // will return 1234567891234567891234567890
}
}

BigDecimal bd = new BigDecimal("111111.000000000000000000025");

System.out.println(bd); //111111.000000000000000000025

 The BigDecimal class found in java.math package provides operation for arithmetic,
comparison, hashing, rounding, manipulation and format conversion.
o This method can handle very small and very big floating point numbers with great
precision.
 An object of the String class represents a string of characters.
  The String class belongs to the java.lang package, which does not require an import
statement.
 Like other classes, String has constructors and methods.
 String class has two operators, + and += (used for concatenation).

Empty String :
 An empty String has no characters. Its length is 0.

 Not the same as an uninitialized String.

 Copy constructor creates a copy of an existing String.

String Class
 In java, a string is a sequence of characters. But, unlike many other languages that
implement strings as character arrays, java implements strings as objects of type String.
 When we create a String object, we are creating a string that cannot be changed. That is,
once a String object has been created, we cannot change the characters that comprise that
string. We can perform all types of operations.
 For those cases in which a modifiable string is desired, java provides two options:
StringBuffer and StringBuilder. Both hold strings that can be modified after they are
created.
 The String, StringBuffer and StringBuilder classes are defined in java.lang. Thus, they are
available to all programs automatically. All three implements CharSequence interface.
 String Constructor
 The String class support several constructors. To create an empty String, you call the default
constructor.
 For example,
String s=new String();
this will create an instance of with no characters in it.
String s = new String(“Computer Deparatment”);
 class StringEx
{
public static void main(String args[])
{
String s1=new String("Computer Department");
String s2;
s2=s1 + "Darshan University";
System.out.println(s2);
}
}

String Immutability
Advantage Disadvantage
Convenient — Immutable objects are Less efficient — you need to create a new string
convenient because several references can and throw away the old one even for small
point to the same object safely. changes.
String name="DIET - Rajkot"; String word = "java";
foo(name); char ch = Character.toUpperCase(
//Some operations on String name word.charAt (0));
name.substring(7,13); word = ch + word.substring (1);
bar(name);

String Methods
Method Call Task Performed
S2=s1.toLowerCase; Conver ts the string s1 to lowercase
S2=s1.toUpperCase; Converts the string s1 to uppercase
S2=s1.replace(‘x’,’y’) Replace all appearances of x with y.
S2=s1.trim() Remove white spaces at the beginning and end of the string s1
S1.equals(s2) Returns true if s1 and s2 are equal
S1.equalsIgnoreCase(s2) Returns true if s1=s2, ignoring the case of characters
S1.length() Gives the length of s1
S1.CharAt(n) Gives the nth character of s1
S1.compareTo(s2) Returns –ve if s1<s2, +ve if s1>s2, and 0 if s1=s2
S1.concat(s2) Concatenates s1 and s2
S1.substring(n) Gives substring starting from nth character.
S1.substring(n,m) Gives substring starting from nth char up to mth
toString() This object (which is already a string!) is itself returned.
S1.indexOf(‘x’) Gives the position of the first occurrence of ‘x’ in the string s1
S1.indexOf(‘x’,n) Gives the position of ‘x’ that occurs after nth position in the string s1
String.ValueOf(variable) Converts the parameter value of string representation

StringBuffer
 The java.lang.StringBuffer class is a thread-safe, mutable sequence of characters.
 Following are the important points about StringBuffer:
 A string buffer is like a String, but can be modified (mutable).
 It contains some particular sequence of characters, but the length and content of
the sequence can be changed through certain method calls.
 They are safe for use by multiple threads.
 StringBuffer defines these Constructor:
StringBuffer()
StringBuffer(int size)
StringBuffer(String str)
StringBuffer(CharSequence chars)
 Remember : “StringBuffer” is mutable
 As StringBuffer class is mutable, we need not to replace the reference with a new reference
as we have to do it with String class.
StringBuffer str1 = new StringBuffer("Hello Everyone");
str1.reverse();
// as it is mutable can not write str1 = str1.reverse();
// it will change to value of the string itself
System.out.println(str1);
// Output will be “enoyrevE olleH”

StringBuffer Methods
Method Description
append(String s) Used to append the specified string with this string.
insert(int offset, String s) Used to insert the specified string with this string at the
specified position.
replace(int startIndex, int endIndex, Used to replace the string from specified startIndex and
String str) endIndex.
delete(int startIndex, int endIndex) Used to delete the string from specified startIndex and
endIndex.
reverse() Used to reverse the string.
String Builder
 Java StringBuilder class is used to create mutable string.
 The Java StringBuilder class is same as StringBuffer class except that it is non-synchronized.
 It is available since JDK 1.5.
 It has similar methods as StringBuffer like append, insert, reverse etc…

ArrayList
 The java.util.ArrayList class provides resizable-array and implements the List interface.
 Following are the important points about ArrayList:
 It implements all optional list operations and it also permits all elements, including null.
 It provides methods to manipulate the size of the array that is used internally to store the
list.

ArrayList (constructors) :
Sr Constructor & Description
1 ArrayList()
This constructor is used to create an empty list with an initial capacity sufficient to hold
10 elements.
2 ArrayList(Collection<? extends E> c)
This constructor is used to create a list containing the elements of the specified
collection.
3 ArrayList(int initialCapacity)
This constructor is used to create an empty list with an initial capacity.

ArrayList (method)
Sr Method & Description
1 void add(int index, E element)
This method inserts the specified element at the specified position in this list.
2 boolean addAll(Collection<? extends E> c)
This method appends all of the elements in the specified collection to the end of this list,
in the order that they are returned by the specified collection's Iterator
3 void clear()
This method removes all of the elements from this list.
4 boolean contains(Object o)
This method returns true if this list contains the specified element.
5 E get(int index)
This method returns the element at the specified position in this list.
6 int indexOf(Object o)
This method returns the index of the first occurrence of the specified element in this list,
or -1 if this list does not contain the element.
7 boolean isEmpty()
This method returns true if this list contains no elements.
8 int lastIndexOf(Object o)
 This method returns the index of the last occurrence of the specified element in this list,
or -1 if this list does not contain the element.
9 boolean remove(Object o)
This method removes the first occurrence of the specified element from this list, if it is
present.
10 E set(int index, E element)
This method replaces the element at the specified position in this list with the specified
element.
11 int size()
This method returns the number of elements in this list.
12 Object[] toArray()
This method returns an array containing all of the elements in this list in proper sequence
(from first to last element).