Java Notes Final

OPERATORS:
OPERATOR PERFORMS OPERATIONS ON OPRERANDS AND PRODUCE RESULTS
1) ANALYSIS
2) PROCESS- CONDITION BASED & NON- CONDITION BASED(FORMULA
BASED)
EX- FOR SIMPLE INTEREST
STEPS- P*T*R/100
INPUTS
VARIABLES
DOUBLE P=___
DOUBLE T=___
DOUBLE R=___
FOR OUTPUT USE VARIABLE DOUBLE
class simpleinterest
{
public static void main(Strings() args)
{
double p=5.0;
double t=6.0;
double r=7.5;
double si=p*t*r/100;
System.out.println(si);
}
}
INCREMENT OPERATOR WILL INCREASE THE VALUE OF A VARIABLE BY ONE
UNIT
PRE INCREMENT (+ + a)
INCREMENT
SUBSTITUE
OPERATION
POST INCREMENT (a + +)
SUBSTITUE
OPERATION
INCREMENT
--BOTH PRE INCREMENT AND POST INCREMENT OPERATORS WILL SHOW
SAME RESULTS IF THEY ARE USED WITHOUT ANY EXPRESSIONS OR JAVA
STATEMENTS
--WHENEVER THE INCREMENT OPERATOR IS USED WITH A CHARACTER
VARIABLE THE UNICODE VALUE OF THE CHARACTER WILL BE INCREASED
AND ITS CORRESPONDING CHARACTER WILL BE STORED IN THE GIVEN
VARIABLE.
--BOOLEAN VARIABLES CAN’T BE USED WITH INCREMENT OPERATOR.
--VALUES CANT BE DIRECTLY USE WITH INCREMENT OPERATOR
Ex-Int a =10;
Int res= ++a +a+ a++ +5 + ++a
10+1+11+11+5+12+1
11+11+11+5+13
51
COMPARISON OPERATORS:
COMPARISON OPERATORS WILL COMPARE GIVEN 2 VALUES AND RETURNS A
BOOLEAN RESULT
== , !=, > , <, >= , <=
A=1,B=2
A == B
1 ==2 ------- >False
A != B
1 != 2------- > TRUE
A<B
1 < 2 ------- > TRUE
A>B
1 > 2 ------- > FALSE
A >= B
1 >= 2 ------- > FALSE
A<=B
1 <= 2 ------- > TRUE
public class com {

public static void main(String[] args) {
int a=10;
int b=11;
boolean res= a==b;
System.out.println(res); //store the value of boolean result
System.out.println(a!=b);
System.out.println(a>b);
System.out.println(a<b);
System.out.println(a>=b);
System.out.println(a<=b);
}
}
OUTPUT:
PS F:\Vinay QSpider\JAVA Pgms> java com.java
false
true
false
true
false
true
BOOLEAN CONDITION:
ANY EXPRESSION WHICH PRODUCE THE RESULT AS TRUE OR FALSE IS
KNOWN AS BOOLEAN CONDITION.
BOOLEAN CONDITION CAN BE CREATED WITH THE HELP OF COMPARISON
OPERATORS
Ex-
public class com {
int a=10;
int b=11;
boolean res= a==b;
System.out.println(res); //store the value of boolean result
System.out.println(a!=b);
System.out.println(a>b);
System.out.println(a<b);
System.out.println(a>=b);
System.out.println(a<=b);
}
}
OUTPUT:
PS F:\Vinay QSpider\JAVA Pgms> java com.java
false
true
false
true
false
true
LOGICAL OPERATORS:
LOGICAL OPERATORS ARE USED TO COMMBINE MULTIPLE BOOLEAN
CONDITIONS AS ONE SINGLE CONNDITION.
LOGICAL OPERATORS WILL ALWAYS RETURN A BOOLEAN RESULT
DIFFERENT TYPES OF LOGICAL OPERATORS ARE
1. LOGICAL AND (&&)
2. LOGICAL OR (II)
3. LOGICAL XOR (^)
LOGICAL AND (&&)

LOGICAL AND 7& OPERATORS WILL RETUTN TRUE IF AND ONLY IF THE
RESULT OF BOTH THE BOOLEAN CONDITIONS RESULT IS TRUE AND IN ALL
OTHER CASES IT RETURNS FALSE.
TRUTH TABLE FOR LOGICAL AND (&&)
CONDITION 1 CONDITION 2 RESULT

TRUE TRUE TRUE
TRUE FALSE FALSE
FLASE TRUE FALSE
FLASE FLASE FALSE
public class Logical {

int a=1;
int b=10;
System.out.println(a<=b && b>=a);// comparing 2 bollean by combining &
using logical operator '&&' true && true
System.out.println(a<=b && b<=a); //true && false = false
System.out.println(a>=b && b<=a); // false && true = false
System.out.println(a>=b && b<=a); // false && false= false
}
}
OUTPUT:
PS F:\Vinay QSpider\JAVA Pgms> javac Logical.java
PS F:\Vinay QSpider\JAVA Pgms> java Logical.java
true
false
false
false
LOGICAL OR (||)
LOGICAL OR ( || ) OPERATOR WILL RETURN FALSE IF AND ONLY IF THE RESULT

OF BOTH THE BOOLEANCONDITIONS RESULT IS FALSE AND IN ALL OTHER CASES
IT RETURNS TRUE
TRUTH TABLE OF LOGICAL OR(||)
CONDITION 1 CONDITION 2 RESULT

TRUE TRUE TRUE
TURE FALSE TRUE
FALSE TRUE TRUE
FALSE FALSE FALSE
BITWISE OPERATOR
BITWISE OPERATOR WILL PERFORM BITWISE OPERATIONS ON EVERY BIT OF

GIVEN VALUE AND PRODUCE RESULTS AS 0 OR 1
0011001 0011001 0011001

1100100(&) 1100100(|) 1100100(^)
-------------- ------------- ---------------
0000000 1111101 1111101
public class Bit {

int a = 25;
int b = 100;
System.out.println(a&b);
System.out.println(a|b);
System.out.println(a^b);
}
}
Output:
PS F:\Vinay QSpider\JAVA Pgms> javac Bit.java
PS F:\Vinay QSpider\JAVA Pgms> java Bit
0
125
125
public class Bit {
int a = 10;
int b = 50;
System.out.println(a&b);
System.out.println(a|b);
System.out.println(a^b);
}
}
Output
PS F:\Vinay QSpider\JAVA Pgms> javac Bit.java

PS F:\Vinay QSpider\JAVA Pgms> java Bit
2
58
56
CONCATENATION OPERATORS:
-CONCATENATION OPERATOR (+) IS USED TO JOIN A STRING VALUE WITH ANY

OTHER DATA.
-BETWEEN A STRING AND ANY OTHER TYPE IF YOU USE + OPERATOR IT WILL
JOIN THE STRING AND GIVEN VALUE CREATING A NEW STRING.
EX: - “HELLO” + “WORLD”

O/P- HELLOWORLD
“HELLO” + 10
O/P- HELLO10
public class conc {

System.out.println("VALUE=" +10);
System.out.println("HELLO"+"JAVA");
System.out.println("HELLO"+"A");
System.out.println("10"+1+10);
System.out.println(10+1+"10"); // arithmetic operator will execute 1st
}
}
Output:
PS F:\Vinay QSpider\JAVA Pgms> JAVAC conc.java
PS F:\Vinay QSpider\JAVA Pgms> java conc
VALUE=10
HELLOJAVA
HELLOA
10110
1110
IMPORTANT
FUNCTIONS/METHOD
FUNCTIONS IS NAMED BLOCK OF CODE USED TO CODE REUSEABLITY
METHODS
1. METHODS ARE USED TO ELIMINATE DUPLICATE LINES OF CODE IN THE
PGM
2. METHODS ARE NAMED BLOCKS OF CODES WHICH WILL PERFORM A
SPECIFIC TASK
SYNTAX
accessspecifier accessmodifier returntype methodname(parameteers)
public static void main (String[] args)
Accessspecifier
1. Public
2. Protected
3. Packaging level(Default value)
4. Private
Accessmodifier
1. Static
2. Non-Static(Default value)
ReturnType
1. Void
2. All datatypes
accessspecifier accessmodifier returntype methodname(parameteers/argument list)
{
Statement;
Statement;
Return;
}
class add
{
Public static void add(int v1, int v2)
{
int res=v1+v2;
System.out.println(res);
}
public static void main(String[] args]
{
add(15,20);
add(100,200);
}
 IF METHODS RETUTNS ANY VALUE THEN THE RETURNED VALUE SHOULD

BE STORED IN A VARIABLE MATCHING THE RETURN TYE OF THE METHOD
 A METHOD WHICH IS CALLING ANOTHER METHOD IS KNOWING AS
CALLING METHOD
 A METHOD WHICH IS CALLED ANOTHER METHOD IS KNOWING AS CALLED
METHOD
 RETURN STATEMENT IS USED TO TRANSFER THE CONTROL & THE VALUES
FROM CALLED METHOD TO CALLING METHOD
 IF METHOD DO NOT RETURN ANY VALUE THEN ITS RETUTN TYPE SHOULD
BE DECLARED AS VOID.
IF RETUTN
TYPES OF FUNCTION CALL

1. CHAIN FUNCTION CALL
2. SEQUENCE FUNCTION CAL
3. RE
CHAIN FUNCTION CALL
M1() { }
M2() { }
Main() { }
IF A METHOD CALLS ANOTHER METHODAND THAT METHOD CALLS ONE MORE
METHOD IS KNOWN A CHAIN FUNCTION METHOD(MINIMUM 3 FUNCTION)
SEQUENCE FUNCTION CALL

M1() { }
M2() { }
Main() { }
SAME METHOD CALLING MORE THEN ONE METHOD IS CALLED AS SEQUENCE

FUNCTION CALL.
RECURSIVE FUNCTION CALL
M1() { }
Main() { }
M1() { }
Main() { }
IF A METHOD CALLS ANOTHER METHOD AND THAT METHOD CALLS BACK THE
SAME METHOD IS CALLED AS RECURSIVE FUNCTION CALL.
IF A METHOD CALLS ITSELF IS ALSO CALLED AS RECURSIVE FUNCTION CALL.
FLOW CONTROL STATEMENT
FLOW CONTROL STATEMENTS ARE USED TO CONTROL THE EXECUTOIN FLOW OF
THE PROGRAM ATA THE RUNTIME.
FLOW CONTROL STATEMENTS ARE OF 2 TYPES:
1. DECISION MAKING STATEMENTS
2. LOOPING STATEMENTS
DECISION MAKING STATEMENTS

DECISION MAKING STATEMENTS ARE USED TO EXECUTE ONE OR GROUP OF
STATEMENTS BASED ON A BOOLEAN CONDITION.
BOOLEAN CONDITION/BOOLEAN EXP: A COMPARISON STATEMENT WRITTEN
USING COMPARISONN OPTS AND LOGICAL OPTS IS CALLED BOOLEAN EXP/COND.
TYPES DECISION MAKING STATEMENTS
1. IF
2. IF-ELSE
3. IF-ELSE-IF
4. SWITCH
IF STATEMENT:
IT IS A TYPE OF DECISION MAKING WHERE ONE GROUP OF STATEMENTS
WRITTEN WITHIN THE IF BODY WILL BE EXECUTED IF AND ONLYIF RESULT OF
BOOLEAN CONDITION IS TRUE.
SYNTAX: if(BOOLEAN CONDITION
{
STATEMENT……..
STATEMENT……..
}
BOOL FALSE
AEN
COND
CON
TRUE
public class number {

public static void check(int num)
{
if(num>100)
{
System.out.println(num+" is greater than 100");
}
}
check(90);
check(101);
}
}
Output:
PS F:\Vinay QSpider\JAVA Pgms> javac number.java
PS F:\Vinay QSpider\JAVA Pgms> java number
101 is greater than 100
IF ELSE STATEMENT:
IT IS A TYPE OF DECISION MAKING STATEMENTS WHERE STATEMENTS OF IF
BODY ARE EXECUTED IF RESULT OF BOOLEAN CONDITION IS TRUE ELSE THE
STATEMENT OF ELSE BODY ARE EXECUTED.
SYNTAX:
if(Boolean Condition)
{
Statement….
Statement…..
}
else
{
Statement…..
Statement….
}
public class ifelse
{
public static void check(int num)
{
if(num>100){
System.out.println(num+"is greater than 100");
}
else
{
System.out.println(num+" is less than 100");
}
}
check(90);
check(115);
}
}
Output:
PS F:\Vinay QSpider\JAVA Pgms> javac ifelse.java
PS F:\Vinay QSpider\JAVA Pgms> java ifelse
90 is less than 100
115is greater than 100
IF ELSE IF:
IT IS A TYPE OF DECISION MAKING STATEMENTS WHICH IS USED TO WHENEVER
THERE ARE MULTIPLPE BOOLEAN CONDITIONS TO BE EVALUATED TO EXECUTE
DIFFERENT SET OF STATEMENTS
SYNTAX:
if(Boolean condition)
{
Statement…..
Statement….
}
else if(Boolean condition)
{
Statement…..
Statement….
}
if
{
Statement…..
Statement….
}
public class Ifelseif {
public static void check(int num) {
if (num > 100) {
System.out.println(num + " is greater than 100");
} else if (num < 100) {
System.out.println(num + " is less than 100");
} else {
System.out.println(num + " is equal to 100");
}
}
check(100);
check(88);
check(128);
}
}
PS F:\Vinay QSpider\JAVA Pgms> javac Ifelseif.java

PS F:\Vinay QSpider\JAVA Pgms> java Ifelseif
100 is equal to 100
88 is less than 100
128 is greater than 100
Template to Solve the Program:
1) Analysis: Inputs & Output
2) Process: Step 1:
Step 2:
Step 3:
3) Coding: Write logic
4) Tracing:
Inputs Code Actual Output Expected Output
5) Class Name:
Example:
1) public class Bill {

2) public static double check(double units)
3) {
4) if(units>=0 && units<=200)
5) {
6) double bill=0.0;
7) return bill;
8) }
9) else if(units>200 && units<=300){
10) double bill=units*6;
11) return bill;
12) }
13) else{
14) double bill=units*7;
15) return bill;
16) }
17) }
18) public static void main(String[] args) {
19) System.out.println(check(101.28));
22)
23) }
24) }
Output:
PS F:\Vinay QSpider\JAVA Pgms> javac Bill.java
PS F:\Vinay QSpider\JAVA Pgms> java Bill

0.0
1501.32
2806.16
NESTED IF
IF WE WRITE AN ”IF” STATEMENT WITHIN THE BODY OF ANOTHER IF
STATEMENT THEN IT IS KNOWN AS NESTED IF.
SYNTAX:
if(Boolean condition)
{
if (Boolean condition)
{
Statement…..
}
else
{
Statement…..
}
}
public class Nested1
{
public static void test(int a,int b)
{
if(a==1)
{
if (b==2)
{
System.out.println("Love You");
}
else
{
System.out.println("Invalid Love");
}
}
else
{
System.out.println("Invalid Girl");
}
}
public static void main(String[] args)

{
test(1, 2);
}
}
Output:
PS F:\Vinay QSpider\JAVA Pgms\codingbat> java Nested1.java
Love You
public class Nested1
{
public static void test(int a,int b)
{
if(a==1)
{
if (b==2)
{
System.out.println("Love You");
}
else
{
System.out.println("Invalid Love");
}
}
else
{
System.out.println("Invalid Girl");
}
}

{
test(5, 5);
}
}
PS F:\Vinay QSpider\JAVA Pgms\codingbat> javac Nested1.java

PS F:\Vinay QSpider\JAVA Pgms\codingbat> java Nested1
Invalid Girl
//**CHECK IF THE NUMBER IS +VE OR NOT , IF NUMBER IS +VE THEN CHECK THE
GIVEN NUMBER IS EVEN OR ODD.**//
SWITCH
IT IS A TYPE OF DECISION MAKING STATEMENTS WHICH IS USED WHENEVER

THERE ARE ONLY EQUALLS CONDITIONS TO BE EVALUATED TO EXECUTE
DIFFERENT SET OF STATEMENTS.
Syntax:
switch(choice)
{
case choice 1:statement

break;
case choice 2:statement
break;
default: statements
}
Class quiz{
public static void quiz(int option)
{
switch(option)
{
case 1: System.out.println(“option 1 is selected);
break;
case2: System.out.println(“option 2 is selected);
break;
break;
break;
default: System.out.println(“Invalid option is selected);
}
}
{
quiz(1);
quiz(2);
quiz(10);
}
}
PS F:\Vinay QSpider\JAVA Pgms\codingbat> javac quiz.java

PS F:\Vinay QSpider\JAVA Pgms\codingbat> java quiz
Option 1 is selected
OPtion 2 is selected
Invalid option is selected
LOOPING STATEMENTS
LOOPING STATEMENTS ARE USED TO EXECUTE ONE OR MULTIPLE STATEMENTS

REPEATEDLY.
IN JAVA THERE ARE 4 LOOPING STATEMENTS
1. FOR LOOP
2. WHILE LOOP
3. DO-WHILE LOOP
4. FOR-EACH LOOP
EXAMPLE:
FOR LOOP IS USED WHENEVER LOGICAL START AND LOGICAL END IS VERY
WELL DEFIENED
OR
FOR LOOP IS USED WHENEVER WE KNOW THE NUMBER OF ITTERATION
SYNTAX:
START check did you reach the end

For (initialization; stop_condition; counter)
{
Statements………
Statements………
}
public class loop1 {

public static void test(int end)
{
for(int start=1;start<=end;start++){
System.out.println("hello");
}
}
{
test(5);
}
}
Output:
PS F:\Vinay QSpider\JAVA Pgms\codingbat\looping statements> javac loop1.java
PS F:\Vinay QSpider\JAVA Pgms\codingbat\looping statements> java loop1
hello
hello
hello
hello
hello
Print the numbers from 1-10 & trace code for 1st three iteration
public class onetoten {

public static void test(int end){
for(int start=1;start<=end;start++)
System.out.println(start);
}
test(10);
}
}
Output:
PS F:\Vinay QSpider\JAVA Pgms\codingbat\looping statements> javac onetoten.java
PS F:\Vinay QSpider\JAVA Pgms\codingbat\looping statements> java onetoten
1
2
3
4
5
6
7
8
9
10
Print the numbers from 10 to 1?

Print even numbers from 1 to 100?
Print odd numbers from 1 to 100?
public class onetoten {
public static void test(int end){
for(int start=10;start>=end;start--)
System.out.println(start);
}
test(10);
}
}
Calculate sum of even number from 1 to 100?

WHILE LOOP:
WHILE LOOP IS USED WHEN EVER STOP CONDITION IS NOT VERY WELL DEFINED.
Syntax:
while(Boolean condition)
{
Statement…..
Statement…..
}
Print the number 10 to 1 using while loop.
DO WHILE LOOP:
DO WHILE LOOP IS USED WHENEVER THE STATEMENTS OF THE LOOP SHOULD BE

EXECUTE FIRST & LATER CONDITION SHOULD BE EVALUATED.
Syntax:
do
{
Statements…….
Statements…….
}
while(Boolean Condition);
Println()= Print the output and move to next line
Print()= print the output and stay in the same line
NESTED LOOP
WRITING THE LOOP WITHIN THE BODY OF ANOTHER LOOP.
class Nestedloop
{
public static void test()
{
for(int i=1;i<=3;i++)
{
For(int j=1;j<=3;j++)
{
System.out.print(“Inner Loop”);
}
System.out.println(“Outer Loop”);
}
}
{
test(3);
}
}
public class nestedloop {
public static void test(int n)
{
for(int i=1;i<=n;i++)
{
for(int j=1;j<=5;j++)
{
System.out.print("*"+" ");
}
System.out.println();
}
}
test(5);
}
}
PS F:\Vinay QSpider\JAVA Pgms\codingbat\looping statements> javac nestedloop.java

PS F:\Vinay QSpider\JAVA Pgms\codingbat\looping statements> java nestedloop
*****
*****
*****
*****
*****
public class nestedloop {

public static void test(int n)
{
for(int i=1;i<=n;i++)
{
for(int j=1;j<=i;j++)
{
System.out.print("*"+" ");
}
}
}
test(5);
}
}
Output:
PS F:\Vinay QSpider\JAVA Pgms\codingbat\looping statements> javac nestedloop.java

PS F:\Vinay QSpider\JAVA Pgms\codingbat\looping statements> java nestedloop
*
**
***
****
*****
I=1--------- i<=3---------true
J=1---------1<=3---------true
J=2---------2<=3---------true
J=3---------3<=3---------true
Move to next line
I=2---------2<=3---------true
J=1---------1<=2---------true
J=2---------2<=2---------true
Move to next line
I=3---------3<=3---------true
J=1---------1<=1---------true
Move to next line
I=4----------Flase
ARRAYS
ARRAY IS A GROUP OF SIMILAR DATA VALUES WHICH HAS A FIXED LENGTH &
INDEX TO INDENTIFY EVERY BUCKET UNIQUELY.
PROPERTIES:
1. FIXED IN SIZE
2. INDEX BASED
7 11 6 55 8 45 16 96 46
0 1 2 3 4 5 6 7 8
Lower Bound Upper Bound
Array Length=9
DECLARATION & INTIALIZATION
SYNTAX:
Datatype[] array variable name={v1,v2,v3…….vN};
Or
Datatypearray variable name[] ={v1,v2,v3…….vN};
Ex: int[] a1={10,20,30,40};
DECLARATION & CREATION

SYNTAX:
Datatype[] array variable name=new datatype[size] (“new” is a keyword mandatory to use)
Ex: int[] a2=new int[4];
LOWER BOUND(START INDEX)=0

UPPER BOUND(LAST INDEX)=LENGTH-1
MIDDLE BOUND(LAST INDEX)=(LENGTH-1)/2
ARRAY VARIABLENAME.LENGHT(TO CALCULATE THE LENGTH OF ARRAY)
*.ARRAY DECLERATION AND CREATION:
SYNTAX:
Datatype[] array variable name=new datatype[size] (“new” is a keyword mandatory to use)
Ex: int[] a2=new int[4];
*ARRAY IS A FIXED LENGTH BECAUSE IT ALWAYS RESERVE THE MEMORY 1ST &
THEN IT PERFORMS OPERATION.
*ARRAY IS A FIXED AT RUNTIME.
*INDEX IS USED TO PERFOM ALL BASICS TO ADVANCED OPERATIONS WITHIN AN
ARRAY.
*INDEX ALWAYS STARTS FROM “0” BASED ON ADDRESS OF MEMORY
LOCATION.IF WE START INDEX FROM 1 IT ALWAYS START POINTING TO 2ND
BUCKET INSTEAD OF 1ST. THIS PROBLEM CAUSES
“ARRAYINDEXOUTBOUNDEXCEPTION”
* First index----- > (lower bound)
* Last index----- >arr.length- 1=9-1=8(upper bound)
*Mid index----- >(arr.length-1)/2=(9-1)/2=4(middle bound)
Example:
public class PrintArray {

int[] a1={10,20,30,40};
System.out.println(a1[0]);
System.out.println(a1);
int firstindex=0;
int lastindex=a1.length-1;
System.out.println("lenght of given array is= "+a1.length);
System.out.println("first index of of given array is= " +firstindex);
System.out.println("first index of of given array is= " +lastindex);
System.out.println("first index of of given array is= " +(lastindex)/2);
}
}
Output:
PS F:\Vinay QSpider\JAVA Pgms\codingbat\array> javac PrintArray.java
PS F:\Vinay QSpider\JAVA Pgms\codingbat\array> java PrintArray
10
20
30
40
[I@2f92e0f4
lenght of given array is= 4
first index of of given array is= 0
public class Array1
{
//Declaration & Creation
int[] a1=new int[3];
// assign the values/insert values:arrayname[index]=value;
a1[0]=10;
a1[1]=20;
a1[2]=30;
System.out.println(a1[0]+","+a1[1]+","+a1[2]);
}
}
Output:
PS F:\Vinay QSpider\JAVA Pgms\codingbat\array> javac Array1.java
PS F:\Vinay QSpider\JAVA Pgms\codingbat\array> java Array1
10, 20, 305
Using for loop

public class Array2 {
public static void traverse(int[] a)
{
for(int index=0;index<=a.length-1;index++){
System.out.print(a[index]+",");
}
}
int[] a1={1,2,3,4};
int[] a2={20,50,60,10};
int[] a3={100,01,33,55};
traverse(a1);
traverse(a2);
traverse(a3);
}
}
Output:
1,2,3,4,
20,50,60,10,
100,1,33,55,
Print the given array in reverse order?
Ex: input=1,2,3,4
Output=4,3,2,1

public static void traverse(int[] a)
{
for(int index=a.length-1;index>=0;index--){
System.out.print(a[index]+" ");
}
}
int[] a1={1,2,3,4};
traverse(a1);
}
}

4,3,2,1
copy the given array and print in new array
//copy the given array and print in new array

public class Array4
{
public static void copy(int[] a1)
{
int [] resar=new int[a1.length];
for{int i=0;i<=a1.length;i++}
{
//Copy the elements
resar[i]=a1[i];
System.out.print(resar[i]+" ");
}
}
int[] a1={10,20,30};
int[] a2={2,5,8,9};
copy(a1);
//copy(a2);
}
}
Tracing
Calculate sum of given array
Input:{1,10,20,30}
Input:{5,4,1,7,9,8}

public static void test(int[] a) {
int test = 0;
for (int i = 0; i <= a.length - 1; i++) {
test = test + a[i];
}
System.out.println(test);

int[] a1 = { 10, 20, 30, 1 };
test(a1);
int[] a2 = { 5, 4, 1, 7, 8, 9 };
test(a2);
}
}

61
34
Find the even numbers from Array

Find odd numbers from Array
Note: Print even number or odd number as a output for above pgms
Count how many even numbers are present in given Array
Count how many odd numbers are present in given Array
for each loop
Syntax:
for(tpye variable:variable) ======= for(int e1:a1)
Example:
public static void test(int[] a1){
for(int e1:a1)
{
Statement……
}
}
USING FOR EACH LOOP TO RETRIVE THE ELEMENTS FROM THE

GIVEN ARRAY.
Syntax:
for(tpye variable:variable) ======= for(int e1:a1)
Example:
for(int e1:a1)
{
Statement……
}
}
// for each loop
for(int e1:a1)
{
System.out.print(e1+" ");
}
}
int[] a1={1,5,1,8,6,7};
test(a1);
int[] a2={10,14,74,85,25};
test(a2);
}
}

151867
10 14 74 85 25
FIND THE MAXIMUM ELEMENT FROM THE GIVEN ARRAY?

FIND THE MINIMUM ELEMENT FROM THE GIVEN ARRAY?
RECERCIVE FUNCTION CALL?
OOPS CONCEPTS
SCANNER CLASS IS USED TO TAKE INPUT FROM USER.

STEPS:
1. import java.util.scanner; or import java.util.*;
2. Scanner sc=new Scanner(System.in)
sc.nextInt(); ------ for numbers
sc.next();
sc.nextLine();-------- for String
sc.nextDouble();------- for Decimal numbers
TO TAKE STRING INPUT WE HAVE METHOD CALLED next(); & nextLine();
TO TAKE ALL OTHER TYPE OF INPUT WE HAVE SPECIFIED METHODS FOR
INTEGER INPUPT nextInt();
// Scanner Program
import java.util.*;
public class Employee {
{
Scanner sc=new Scanner(System.in);
System.out.println("Enter Your Name");
String name=sc.nextLine();
System.out.println("Enter Your Id");
int id=sc.nextInt();
System.out.println(" Enter Your Salary");
double sal=sc.nextDouble();
System.out.println("Employee Details("+name +","+id+","+sal+")");
}
}
PS F:\Vinay QSpider\JAVA Pgms\codingbat\array> javac Employee.java

PS F:\Vinay QSpider\JAVA Pgms\codingbat\array> java Employee
Enter Your Name
Vinay
Enter Your Id
101
Enter Your Salary
75000.25
Employee Details (Vinay,101,75000.25)
Methods of Scanner Class: In built pre-defined
Scanner sc=new Scanner(System.in)
Byte sc.nextByte();
Short sc.nextShort();
Int sc.nextInt();
Long sc.nextLong();
Float sc.nextFloat();
Double sc.nextDouble();
Char sc.next().charAt(0);
Boolean sc.nextBoolean();
String sc.next(); or
sc.nextLine();
// Array Using Scanner

import java.util.*;
Scanner s1=new Scanner(System.in);
System.out.println("Enter size of Array");
int size=s1.nextInt();
int[] a1=new int[size];
System.out.println("Enter the values");
for(int i=0;i<=a1.length-1;i++)
{
a1[i]=s1.nextInt();
}
for(int j=0;j<=a1.length-1;j++){
System.out.print(a1[j]+" ");
}
}

Enter size of Array
3
Enter the values
2
4
5
245
SL CALLING CALLED LOCATION HOW TO ACCESS
NO METHOD MEMBER
1 Static Static Same class Membername
2 Static Static Different class Classname.membername
3 Non- Static Static Same class Member name
4 Non-Static Static Diff Class Classname.membername
1 Static Non-Static Same Class Object.membername
2 Static Non-Static Diff class Object.membername
3 Non-Static Non-static Same class Member name
4 Non-Static Non-Static Diff Class Object.membername

public class Account {
long Accnum=12345678;
String Name="Vinay";
String Branch="Bailhongal";
String Ifsc="SBIN0000273";
double Balance=5000.0;
static String BranchName="SBI";
public void displaydetails()

{
System.out.println("Account Number: "+Accnum);
System.out.println("\nBranch Details:\t"+Branch+"\nIFSC
Code\t:"+Ifsc+"");
}
public static void displaybarnch()
{
System.out.println(BranchName);
}
public void deposit(double amount)
{
if(amount>=0)
{
Balance=Balance+amount;
System.out.println("Current Balance: " + Balance);
}
else{
System.out.println("Invalid Amount!");
}
}
public void withdraw(double amount){
if(amount>=0 && Balance>amount)
{
Balance=Balance-amount;
System.out.println("Current Balance"+ Balance);
}
else{
System.out.println("Insufficient Funds!!");
}
}
new Account().displaydetails();
new Account().deposit(20000.0);
new Account().withdraw(15000);
}
}
Output:
PS F:\Vinay QSpider\JAVA Pgms\codingbat\opps> javac Account.java
PS F:\Vinay QSpider\JAVA Pgms\codingbat\opps> java Account
Account Number: 12345678
Name: Vinay
Branch Details: Bailhongal
IFSC Code :SBIN0000273
Current Balance: 25000.0
Insufficient Funds!!
public class Student {

long Phno= 7204469689l;
String Email="vinayparit@gmail.com";
double Marks= 60.48;
String College="K.R.C.E.S";
public void Studentdetails()
{
System.out.println(Name);
System.out.println(Phno);
System.out.println(Email);
System.out.println(Marks);
System.out.println(College);
}
public void UpdateMarks(double NewMarks)
{
Marks=NewMarks;
System.out.println("Updated marks : "+Marks);
}
new Student().Studentdetails();
new Student().UpdateMarks(80.50);
}
}
PS F:\Vinay QSpider\JAVA Pgms\codingbat\opps> javac Student.java
PS F:\Vinay QSpider\JAVA Pgms\codingbat\opps> java Student
Vinay
7204469689
vinayparit@gmail.com
60.48
K.R.C.E.S
Updated marks : 80.5
Static keyword in Java

Static keyword means non constant & one copy.
Final keyword
Final keyword means constant in Java
STATIC MEMBER:
Static members will have only one copy in the memory.
If the value of a data member in a class is not changing from object to other object then those
data members should be declared as Static.
If a function member/method in a class is using only static members of the class then those
function member/method should be declared as Static.
NON-STATIC MEMBER
Non-Static members will have only multiple copy in the memory.
If the value of a data member in a class is changing from object to other object then those data
members should be declared as Non-Static.
If a function member/method in a class is using at least one non static members of the class then
those function member/method should be declared as Non-Static.
WHAT IS CLASS?
WHAT IS OBJECT?
HOW TO CREATE OBJECT IN JAVA?
EXPLAIN MEMBER OF CLASS.?
WHAT IS STATIC & NON STATIC MEMBERS?
DIFFERENCE BETWEEN STATIC, NON-STATIC & FINAL?
HOW TO ACCESS STATIC & NON STATIC PRESENT IN SAME & DIFFERENT CLASS?
WRITE THE PGM TO EXPLAIN STATIC MEMBERS & NON-STATIC MEMBERS?
DIFFERENCE BETWEEN STATIC POOL & HEAP AREA?
Important
REFERENCE VARIABLES
 It is a type of variable which is used to store address of an object.
 Within a reference variables we can’t store primitive values.
 Within a primitive variables we can’t store address of an object.
 Within 1 reference variables we can store ONLY ONE OBJECT ADDRESS.
 Multiple reference variables can point to same object.
 If multiple reference variables points to same object then, changes done on the data of the
object by one reference variable will impact other reference variables.
 If two reference variables points to different objects then, changes done on the data of
one object by one reference variable will NOT impact other reference variables.
Syntax:
Classname reference variable = new classname();
public class Accountref{

long Accnum=12345678;
String Branch="Bailhongal";
String Ifsc="SBIN0000273";
double Balance=5000.0;
static String BranchName="SBI";

{
System.out.println("Account Number: "+Accnum);
System.out.println("Name: "+Name);
System.out.println("Branch Details:\t"+Branch+"\nIFSC Code\t:"+Ifsc+" ");
System.out.println(BranchName);
}
// public static void displaybarnch()
// {
// System.out.println(BranchName);
// }
public void deposit(double amount)
{
if(amount>=0)
{
System.out.println("Current Balance: " + Balance);
}
else{
System.out.println("Invalid Amount!");
}
}
public void withdraw(double amount){
if(amount>=0 && Balance>amount)
{
System.out.println("Current Balance:"+ Balance);
}
else{
System.out.println("Insufficient Funds!!");
}
}
// new Accountref().displaydetails();
// displaybarnch();
// new Accountref().deposit(20000.0);
// new Accountref().withdraw(15000);
Accountref a1= new Accountref();
a1.displaydetails();
a1.deposit(20000.0);
a1.withdraw(5000.0);
// a1.BranchNamedisplaybarnch();
}
}
PS F:\Vinay QSpider\JAVA Pgms\codingbat\opps> javac Accountref.java

PS F:\Vinay QSpider\JAVA Pgms\codingbat\opps> java Accountref
Account Number: 12345678
Name: Vinay
Branch Details: Bailhongal
IFSC Code :SBIN0000273
SBI
Current Balance: 25000.0
Current Balance:20000.0
VARIABLES
MEMBER VARIABLES LOCAL VARIABLES
PRIMITIVE REFERENCE PRIMITIVE REFERENCE

VARIABLES VARIABLES VARIABLES VARIABLES
STATIC NON- STATIC NON-

STATIC STATIC
MEMBER VARIABLES:
 ANY VARIABLE WHICH IS DECLARED WITHIN THE BODY OF THE CLASS IS
CALLED MEMBER VARIABLE.
 MEMBER VARIABLES CAN BE ACCESSED BY ANY METHOD PRESENT IN
SAME CLASS.
 MEMBER VARIABLES WILL BE INITIALIZED BY THE COMPLIER WITH THE
DEFAULT VALUE IF PROGRAMMER DON NOT INITIALIZE THEM.
 MEMBER VARIABLES ARE NOTHING BUT DATA MEMBERS OF THE CLASS.
LOCAL VARIABLES:
 ANY VARIABLES WHICH IS DECLARED WITH THE METHOD DECLARATION
AND WITHIN THE METHOD DEFINITION IS CALLED AS LOCAL VARIABL.
 LOCAL VARIABLES CAN BE ACCESSED ONLY BY THE METHOD IN WHIHCH
IT IS DECLARED.
 LOCAL VARIABLS SHOULD BE INITIALIZED BY THE PROGRAMMER WITH
THE VALUES EXPLICITLY.
NOTE: LOCAL VARIABLES CANNOT BE DECLARED AS STATIC
BECAUSE OF MEMORY LOCATION WE CANNOT DECLARE LOCAL VARIABLES AS
STATIC
class Sample
{
static int v1=100; //static primitive member variable
String str1=”Java”; // Non Static reference member variable
{
int a1=500; // primitive local variable
String s1=”SQL” // reference local variable
System.out.println(v1);
System.out.println(new Sample().str1);
System.out.println(s1);
}
publilc static void main(String [] args)
{
Sample a1=new Sample();
System.out.println(a1.str1);
test();
}
}
 IF BOTH MEMBER & LOCAL VARIABLES HAVE SAME NAME THEN IF YOU
CALL A VARIABLE FROM THE SAME METHOD THEN PRIORITY ALWAYS
GIVEN FOR LOCAL VARIABLES.
 STATIC MEMBER VARIABLE & LOCAL VARIABLE HAVE SAME NAME

THEN IT CAN BE DIFFERENTIATED FROM STATIC METHOD BY
classname.membername(classname.membername IS POINTING TH MEMBER
VARIABLE)
=== WE CAN USE ANY METHOD FOR CALLING& CALLED FUNCTION BUT IN
MAIN METHOD WE NEED TO DEFINE THE EXECUTION PART.
class Sample
{
static int v1=100; //static primitive member variable
static String str1=”Java”; // Static reference member variable
{
int v1=500; // primitive local variable
String str1=”SQL”; // reference local variable
System.out.println(str1);
System.out.println(Sample.v1);
System.out.println(Sample.str1);
}
publilc static void main(String [] args)
{
test();
}
}
Class Sample{
Int v1=100;
String str1;
Public static void test()
{
Int v1=100;
String str1=”sql”;
System.out.println(new Sample().v1);
System.out.println(new Sample.str1);
}
Public static void 0main(String[] args )
{
test();
}
}
 NON STATIC MEMBER VARIABLES & LOCAL VARIABLES HAVE SAME
NAME THEN IT CAN BE DIFFERENTIATED FROM STATIC METHOD BY
CREATING OBJECT.( object creation. member name is pointing to member variable)
class Sample
{
int v1=100;
String str1;
{
int v1=500;
String str1-“SQL”;
System.out.println(new Sample().v1);
System.out.println(new Sample().str1); Calling Method
}
Main()
{
test();
}}
 STATIC MEMBER VARIABLE & LOCAL VARAIBLE CAN BE

DIFFERENTIATED FROM NON STATIC METHOD BY USING
classname. membername
 NON-STATIC MEMBER & LOCAL VARIABLE HAVE SAME NAME THEN IT

CAN BE DIFFERENTIATED FROM NON-STATIC METHOD BY USING OBJECT
CREATION (or) WE CAN USE “this” KEYWORD.
“this” KEYWORD USED TO POINT SAME CLASS OBJECT OR CURRENT OBJECT OR

CURRENT INSTANCE.
“this” KEYWORD CANNOT BE USED WITHIN STATIC METHOD BODY.
NOTE: a1 IS MEMBER NAME & LOCAL VARIABLE NAME
IF BOTH MEMBER & LOCAL VARIABLE HAVE SAME NAME THEN FROM SAME
METHOD HOW TO DIFFERENTIATE
CALLING CALLED LOCAL HOW TO CALL
METHOD MEMBER VARIABLE MEMBER VARIABLE
VARIABLE
Static Static (a1) Default (a1) classname . membername
non-static static(a1) Default (a1) classname . membername
static non-static (a1) Default (a1) new

classname().membername;
non-static non-static (a1) Default (a1) this.membername / new
classname().membername;
PASS BY VALUE:
 IF A METHOD IS RETURNING ANY PREMITIVE VALUES THEN I IS CALLED
AS PASS BY VALUE
public class passbyvalue

{
public static int test(int a)
{
return a;
}
{
int a1=1;
System.out.println(test(a1));
}
}
IN ABOVE EXAMPLE A METHOD IS PASS THE VALUETO ANOTHER METHOD.
PASS BY REFERENCE:
 IF A METHOD IS RETURNING OBJECT FROM 1 METHOD TO ANOTHER
METHOD THEN IT IS NOWN AS PASS BY REFERENCE
public class PassByref
{
public static PassByref test(PassByref pr1)
{
return pr1;
}
{
PassByref pr=new PassByref();
System.out.println(test(pr));
}
}
JAVA PACKAGES
WITHOUT USING JAVA PACKAGES
 MANAGING SOURCE CODE IS DIFFICULT

 CREATING NAMING COLLISIONS
 SECURITY FOR CLASSES & ITS MEMBERRS IS NOT GUARANTEED
GMAIL
INBOX.JAVA INBOX.CLASS DELETE.JAVA DELETE.JAVA JAVA .CLASS

WITH JAVA PACKAGES
 MANAGING SOURCE CODE IS EASY

 NO NAMING COLLISIONS
 SECURITY FOR CLASSES & ITS MEMBERRS IS GUARANTEED
PACKAGES:
 AJAVA PACKAGE IS GROUP OF CLASSES AND INTERFACES WHICH ARE
RELATED TO ONE SINGLE MODULE IN THE GIVEN PROJECT.
PACKAGE NAMING CONVENTION :
 PACKAGE NAME IS ALWAYS WRITTEN IN ALL LOWERCASES.
 PACKAGAE NAMES ARE ALWAYS WRITTEN IN REVERSE ORDER OF
DOMAIN
CONVENTION 1
domain.appname.modulename
com.instagram.signup
CONVENTION 2
omain..companyname.appname.modulename
com.meta.instagram.signup
INSTAGRAM(PROJECT)(APPNAME)
SRC ===== com.instagram.registration (Registration) (Packages)
(Class Name) Singup  Create object (methods)
(Class Name) Login  Access object (methods)
com.instagram.home (Home) (Packages)
(Class Name) msg send, delete, edit (methods)
(Class Name) callsaudiocalls, videocalls (methods)
(Class Name) storyvideo, photo (methods)
(Class Name) postaddvideo, addphoto, deletephoto (methods)
ACCESS SPECIFIER
ACCESS SPECIFIERS ARE USED TO PROVIDE SECURITY FOR THE CLASSES AND ITS
MEMBERS BY CONTROLLING THE VISIBILITY.
PUBLIC HIGH
VISIBLITY
LESS PROTECTED & LESS
VISIBLITY
& HIGH
PACKAGE SECURITY
SECURITY LEVEL
PRIVATE
 PUBLIC
 PROTECTED
 PACKAGE LEVEL
 PRIVATE
ENTITY:
 CLASS
 METHODS
 DATA MEMBERS (VARIABLES)
HOW TO ACCESS AN ENTITIES WHICH ARE DECLARED AS PUBLIC OR
PROTECTED OR PACKAGED OR PRIVATE FROM DIFFERENT PLACES
SAME CLASS- DIFFERENT DIFFERENT
SAME PACKAGE CLASS- SAME CLASS-
PACKAGE DIFFERENT
PACKAGE
PUBLIC CAN BE CAN BE CAN BE
ACCESSED ACCESSED ACCESSED
PROTECTED CAN BE CAN BE CAN BE
ACCESSED ACCESSED ACCESSED USING
INHERITANCE
PACKAGED CAN BE CAN BE CANNOT BE
PRIVATE CAN BE CANNOT BE CANNOT BE
PUBLIC:
 IF YOU DECLARE ANY ENTITY AS PUBLIC, THEN IT CAN BE ACCESSED BY
THE CLASSES PRESENT IN SAME OR DIFFERENT PACKAGES.
 PUBLIC ENTITIES WILL HAVE HIGHEST VISIBILITY AND LOWEST SECURITY
PROTECTED:
 IF YOU DECLARE ANY ENTITY AS PROTECTED,THEN IT CAN BE ACCESSED
BY THE CLASSES PRESENT IN SAME PACKAGES
 PROTECTED ENTITY CAN BE ACCESSED BY OTHER CLASS PRESENT IN
DIFFERENT PACKAGE THROUGH INHERITANCE AND CREATING THE
OBJECT OF SUBCLASS ONLY.
PACAKAGE LEVEL (DEFAULT):
 IF YOU DECLARE ANY ENTITY WITHOUT USING ANY ACCESS SPECIFIER
KEYWORD THEN IT IS CONSIDERED AS PACKAGE-LEVEL MEMBER
(DEFAULT MEMBER)
 IF YOU DELARE ANY ENTITY AS PACKAGE-LEVEL (DEFAULT), THEN IT CAN
BE STRCITLY ACCESSED ONLY BY THE CLASSES PRESENT IN SAME
PACKAGE.
PRIVATE:
 IF YOU DECLARE ANY ENTITY AS PRIVATE, THEN IT CAN BE ACCESSES
ONLY BY THE CLASS WITHIN WHICH THEY ARE DECLARED.
 PRIVATE ENTITIES WILL HAVE HIGHEST SECURITY AND LOWEST
VISIBILITY
TABLE FOR WHICH ENTITY CAN BE DECLARED AS PUBLIC, PROTECTED,

PACKAGE-LEVEL & PRIVATE
SPECIFIER PUBLIC PROTECTED PACKAGE PRIVATE
LEVEL
ENTITY
CLASS CAN BE CANNOT BE CAN BE CANNOT BE

DECLARED DECLARED DECLARED DECLARED
METHODS CAN BE CAN BE CAN BE CAN BE
DECLARED DECLARED DECLARED DECLARED
DATA CAN BE CAN BE CAN BE CAN BE
MEMBERS DECLARED DECLARED DECLARED DECLARED
package com.OopsProgram.package1;
public class firstpgm

{
public int a1=1;
protected int a2=2;
int a3=3;
private int a4=4;
public void test() {
System.out.println("public");
}
protected void test1() {
System.out.println("protected");
}
void test2() {
System.out.println("package-level");
}
private void test3()
{
System.out.println("private");
}
// same class same package
{
firstpgm p1= new firstpgm();
System.out.println(p1.a1);
p1.test();
p1.test1();
p1.test2();
p1.test3();
}
}
OR
public class secondpgm

// different class and same package
{
{
// System.out.println(p1.a4); // private of different class
p1.test();
p1.test1();
p1.test2();
// p1.test3(); // private of different class
}
}
OR
import com.OopsProgram.package1.*;
public class thirdpgm
{
//different class different package
// System.out.println(p1.a2); protected of different class
// System.out.println(p1.a3); package level of different class
// System.out.println(p1.a4); // private of different class
p1.test();
// p1.test1(); protected of different class
// p1.test2();package level of different class
// p1.test3(); // private of different class
CONSTRUCTORS:
 CONSTRUCTORS ARE SPECIAL TYPE OF METHODS WHICH HAVE SAME
NAME AS THE CLASS NAME.
 CONSTRUCTORS ARE EXECUTEED WHENEVER THE OBJECT OF THAT
CORRESPONDING CLASS IS CREATED.
 EVERY CLASS MUST & SHOULD HAVE CONSTRUCTOR
 IF PROGRAMMER DO NOT WRITE ANY CONSTRUCTOR, THE COMPLIER
WILL WRITE DEFAULT CONSTRUCTOR IMPLICITLY.
 IF THE PROGRAMMERE WRITES CONSTRUCTOR IT CAN BE OF TWO TYPES.
1. ZERO ARGUMENT CONSTRUCTOR.
2. PARAMETERZIED CONSTRUCTOR.
 CONSTRUCTORS CANNOT BE DECLARED AS STATIC OR FINAL.
 IF YOU SPECIFY RETURN TYPE FOR THE CONSTRUCTOR, THEN IT WILL BE
CONSIDERED AS A NORMAL METHOD.
 IF THE PROGRAMMER WRITES ANY CONSTRUCTOR EXPLICITLY, THEN
COMPLIER WILL NOT WRITE ANY CONSTRUCTOR IMPLICITLY.
CONSTRUCT PUBLIC PROTECT PACKAG PRIVATE
ORS
ED E LEVEL
BY ZERO CAN BE CAN BE CAN BE CAN BE

ARGUMENTS
PROGRAMM DECLARED DECLARED DECLARE DECLARE
ER D D
PARAMETER CAN BE CAN BE CAN BE CAN BE
IZED
DECLARED DECLARED DECLARE DECLARE
D D
BY DEFAULT CAN BE CANNOT CAN BE CANNOT
COMPLIER DECLARED BE DECLARE BE
(DEFAULT DECLARED D DECLARE
CONSTRUCT D
OR)
Default constructor
package com.OopsPrograms.constructor;
public class Default {

//default constructor by compiler
new Default();
// Default(); ----> Default constructorcall
// if the programmer do not write any constructor,
// then complier will write default constructor
implicitly
}
}
Zero argument constructor

public class Zeroargs {

// Zero arg constructor
public Zeroagrs()
{
System.out.println(" Zero arg constructor of Zeroargs
class");
}
new Zeroargs();
// Zeroargs(); in the class programmer is writing
// zero arguments constructor
// Zeroargs(); zero argument constructor
}
}
Parameterized constructor
public class Parameterized {

public Parameterized(int a) {
System.out.println("Parameterized constructor ");
}
new Parameterized(10);
// Parameterized(10); Parameterized(int)
//---- Parameterized constructor call
}
}
APPLICATION OF CONSTRUCTOR:
 CONSTRUCTOR ARE USED TO INTIALIZE THE DATA MEMBERR OF THE
CLASS.
WE CAN INTIALIZE THE DATA MEMBERS OF THE CLASS BY FOLLOWING

TYPES.
1. NORAML INTIALIZATION
2. REFERENCE VARIABLE INTIALIZATION
3. METHOD INTIALIZATION
4. CONSTRUCTOR INTIALIZATION
 NOTE: IN APPLICATIONS WE ARE USING CONSTRUCTOR INTIALIZATION
BECAUSE IT INTIALIZE THE VALUES DURING OBJECT CREATION, AND ALL
OTHER TYPES OF INTIALIZATION WILL WORK AFTER OBJECT CREATION
HENCE CONSTRUTOR INTIALIZATION IS BEST
Public class Car
{
String Carname;
String Carmodel;
double Price;

{
System.out.println(Carname);
System.out.println(Carmodel);
System.out.println(Price);
}
//public void discount(double disprice)
{
If(disprice>1500000)
{
Price=disprice-Price/Price*100
}
}
// Reference Variable Initialization
{
Car C1= new Car();
C1.Carname=”Skoda”;
C1.Carmodel=”Rapid”;
C1.Price=1650000.0;
C1.displaydetails();
Car C2=new Car();
C2.Carname=”BMW”;
C2.Carmodel=”A4” ;
C2.Price=7500000.0;
}
}
Heap Area
C1 C2
Car@1 Car@2
Carname Skoda Carname BMW
Carmodel Rapid Carmodel A4
Price 1650000.0 Price 7500000.0
displaydetails(); displaydetails();
Public class Car
{
String Carname;
String Carmodel;
double Price;

{
}
// Method Initialization
public void updatedetails(String Carname, String Carmomdel, Double Price)
{
this.Carname=Carname;
this.Carmodel=Carmodel;
this.Price=Price;
}
}
public static void main()

{
Car C1= new Car();
C1.updatedetails(”Skoda”; ”Rapid”; 1650000.0);
Car.C2= new Car();
C2.updatedetails(”BMW”; ”A4”; 7500000.0);
}
}
Method Initialization (updatedetails)
C1 C2
Car@1 Car@2
Carname Skoda Carname BMW
Carmodel Rapid Carmodel A4
Price 1650000.0 Price 7500000.0
displaydetails(); displaydetails();
Updatedetails(); Updatedetails();
// Initialization Using Constructor
package com.OopsProgram.Car;
public class Car {

public String Carname;
public String Carmodel;
public double Price;
public Car(String Carname, String Carmodel, double Price)
{
this.Carname=Carname;
this.Carmodel=Carmodel;
this.Price=Price;
}
{
}
Car C1= new Car("Skoda","Rapid",1650000.0);
Car C2=new Car("BMW","A4",7500000.0);
}
}
CONSTRUCTOR OVERLOADING
 “THIS” KEYWORD
 “THIS” KEYWORD IS USED TO DIFFERENTIATE BETWEEN LOCAL
VARIABLES AND MEMBER VARIABLES WITHIN A METHOD/CONSTRUCTOR
WHENEVER THEY HAVE SAME NAMES.
 DEVELOPING MULTIPLE CONSTRUCTORS WITHIN THE SAME CLASS WITH
THE SAME NAME WHICH DIFFER IN
1. NUMBER OF ARGUMENTS
2. DATATYPES OF ARGUMENTS
3. ORDER OF DATATYPE ARGUMENTS
IS CONSTRUCTOR OVERLOADING
public class Overloading {

public Overloading() {
System.out.println("Zero arg constructor");
}
public Overloading(int a) {
System.out.println("one arg constructor with int");
}
public Overloading(String a) {
System.out.println("One arguments with string datatype");
}
public Overloading(int a, double b) {
System.out.println("With multiple datatypes of arguments");
}
public Overloading(double a, int b) {
System.out.println("With multiple datatypes of arguments with
different order");
}
new Overloading();
new Overloading(10);
new Overloading("Hello");
new Overloading(10,10.10);
new Overloading(10.10,10);
}
}
Output:
Zero arg constructor

one arg constructor with int
One arguments with string datatype
With multiple datatypes of arguments
With multiple datatypes of arguments with different order
this();
this calling statement
 USED TO CALL SAME CLASS CONSTRUCTOR

 this(); ALWAYS WRITTEN WITHIN FIRST LINE OF CONSTRUCTOR BODY
 this(); CANNOT BE DECLARED WITHIN THE METHOD BODY.
 WITH THE HELP OF this(); WE CAN ACHIVE LOCAL CONSTRUCTOR
CHAINING
LOCAL CONSTRUCTOR CHAINING:
IT’S A PROCESS OF CALLING ONE CONSTRUCTOR TO ANOTHER CONSTRUCTOR

WITHIN THE SAME CLASS.
DIFFERENECE BETWEEN this KEYWORD & this();
this KEYWORD this();

USED TO POINT CURRENT OBJECT USED TO CALL THE SAME CLASS
CONSTRUCTOR
WE CAN WRITE this KEYWORD WE CAN WRITE ONLY WITHIN FIRST
WITHIN NON-STATIC METHOD BODY & LINE OF CONSTRUCTOR BODY
WITHIN CONSTRUCTOR BODY
this KEYWORD USED TO ACCESS WE CAN ACHIVE LOCAL
MEMBER VARIABLES & FUNCTION CONSTRUCTOR CHAINING
MEMBER
USED TO DIFFERENTIATE MEMEBR
VARIABLE & LOCAL VARIABLE WHEN
THEY HAVE SAME NAME
APPLICATION CONSTRUCTOR OVERLOADING
USED TO INITALIZE 2 OR MORE TYPE OF USER DATA TO THE OBJECTSpackage

package com.Oopspragram.Assignment;

String Name;
String Eid;
double Salary;
int Exp;
//Employee with 4 number of arg constructor for 1st type of user those who
have exp
public Employee(String Name,String Eid, double Salary, int Exp) {
// Update the local variables value to member variable
this.Name=Name;
this.Eid=Eid;
this.Salary=Salary;
this.Exp=Exp;
}
//Employee with 3 number of arg constructor for 2nd type of user those who
don't have exp
public Employee(String Name,String Eid, double Salary) {
// Update the local variables value to member variable
this.Name=Name;
this.Eid=Eid;
this.Salary=Salary;
}
{
System.out.println(Eid);
System.out.println(Salary);
System.out.println(Exp);
}
Employee E1=new Employee("Vinay","E123",50000.0,2);
E1.displaydetails();
Employee E2=new Employee("Sumeet","E852",25000.0);
E2.displaydetails();
}
}
Output:
Vinay
E123
50000.0
2
---------------
Sumeet
E852
25000.0
0
NOTE:
 2 OVERLOADED CONSTRUCTOR CAN HAVE DIFFERENT ACCESS

SPECIFIERS.
 CONSTRUCTORS ACCESS SPECIFIERS IS ALWAYS NON-STATIC.
 THERE IS NO RETURN TYPE FOR CONSTRUCTOR.
 CONSTRUCTOR WILL RETURN CLASS OBJECT IN WHICH IT IS DEFINED
IMPLICITLY.
METHOD OVERLOADING:
 DEVELOPING MULTIPLE METHODS WITHIN THE SAME CLASS WITH THE
SAME NAME WHICH MAY DIFFER IN
1. NUMBERR OF ARGUMENTS
2. DATA TYPE OF ARGUMENTS
3. ORDER OF ARGUMENTS
IS CALLED AS METHOD OVERLOADING
 EX: println() IS THE BEST EXAMPLE FOR METHOD OVERLOADING.
ADVANTAGES:
 EASY TO BIND DEFINITION WITH DECLARATION BASED ON
PARAMETERS(ARGUMENTS)
 USED TO PERFORM SAME OPERATION WITH DIFFERENT TYPE OF INPUTS
WHEN TO USE OVERLOADING:

 FOR THE SAME FUNCTIONALITY WHEN WE WANT TO PROVIDE MULTIPLE
OPTIONS.
NOTE:
OVERLOADED METHODS CAN HAVE DIFFERENT ACCESS SPECIFIER, ACCESS
MODIFIER & RETURN TYPE
//METHOD OVERLOADING EXAMPLE

public class Methodoverloading {
public static int add(int a,int b)
{
int res=a+b;
return res;
}
protected void add(int a, int b, int c)
{
int res=a+b+c;
}
void add(int a, int b, int c, int d) {
int res=a+b+c+d;
}
Methodoverloading m1=new Methodoverloading();
add(1,2);
m1.add(1, 2, 3);
m1.add(1, 2, 3, 4);
}
}
OUTPUT:
3
6
10
STATIC BLOCK or STATIC INITIALIZER BLOCK
Syntax:
Static
{
Statements……..
Statements……..
Statements……..
}
 STATIC BLOCKS USED TO INITIAALIZE THE STATIC MEMBERS OF THE

CLASS.
 STATIC BLOCK WILL EXECUTE BEFORE THE EXECUTION OF MAIN METHOD
& DURING CLASS LOADING.
 IF WE WANT TO EXECUTE SOME SET OF CODE BEFORE THE EXECUTION OF
MAIN THOSE CODES MUST BE WRITTEN IN STATIC BLOCK.
 TO EXECUTE STATIC BLOCKS MAIN METHOD IS MANDATORY.
 WE CAN WRITE MULTIPLE STATIC BLOCKS WITHIN THE SAME CLASS.
Example:
package com.OopsPrograms.Blocks;
public class Sample {

static int x;
// static block
static {
System.out.println("static block 1 of sample class");
x=10;
}
System.out.println("main starts");
System.out.println(x);
System.out.println("main ends");
}
}
Output:
static block 1 of sample class
main starts
10
main ends
NON STATIC BLOCK or INSTANCE INITIALIZER BLOCK
 IT IS USED TO INITIALIZE NON STATIC MEMBERS OF THE CLASS
 IT EXECUTES BEFORE THE EXECUTION OF CONSTRUCTOR & DURING
OBJECT CREATION.
 OBJECT CREATION IS MANDATORY TO EXECUTE INSTANCE BLOCK.
 WE CAN WRITE MULTIPLE INSTANCE BLOCK WITHIN THE SAME CLASS.
Syntax:
{
Statements……….
}
Example:
package com.OopsPrograms.Blocks;
public class Demo {

int x;{
x=10;
System.out.println("Non Static block 1 of Demo");
}
public Demo()
{
System.out.println("Zero arg constructor");
}
System.out.println("main starts");
Demo d1=new Demo();
System.out.println(d1.x);
System.out.println("main ends");
}
}
Output:
main starts
Non Static block 1 of Demo
Zero arg constructor
10
main ends
MAIN METHOD:
 IT’S AN ENTERY POINT OF JAVA WHERE ALL THE PROGRAMS STARTS THE
EXECUTION ALWAYS FROM MAIN METHOD.
 WE CAN DEVELOP A CLASS WITHOUT A MAIN METHOD ALSO.
 BUT WE CAN’T EXECUTE THE CODE WITHOUT MAIN METHOD
 IF A CLASS CONSISTS OF MAIN METHOD THEN THAT CLASS IS KNOWN AS
MAIN CLASS
public static void main(String args[])

public static void main(String. . . args)
Args :- it’s a variable name we can change
[] :- Array
. . . :- varargs
NOTE:
WE CAN OVERLOAD THE MAIN METHOD.
JAVA BEAN CLASS
 DECLARING DATA MEMBERS AS PRIVATE AND GRANT THE ACCESS
THROUGH GETTER AND SETTER METHODS IS CALLED BEAN CLASS
 JAVABEANS ARE CLASSES THAT ENCAPSULATE MANY OBJECTS INTO A
SINGLE OBJECT (THE BEAN).
IT IS A JAVA CLASS THAT SHOULD FOLLOW FOLLOWING CONVENTIONS:

 MUST IMPLEMENT SERIALIZABLE
 IT PROVIDE DEFAULT CONSTRUCTOR OR ZERO ARGUMENTS
CONSTRUCTOR.
 ALL DATA MEMEBERS IN JAVA BEAN MUST BE PRIVATE.
 PUBLIC GETTER AND SETTER METHODS.
NOTE: CLASS SHOULD BE DECLARED AS PUBLIC.
GETTER AND SETTER METHODS:
 GETTER METHOD RETURNS THE CURRENT VALUE OF THE DATA MEMBER.

 RETURN TYPE OF GETTER METHOD DEPENDS ON THE DATA TYPE OF THE
DATA MEMBER WHO’S VALUE WILL BE RETURNED.
 SETTER METHOD UPDATES THE VALUE OF THE DATA MEMBER.
 RETURN TYPE OF SETTER METHOD WILL BE USUALLY VOID BECAUSE IT

DOESN”T RETURN ANY VALUE.
SERIALIZATION:
 SERIALIZATION IS A MECHANISM OF CONVERTING THE STATE OF AN

OBJECT INTO A BYTE STREAM.
public class Student implement Serializable
private String Name;

private String Email;
private long Phone;
public String getName(){

return Name;
}
public String getEmail(){
return Email;
}
public long getPhone(){
return Phone;
}
public void setName(String Name){
this. Name=Name;
}
public void setEmail(String Email){
this. Email = Email;
}
public void setPhone(String Phone){
this. Phone = Phone;
}
}
package com.OopsPrograms.JavaBeans;
import java.io.Serializable;
public class Student implements Serializable {

private String Name;
private String Email;
private long Phone;
//Getters
public String getName() {
return Name;
}
public String getEmail() {
return Email;
}
public long getPhone() {
return Phone;
}
//Setters
public void setName(String Name) {
this.Name=Name;
}
public void setEmail(String Email) {
this.Email=Email;
}
public void setPhone(long Phone) {
this.Phone=Phone;
}
public void displaydetials() {
System.out.println(Email);
System.out.println(Phone);
}
}
package com.OopsPrograms.JavaBeans;
public class MainStudent {

{
Student S1=new Student();
S1.setName("Vinay");
S1.setEmail("vinayp@gmail.com");
S1.setPhone(7204469689L);
S1.displaydetials();
}
}
}
DESERIALIZATAION:
IT IS A MECHANISM OF CONVERTING THE BYTE STREAM INTO OBJECT STREAM.

ENCAPSULATION:
 DECLARING DATA MEMBERS AND FUNCTION MEMBERS WHERE FUNCTION
MEMBERS ARE CHANGING THE VALUES OF DATA MEMBER IS KNOW AS
ENCAPSULATION.
 WRAPPING UP THE DATA IS KNOWN AS ENCAPSULATION
 FINDING THE DATA MEMBERS WITH FUNCTION MEMBERS WITHIN A
CLASS IS ALSO CALLED AS ENCAPSULATION
 IN JAVA ENCAPSULATION IS ACHIEVED BY USING BEAN CLASS.
 ENCAPSULATION IS USED TO PROVIDE SECURITY FOR DATA MEMBERS
AGAINST THE INVALID VALUES
CLASS DIAGRAMS
 A CLASS DIAGRAM IS PICTORIAL REPRESENTATION OF CLASS.
 CLASS DIAGRAMS HELPS UNDERSTANDING THE RELATIONS BETWEEN
CLASSES IN MUCH BETTER WAY.
Class name Employee
Name:String
Datamember:datatype Empid: int
Sal: double
+ Displaydetails(): void
Functionmember:returntype + Updatedetails(newsal): void
RELATIONS BETWEEN CLASSES OR OBJECTS

 2 CLASS ARE RELATED BASED ON THE DEPENDENCY OF CLASS OBJECT
OVER THE ANOTHER CLASS OBJECT.
 2 CLASSES ARE RELATED BASED BY TWO TYPES RELATIONS
1. Has-A relation
2. Is-A relation(INHERITANCE)
 Has-A RELATION
 Has-A RELATION IS A TYPE OF RELATION WHERE 2 CLASSES ARE RELATED
BASED ON THE DEPENDENCY OF EXISTENCE OF ONE OBJECT OVER THE
ANOTHER CLASS OBJECT.
 Has-A RELATION IS IMPLEMENTED BY CREATING MEMBER REFERENCE
CRIABLE POINTING TO THE OBJECT OF ANOTHER CLASS.
INHERITANCE
 ONE CLASS ACQUIRING THE PROPERTIES OF ANOTHER CLASS IS CALLED
AS INHERITANCE.
 THE CLASS FROM WHERE PROPERTIES ARE INHERITED IS CALLED AS
SUPERCLASS or BASECLASS or PARENTCLASS.
 THE CLASS WHICH IS INHERITING PROPERTIES IS CALLED AS SUB CLASS or
DERIVED CLASS or CHILD CLASS.
 IN JAVA INHERITANCE IS ACHIVED BY USING EXTENDS KEYWORD.
 USING SUPER CLASS OBJECT WE CAN ACCESS ONLY PROPERTIES OF
SUPERCLASS.
 USING SUBCLASS OBJECT WE CAN ACCESS PROPERTIES OF BOTH
SUBCLASS & SUPERCLASS.
 FINAL CLASSES CANNOT BE INHERITED.
 FINAL DATA MEMBERS & FUNCTION MEMBERS OF THE CLASS CAN BE
INHERITED.
 CONSTRUCTORS OF THE CLASSES CANNOT BE INHERITED.
 PRIVATE DATA MEMBERS & FUCTION MEMBERS OF THE CLASSES CANNOT
BE INHERITED.
package com.OopsPrograms.Inheritance;
class Father
{
public void Bike()
{
System.out.println("Bike");
}
}
class Son extends Father
{
public void Cycle()
{
System.out.println("Cycle");
}
}
public class Main1 {
Father F1=new Father();
F1.Bike();
Son S1=new Son();
S1.Bike();
}
}
OUTPUT:
Bike
Bike
Cycle
DIFFERENT TYPES OF INHERITANCE

1. SINGLE INHERITANCE
2. MULTILEVEL INHERITANCE
3. MULTIPLE INHERITANCE
4. HIERARCHICAL INHERITANCE
5. HYBRID INHERITANCE
NOTE: INHERITANCE IS USED FOR CODE REUSABLITY

SINGLE INHERITANCE:
ONE SUBCLASS INHERITINIG FROM ONE SINGLE SUPERCLASS IS CALLED AS

SINGLE INHERITANCE
Sample
Final v1:int
Str:String
+ test(): void
+count() : void
EXTENDS
Demo
Z1: double
+displaydetails()
:void
class Sample
{
final int V1 = 10;
String Name;
public void test()
{
System.out.println(V1);
}
public void count()
{
}
}
class Demo extends Sample
{
double Z1=10.0;
public void display()
{
System.out.println("Sub Class");
}
}
public class Maindemo
{
{
Demo d1=new Demo();
d1.test();
d1.count();
d1.display();
System.out.println(d1.V1);
System.out.println(d1.Name);
System.out.println(d1.Z1);
}
}
OUTPUT:
10
null
Sub Class
10
null
10.0
MUTLILEVEL INHERITANCE:
 SUBCLASS INHERITING THE PROPERTIES OF SUPERCLCASS AND THAT
SUPERCLASS INHERITING THE PROPERTIES FROM ANOTHER SUPERCLASS
IS CALLED AS MULTILEVEL INHERITANCE.
WhatsAppV1
+Sendmessages() :void
EXTENDS
WhatsAppV2
+SendVoicemessages()
:void
EXTENDS
WhatsAppV1
+Videocall() :void
package com.OopsPrograms.Inheritance; (MUTLILEVEL INHERITANCE:
class WhatsAppV1{
public void sendmsg() {
System.out.println("Messages");
}
}
class WhatsAppV2 extends WhatsAppV1{
public void voicemsg() {
System.out.println("Voice Msg");
}
}
class WhatsAppV3 extends WhatsAppV2{
public void videocall() {
System.out.println("Video Call");
}
}
public class WhatsAppMain {
WhatsAppV1 w1=new WhatsAppV1();
w1.sendmsg();
w2.sendmsg();
w2.voicemsg();
w3.sendmsg();
w3.voicemsg();
w3.videocall();
}
}
OUTPUT:
Messages
Messages
Voice Msg
Messages
Voice Msg
Video Call
MULTIPLE INHERITANCE:
 SUBCLASS INHERITING THE PROPERTIES FROM 2 OR MORE SUPERCLASS IS
AS CALLED AS MULTIPLE INHERITANCE.
 JAVA DON’T SUPPORT MULTIPLE INHERITANCE.
HIERARCHICAL INHERITANCE:
 ONE SUPERCLASS INHERITED/EXTENDED BY TWO OR MORE SUBCLASSES

IS called as HIERARCHICAL INHERITANCE.
 2 OR MORE SUB CLASSES AQUIRING THE PROPERTIES OF 1 SINIGLE SUPER
CLASS IS CALLED AS HIERARCHICAL INHERITANCE
Account
+AccNo:long
+Bal: double
+Owner : String
+deposit(amount) :void
+withdraw(amount) : void
Saving Account
+ +AccNo:long
+Bal: double
+Owner : String
class Account{
long Accno;
double Balance;
String Owner;
public void deposit(double amount) {
System.out.println("Amount deposited in :" +amount+"/n Current
Balance is:Rs"+Balance);
}
public void withdraw(double amount) {
System.out.println("Amount withdrawn is :" +amount + "/n"
+"Current Balance is :" +Balance);
}
}
class Saving extends Account{
double roi=0.05;
public void calculateroi() {
Balance=Balance+Balance*roi;
System.out.println("ROI is Rs:" +Balance);
}
}
class Current extends Account{
static double MinBal=5000.0;
public void ShowBal() {
System.out.println("Minimum Balance of Current Account is: "
+MinBal);
}
}
public class MainAccount {

Saving S1=new Saving();
S1.deposit(10000.0);
S1.withdraw(1000.0);
S1.calculateroi();
Current C1=new Current();

C1.deposit(50000.0);
C1.withdraw(10000.0);
C1.ShowBal();
}
OUTPUT:
Amount deposited in :10000.0/n Current Balance is:Rs10000.0

Amount withdrawn is :1000.0/nCurrent Balance is :9000.0
ROI is Rs:9450.0
Amount deposited in :50000.0/n Current Balance is:Rs50000.0
Amount withdrawn is :10000.0/nCurrent Balance is :40000.0
Minimum Balance of Current Account is: 5000.0
GENERALIZATION:
 DECLARING COMMON METHODS AND VARIABLES OF ALL SUBCLASSES IN

ONE COMMON SUPERCLASS.
SUPER (); (SUPER STATEMENT)
 super(); (super statement)
 super(); CREATES THE OBJECT OF SUPERCLASS WHENEVER OBJECT OF
SUBCLASS IS CREATED TO INHERIT THE PROPERTIES .
 super(); CAN BE WRITTEN EXPLICITLY BY THE PROGRAMMER OR
IMPLICILTY BY THE COMPLIER AT THE COMPLIE TIME.
 IF THE SUPERCLASS CONTAINS ONLY PARAETERIZED CONSTRUCTORS
THEN THE PROGRAMMER SHOULD WRITE super(); EXPLICILTY & PASS THE
REQUIRED ARGUMENTS.
 super(); MUST BE WRITTEN ONLY WITHIN THE COSTRUCTOR BODY.
 ALWAYS SUPERCLASS OBJECT SHOULD BE CREATED 1st & THEN
PROPERTIES SHOLD INHERITED TOO SUBCLASS OBJECT & HENCE super();
SHOULD BE ALWAYS WRITTEN AT THE 1st LINE OF CONSTRUCTOR BODY.
 Multiple super(); WITHIN THE SAME CONSTRUCTOR BODY IS NOT ALLOWED.
BECAUSE WRITING Multiple super(); MAY LEAD TO MULTIPLE SUPERCLASS
OBJECTS WHICH IS NOT REQUIRED.
class A{
// Parent Class Constructor with Parameters

public A(int a) {
super(); //new object
System.out.println("Parent Class A Constructor");
}
}
class B extends A{
public B() //Sub Class with Zero Arguments
{
super(1);
//new A(1); super(with value) is mandatory because parent class

consist of
// only parameterized constructor
System.out.println("Subclass B Constructor");
}
}
public class Constructor {
B B1=new B();
}
}
OUTPUT:
Parent Class A Constructor
Subclass B Constructor
OBJECT CLASS:
 IT IS SUPER MOST CLASS IN JAVA WHERE EVERY CLASS DIRECTLY or
INDIRECTLY INHERITICE THE PROPERTIES OF OBJECT CLASS.
 INSIDE OF AN OBJECT CLASS WE HAVE ONE NO ARGUMENT
CONSTRUCTOR & WITHIN THAT CONSTRUCTOR BODY WE DON’T HAVE
ANY SUPER STATEMENT.
CONSTRUCTOR CHAINING:
 IT’S A PROCESS OF SUB CLASS CONSTRUCTOR CALLING SUPER CLASS
CONSTRUCTOR & THAT CONSTRUCTOR IS ANOTHER SUPERCLASS
CONSTRUCTOR & THIS PROCESS WILL BE CONTINUED UNTILL REACHING
OBJECT CLASS.
WHY JAVA DO NOT SUPPORT MULTIPLE INHERITANCE? Or EXPLAIN

DIAMOND problem IN JAVA?
 IT CREATES AN CONFUSION FOR THE COMPLIER TO CHOOSE THE PATH
FROM WHERE PROPERTIES OF OBJECT CLASSS SHOULD BE COPIED TO
SUBCLASS.
 TO CALL MULTIPLE CONSTRUCTORS OF MULTIPLE SUPER CLASSES WE
SHOULD WRITE Multiple super(); WHICH IS NOT SUPPORTED IN JAVA.
 IF BOTH SUPER CLASSES HAVE METHODS WITH SAME NAME & SAME
ARGUMETNS, THEN IT CREATES AN CONFUSION FOR THE COMPLIER TO
CHOOSE WHICCH METHOD SHOULD BE CALLED FOR THE EXECUTION
WHEN IT CACLLED USING SUBCLASS OBJECT.
CONSTRUCTOR CHAINING IN DIFFERENT TYPES OF INHERITANCE
METHOD OVERLOADING
 SUBCLASS ONHERITING METHOD OF SUPERCLASS & CHANGING THE

METHOD DEFINITION ACCORDING SUBCLASS SPECIFICATION WITHOUT
CHANGING METHOD DECLARATION IS CALLED AS METHOD OVERRIDING.
 INHERITANCE IS MANDATORY FOR METHOD OVERRIDING.
 @------- > ANNOTATION.
 @Override (OVERRIDE ANNOTATION) IT COMPARES THE GIVEN METHOD
DECLARATION OF SUBCLASS WITH EVERY OTHER METHOD DECLARATION
PRESENT IN SUPERCLASS & THROWS AN ERROR IF THERE IS NO MATCHING
DECLARATION FOUND.
 FINAL, PRIVATE & STATIC METHODS CANNOT BE OVERRIDDEN.
 IF SUBCLASS & SUPERCLASS CONTAINS STATIC METHODS WITH SAME
NAME & SAME ARGUMENTS THEN IT IS CALLED AS METHOD HIDING.
 IF SUBCLASS & SUPERCLASS CONTAINS STATIC DATA MEMBERS WITH THE
SAME NAME THEN IT IS CALLED AS VARIABLE HIDING or VARIABLE
SHADOWING.
 NOTE: CONSTRUCTORS CANNOT BE OVERRIDDEN.
 OVERRIDDEN METHOD CAN HAVE HIGHEST VISIBILITY COMPARE TO
PARENT CLASS METHOD BUT WE CAN’T PROVIDE HIGHEST SECURITY
COMPARE TO PARENT CLASS METHOD.
package com.OopsPrograms.MethodOverriding;
//METHOD OVERRIDING------->METHOD IN SON CLASS IS OVERRIDING METHOD IN THE

FATHER CLASS
//public void bike() method in father class is OVERRIDDEN by public void
bike() method in son class using keyword @Override
//So output will also be overridden
class Father{
public void bike() {
System.out.println("Bike");
}
}
class Son extends Father{
@Override
public void bike() {
System.out.println("Modified Bike");
}
}
public class MainOverriding {
Son S1=new Son();
S1.bike();
}
}
OUTPUT:
Modified Bike
DIFFERENCE BETWEEN this keyword & this(); statement?

DIFFERENCE BETWEEN super keyword & super(); statement?
Keyword Statement
this. ( used to point the current object) this(); ---(Used to call same class
constructor)
Super-----(used to point the parent Super(); ----(Used to call parent class
object) constructor)
Can be written within Non-Static Only written within the first line of
method & constructor body constructor body
SPUER KEYWORD:
 SUPER KEYWORD IS SPECIAL IN-BUILT REFERENCE VARIABLE WHICH IS
CREATED BY JVM & IT WILL POINT TO IMMEDIATE PARENT CLASS OBJECT.
 SUPER KEYWORD IS USED WITHIN THE SUBCLASS METHODS IN ORDER TO
ACCESSS PROPERTIES OF ITS IMMEDIATE SUPERCLASS.
class Sample1
{
public void count()
{
System.out.println("Count method of parent class");
}
}
class Demo1 extends Sample1
{
@Override
public void count()
{
super.count(); //Call count of parent class
System.out.println("Count overridden method of sub class");
}
}
public class Main {
{
Demo1 d1=new Demo1();
d1.count();
}
}
OUTPUT:
Count method of parent class
Count overridden method of sub class
METHOHD OVERRIDING WITH MULTILEVEL INHERITANCE
Whatsappmsg1
Deliveryreport(); void
Whatsappmsg2
Whatsappmsg3
class Whatsappmsg1{
public void deliveryreport() {
System.out.println("Single Tick");
}
}
class Whatsappmsg2 extends Whatsappmsg1{
@Override
super.deliveryreport();
System.out.println("Double Tick");
}
}
class Whatsappmsg4 extends Whatsappmsg2{
@Override
super.deliveryreport();
System.out.println("Blue tick");
}
}
public class Whatsappmsg3 {

Whatsappmsg4 W1=new Whatsappmsg4();
W1.deliveryreport();
}
}
OUTPUT:
Single Tick
Double Tick
Blue tick
Account
Bal:double
Name:String
AccNo:long
Deposit():Void
Withdraw():void
Current Saving
Minbal:double Roi=
@Override
Withdraw():void
ABSTRACTION
ABSTRACT:
 INCOMPLETE
ABSTRACT METHOD:
 A METHOD WHICH HAS ONLY METHOD DECLARATION & NO METHOD
DEFINITION IS CALLED AS ABSTRACT METHOD.
ABSTRACT CLASS:
 IF THE CLASS IS DELARED WITH ABSTRACT KEYWORD.
 ABSTRACT METHOD MUST BE DECLARED BY USING ABSTRACT KEYWORD
WHEN TO DECLARE
 IF A CLASS CONSIST OF ATLEAST ONE ABSTRACT METHOD THEN THE
CLASS MUST BE DECLARED AS ABSTRACT METHOD
 IT’S IMMPOSSIBE TO CREATE OBJECT OF AN ABSTRACT CLASS.
 WE CAN CREATE REFERENCE VARIABLE OF AN ABSTRACT CLASS.
RULE OF ABSTRACT:
IF A CLASS INHERITANCE FROMM ABSTRACT CLASSTHEN THE SUB CLASS MUST
OVERRIDE ALL ABSTRACT METHODS OF SUPER CLASS ELSE SUB CLASS ALSO
DECLARED AS ABSTRACT CLASS
CONCRETE CLASS:
IF A CLASS IS DECLARED WITHOUT USING ABSTRACT KEYWORD THEN THE
CLASS IS KNOWN AS CONCRETE CLASS.
CONCRETE METHOD:
A METHOD WHICH HAS BOTH METHOD DECLAREATION & METHOD DEFINITION
IS CALLED AS CONCRETE METHOD.
WE CAN CREATE OBJECT OF CONCRETE CLASS & WE CAN CREATE REFERENCE
VARIABLE ALSO.
WHEN TO USE CONCRETE CLASS:
IF A CLASS CONSIST OF ONLY CONCRETE METHOD THEN THE CLASS IS
DECLARED AS CONCRETE CLASS.
package com.OopsPrograms.Abstract1;
abstract class Sample

{
abstract void test(); //Abstract method of abstract class
//overriding is mandatory for abstract method
}
class subclass extends Sample{
@Override
System.out.println("Abstract method of Sample Class is
overridden");
}
}

Sample s1; //Reference variable of abstract class
//create object of subclass
subclass sub1=new subclass();
sub1.test();
}
}
OUTPUT:
Abstract method of Sample Class is overridden
CLASS Abstract class

Concrete Class Block Abstract Class Block
BY DEFAULT CONCRETE METHOD ARE BY DEFAULT CONCRETE METHOD ARE
ALLOWED ALLOWED
WE HAVE CONSTRUCTOR WE HAVE CONSTRUCTOR
WE CAN CREATE OBJECT IMMPOSIBLE TO CREATE OBJECT
WE CAN CREATE REFERENCE WE CAN CREATE REFERENCE
VARIABLE VARIABLE
IMPOSSIBLE TO WRITE ABSTRACT WE CAN WRITE ABSTRACT METHOD’S
METHOD BY USING ABSTRACT KEYWORD.
ABSTRACT METHODS CANNOT BE DECLARED AS:

 FINAL
 STATIC
 PRIVATE
WITHIN AN ABSTRACT CLASS WE CAN WRTE:
 ONLY ABSTRACT METHOD or
 ONLY CONCRETE METHOD or
 BOTH ABSTRACT & CONCRETE METHODS.
 NON-STATIC NON-PRIVATE MEMBERS OF ABSTRACT CLASS CAN BE

ACCESSED BY CREATING THE OBJECT OF ITS SUBCLASS ONLY.
 STATIC NON-PRIVATE MEMBERS OF ABSTRACT CLASS CAN BE ACCESSED

BY USING THE CLASS NAME.
 NOTE: WE CAN WRITE ONLY CONCRETE METHODS WITHIN AN ABSTRACT

CLASS TO AVOID OBJECT CREATION. ELSE WE CAN PREFER CONCRETE
CLASS TO WRITE ONLY CONCRETE METHODS.
package com.OopsPrograms.Abstract1;
abstract class Sample

{
public abstract void test();
public void test1()

{
System.out.println("Non Static Concrete of abstract class");
}
public static void test2() {
System.out.println("Static Concrete of abstract class");
}
}
class subclass extends Sample{
@Override
System.out.println("Abstract Method of Sample Class Overridden");
}
}
Sample s1;
subclass Sub1=new subclass();
Sub1.test();
Sub1.test1();
Sample.test2();
}
}
OUTPUT:
Abstract Method of Sample Class Overridden
Non Static Concrete of abstract class
Static Concrete of abstract class
 STATIC NON-PRIVATE MEMBERS OF ABSTRACT CLASS CAN BE ACCESSED

BY USING THE CLASS NAME.
 IF GENERALIZED METHODS OF ALL THE SUBCLASSES HAVE SAME
DEFINITIONS THEN THOSE METHODS SHOULD DECLARED AS CONCRETE
METHODS IN GENERALIZED CLASS.
GENERALIZED CONCRETE METHODS GENERALIZED ABSTRACT METHODS
NOTE: OVERRIDING NOT MANDATORY NOTE: OVERRIDING IS MANDATORY
0
APPLICATIONS OF ABSTRACT:
 BY USING ABSTRACT CLASSES WE CAN ENSURE THERE ARE NO MISSING
METHOD IMPLEMENTATIONS THE SUBCLASS.
 ABSTRACT ACTS AS BLUEPRINT TO CREATE CONCRETE CLASS.
 FINAL CLASS CANNOT BE INHERITED.
1. FINAL METHODS CAN BE INHERITED BUT CANNOT BE OVERRIDDEN.
2. FINAL VARIABLES CAN BE INHERITED BUT CANNOT BE RE-INTIALZED.
CONSTRUCTOR IN ABSTRACT CLASS:
 WE HAVE DEFAULT CONSTRUCTOR IN ABSTRACT CLASS or WE CAN WRITE
ZERO or PARAMETRIZED CONSTRUCTOR IN ABSTRACT CLASS.
 IT IS IMMPOSSIBLE TO EXECUTE CONSTRUCTOR BY ABSTRACT CLASS
EXPLICITLY BY THE PROGRAMMER.
 IT CAN BE EXECUTED WITH THE HELP OF super();.
 WE CANNOT CREATE OBJECT OF ABSTRACT CLASS BUT WE HAVE
CONSTRUCTOR IN ABSTRACT CLASS IN ORDER TO ACHIVE CONSTRUCTOR
CHAINING BECAUSE FOR ABSTRACT CLASSES ALSO SUPER MOST CLASS IS
OBJECT CLASS.
abstract class A
{
int a;
public A(int a)
{
System.out.println(“Constrructor of Abstract Class”);
}
class B extends A
{
publilc B(int a)
{
super(a);
system.out.println(“B Class Constructor);
}
}
Class Main{
Public static void main(String[] args
{
B b1=new B(10);
}
}
INTERFACE
 INTERFACE IS A TYPE WHERE METHODS ARE BY DEFAULT ABSTRACT &
VARIBALES ARE BY DEFAULT STATIC & FINAL.
 IT IS IMPOSSIBLE TO CREATE OBJECT OF AN INTERFACE.
 WE CAN CREATE REFERENCE VARIABLES OF INTERFACE TYPE.
 THE CLASS CAN INHERIT THE PROPERTIES OF AN INTERFACE ONLY BY
USIING IMPLEMENTS KEYWORD.
 THE INTERFACE FROM WHERE PROPERTIES ARE INHERITED IS CALLED AS
SUPER INTERFACE.
 THE CLASS WHICH IS IPLEMENTS THE INTERFACE IS CALLED AS
IMPLEMENTATION CLASS.
 IF A CLASS IMPLEMENTS AN INTERFACE THEN THE IMPLEMENTATION
CLASS MUST OVERRIDE ALL THE ABSTRACT METHODS PRESENT IN SUPER
INTERFACE ELSE THE CLASS MUST BE DECLARED AS ABSTRACT CLASS.
 AN INTERFACE CANNOT IMPLEMENTS ANOTHER INTERFACE.
 AN INTERFACE SHOULD ONLY EXTENDS ANOTHER INTERFACE.
 AN INTERFACE CAN NEVER INHERIT or EXTENDS FROM A CLASS NOT
EVEN FROM OBJECT CLASS.
 A CLASS CAN IMMPLEMENTS ANY NUMBER OF INTERFACES.
 A CLASS CAN EXTENDS & IMPLEMENTS AT THE SAME TIME.
 A CLASS CAN EXTENDS ONLY ONE SUPERCLASS BUT IT CAN IMPLEMENTS
ANY NUMBER OF INTERFACES AT THE SAME TIME.
interface
{
 By default every method is abstract
 By default datamembers are static & final.
 By default only public Access specifier is allowed.
 Impossible to create a object
 We can create reference variable.
 We don’t have constructor.
}
SUPER Class Abstract Class Interface Interface Class
TYPE class
SUB Class Class Abstract Class Interface Interface
TYPE class (implementation
class)
How to Extends Extends Extends Implements Extends Not
Achieve Possible
inheritance
<<Run>>
a:int
Test():void
implements
<<Run>>
a:int
Test():void
package com.OopsPrograms.Interface1;
interface Run
{
int a=10; //variable (static & final)
//public static final a=10;
void test();
}
class Sample implements Run{
System.out.println("Overridden method of interface Run");
}
}
public class Main1{
System.out.println(Run.a);
Sample S1=new Sample();
S1.test();
Run R1; //reference variable for interface Run
}
}
interface A1{
public void test();
}
interface A2{
public void test1();
}
class Demo {
public void test2() {
System.out.println("Demo");
}
}
class Sample1 extends Demo implements A1,A2{
System.out.println("Override of Interface A1");
}
System.out.println("Override of Interface A2");
}
System.out.println("Override of Demo Class");
}
}
Sample1 S1=new Sample1();
S1.test();
S1.test1();
S1.test2();
}
}
interface PhotoEdit{
public void resize();
public void crop();
public void addFilter();
}
interface videoedit{
public void trim();
public void addaudio();
public void changespeed();
}
class Post{
public void like() {
System.out.println("Like");
}
public void comment() {
System.out.println("Comment");
}
public void share() {
System.out.println("Share");
}
}
class Photo extends Post implements PhotoEdit{
double size=5.6;
int reso;
String type;
public void resize() {
System.out.println("Photo Resize");
}
public void crop() {
System.out.println("Photo Crop");
}
public void addFilter() {
System.out.println("Photo AddFilter");
}
public void collage() {
System.out.println(size);
System.out.println(200);
System.out.println("Image Collage");
}
}
class Video extends Post implements videoedit{
double size=100.0;
int duration;
String quality;
public void trim() {

System.out.println("Video trim");
}
public void addaudio() {
System.out.println("Video Audio");
}
public void changespeed() {
System.out.println("Video Changespeed");
}
public void minute() {
System.out.println(size);
System.out.println(5);
System.out.println("4k");
}
}

Photo P1=new Photo();
P1.resize();
P1.crop();
P1.addFilter();
P1.collage();
P1.like();
P1.comment();
P1.share();
System.out.println("------------");
Video v1=new Video();
v1.trim();
v1.addaudio();
v1.changespeed();
v1.minute();
v1.like();
v1.comment();
v1.share();
}
}
APPLICATION OF INTERFACE
 IF WE HAVE TO DEVELOP A CLASS USING TWO SUPER TYPES THEN WE
SHOULD USE INTERFACES.
 NOTE: ABSTRACT CLASS CANNOT BE USED HERE BECAUSE, A CLASS
CANNOT EXTENDS FROM TWO DIFFERENT SUPER CLASSES AT THE SAME
TIME.
JDK-8 INTERFACE ENHANCEMENT:
 FROM JDK-8 INTERFACES NOW ON SUPPORTS CONCRETE METHODS.
 CONCRETE METHODS OF INTERFAACE SHOULD BE DECLARED ONLLY BY
USING 2 KEYWORS
 1.) STATIC – FOR STATIC METHODS
2.) DEFAULT- FOR NON-STATIC METHODS
 IF YOU WANT A CONCRETE METHOD WITHIN THE INTERFACE WHICH
SHOULD NOT BE OVERRIDDEN IN IMPLEMENTATION CLASS THEN
METHOD SHALL BE DECLARED AS STATIC METHOD.
 IF YOU WANT A CONCRETE METHOD WITHIN THE INTERFACE WHICH YOU
WANT TO BE OVERRIDDEN IN IMPLEMENTATION CLASSES THEN METHOD
SHALL BE DECLARED AS DEFAULT METHOD.
 STATIC METHODS OF INTERFACE CAN BE ACCESSED BY USING INTERFACE
NAME WITH DOT (.) OPERATOR.
 DEFAULT METHODS OF INTERFACE CAN BE ACCESSED BY USING OBJECT
OF ITS IMPLEMENTATION CLASS ONLY.
 IF TWO INTERFACES CONTAINS STATIC METHODS WITH THE SAME NAME
& SAME ARGUMENTS THEN, WE DIFFERENTIATE THEM WITH HELP OF
INTERFACE NAME.
 IF TWO INTERFACES CONTAINS DEFAULT METHODS WITH THE SAME
NAME & SAME ARGUMENTS THEN, IT SHOULD BE OVERRIDDEN IN THE
IMPLEMENTATION CLASS.
interface Sample3{
// abstract method of interface(override is mandatory)
public void test();
// static concrete
public static void test1() {
System.out.println("Static method of interfcae");
}
// non-static concrete(override is optional)
public default void test2() {
System.out.println("Non-Static method of interface");
}
}
class IMPLEMENTATION implements Sample3{
System.out.println("Override of abstract method of interface");
}
}
public class Jdk8 {

Sample3.test1();
IMPLEMENTATION I1=new IMPLEMENTATION();
I1.test();
I1.test2();
}
}
CLASS ABSTRACT CLASS INTERFACE

CONCRETE CLASS BY DEFAULT CONCRETE BY DEFAULT ABSTRACT
METHODS ARE METHODS ARE
ALLOWED ALLOWED
BY DEFAULT CONCRETE WE CAN WRITE FROM JDK-8 WE ARE
METHODS ARE ABSTRACT METHOD BY ABLE WRITE CONCRETE
ALLOWED USING ABSTRACT METHODS BY USING
KEYWORD KEYWORDS
STATIC
DEFAULT
WE CN CREATE OBJECT IMPOSSIBLE TO CREATE IMPOSSIBLE TO CREATE
OBJECT OBJECT
WE CAN CREATE WE CAN CREATE WE CAN CREATE
REFERENCE VARIABLE REFERENCE VARIABLE REFERENCE VARIABLE
WE HAVE WE HAVE WE DON’T HAVE ANY
CONSTRUCTOR CONSTRUCTOR CONSTRUCTOR
WE CAN EXECUTE SUPER() CAN EXECUTE THERE IS NO COMMON
CONSTRUCTOR CONSTRUCTOR PARENT
EXPLICITLY
OBJECT IS SUPER MOST OBJECT IS SUPER MOST
CLASS CLASS
interface Sample5{
public void count();
public static void test() {
System.out.println("Static method of interface Sample5");
}
public default void display() {
System.out.println("Non-Satitc concrete method of interface
Sample5");
}
}
interface Sample6{
public void count();
public static void test() {
System.out.println("Static method of interface Sample6");
}
public default void display() {
System.out.println("Non-Satitc concrete method of interface
Sample6");
}
}
class Implementation1 implements Sample5, Sample6{
public void count() {
System.out.println("Overridden method of interface");
}
public void display()
{
System.out.println("Overridden common default method of
interfaces");
}
}
Sample5.test();
Sample6.test();
Implementation1 I1=new Implementation1();
I1.count();
I1.display();
}
}
OUTPUT:
Static method of interface Sample5
Static method of interface Sample6
Overridden method of interface
Overridden common default method of interfaces
TYPE CASTING
TYPE CASTING
PRIMITIVE TYPE CASTING DERIVED TYPE CASTING
WIDINING NARROWING UPCASTING DOWNCASTING
 CONVERTING ONE TYPE TO ANOTHER TYPE IS CALLED AS TYPECASTING.

 TYPECASTING IS OF 2 TYPES
1) PRIMITIVE CASTING
2) DERIVED CASTING
 CONVERTING ONE PRIMITIVE DATA TYPE VALUE TO ANOTHER PRIMITIVE
DATA TYPE VALUE IS CALED AS PRIMITIVE CASTING
 PRIMITIVE CASTING IS OF 2 TYPES.
1) WIDENING
2) NARROWING
 WIDENING: CONVERTING LOWER DATA TYPE VALUE TO HIGHER DATA
TYPE VALUE.
 WIDENING IS DONE IMPLICITLY BY THE COMPILER.
 NARROWING: CONVERTING HIGHER DATA TYPE VALUE TO LOWER DATA
TYPE VALUE.
 NARROWING SHOULD BE DONE EXPLICITLY BY THE PROGRAMMER BY
WRITING CASTING STATEMENT.
 SYNTAX: (DATATYPE) VAL;/VAR;
 IF A METHOD IS HAVING PRIMITIVE DATA TYPE ARGUMENT THEN FOR
THE SAME METHOD WE CAN PASS VALUES WHICH ARE LOWER DATA TYPE
COMPARED to given METHOD ARGUMENT.
 IF THERE ARE 2 OVERLOADED METHODS ONE WITH LOWER DATA TYPE
ARGUMENT & OTHER WITH HIGHER DATA TYPE ARGUMENT, IF YOU PASS
A LOWER DATA TYPE VALUE & CALL THE METHOD COMPILER WILL
ALWAYS CHOOSE METHOD WITH LOWER DATA TYPE ARGUMENT
package com.OopsPrograms.TypeCasting;
public class Primitive {

int i1=100;
double i2=i1;
System.out.println(i1);
System.out.println(i2);
// Narrowing
double d1=100.78;
int d2=(int)d1;
System.out.println(d1);
// With Character
char c1='a';
int c2=c1; //Widening
System.out.println(c1);
System.out.println(c2);
// float & int

int a1=10;
float f1=a1; //Widening
System.out.println(f1);
int a2=(int)10.78f;//narrowing
char a3=(char)172456; //narrowing

}
}
OUTPUT:
100
100.0
100.78
100
a
97
10
10.0
10
ꆨ
public class Sample1 {

public static void test(int a) {
System.out.println(" int " +a);
}
public static void test(double a) {
System.out.println(" Double " +a);
}

test(1);//1 is int value, search for test(int) arg.
test('i');
// i is char value,search for test(char)//then it search for next higher
capacity type.
byte b1=16;
test(b1);
//b1 is byte value// search for test(byte)//then it search for next
higher capacity type.
short s1=13;
test(s1);
test(100.98);//test(double)
}
}
OUTPUT:
int 1
int 105
int 16
int 13
Double 100.98
 EVEN THOUGH INT & FLOAT HAVE SAME CAPACITY THE DATA IS
REPRESENTED IN A DIFFERENT FORMAT.
 COMPARED TO FLOAT & INT, FLOAT IS HIGHER DATATYPE & INT IS LOWER
DATA TYPE.
 EVEN THOUGH LONG & DOUBLE HAVE SAME CAPACITY THE DATA IS
REPRESENTED IN A DIFFERENT FORMAT.
 COMPARED TO DOUBLE & LONG, FLOAT IS HIGHER DATATYPE & INT IS
LOWER DATA TYPE.
 IF YOU STORE A CHARACTER VALUE WITHIN AN INTEGER VARIABLE THEN
ITS UNICODE VALUE WILL BE STORED IN THE GIVEN INTEGER VARIABLE
DERIVED CASTING or CLASSTYPE CASTING

 CONVERTING ONE OBJECT REFERENCE TYPE TO ANOTHER OBJECT
REFERENCE TYPE IS CALLED AS DERIVED CASTING.
 DERIVED CASTING IS OF 2 TYPES.
 1) UPCASTING
 2) DOWNCASTING
 CONVERTING SUBCLASS OBJECT REFERENCE TO SUPERCLASS OBJECT
REFERENCE IS CALLED UPCASTING.
 UPCASTING IS ACHIEVED BY STORING THE ADDRESS OF SUBCLASS OBJECT
INTO SUPERCLASS REFERENCE VARIABLE.
 ANY SUPERCLASS REFERENCE VARIABLE POINTING TO SUBCLASS OBJECT
IS CALLED AS UPCASTED REFERENCE.
 USING AN UUPCASTED REFERENCE WECAN ACCESS ONLY PROPERTIES OF
SUPERCLASS IN THE SUBCLASS OBJECT & IT IS IMPOSSIBLE TO ACCESS
SUBCLASS PROPERTIES.
 CONVERTING UPCASTED OBJECT REFERENCE BACK TO SUBCLASS OBJECT
REFERENCE IS CALLED DOWNCASTING.
 USING A DOWNCASTED REFERENCE WE CAN ACCESS PROPERTIES OF
SUPERCLASS & SUBCLASS.
Class Parent{
Public void test()
{
System.out.println(“Test of parent”);
}
Class child extends parent{
Public void count()
{
System.out.println(“Count of child”)
}
}
Class Main
{
Public static void main(String[] args)
{
Parent P1=new child(); //Upcasting
Child C1=(Child) P1; //Downcasting
P1.test();
C1.test();
C1.count();
}
}
*****CLASS CAST EXCEPTION:
 NOTE: INHERITANCE IS MANDATORY FOR DERIVED CASTING
 What is ClassCastException?
 WHENEVER WE TRY DOWNCAST AN UPCASTED REFERENCE TO A
DIFFERENT CLASS REFERENCE WHICH DO NOT CONTAINS THE
PROPERTIES OF GIVEN OBJECT, THEN JVM WILL THROW ClassCastException.
 IF A METHOD IS HAVING SUPERCLASS REFERENCE ARGUMENT THEN FOR
THE SAME METHOD WE CAN PASS ALL OF ITS SUBCLASS REFERENCES
COMPARED TO GIVEN METHOD ARGUMENT.
 IF THERE ARE 2 OVERLOADED METHODS ONE WITH SUPER CLASS
REFERENCE ARGUMENT & OTHER WITH SUBCLASS REFERENCE
ARGUMENT, IF YOU PASS SUBCLASS REFERENCE & CALL THE METHOD,
COMPLIER WILL ALWAYS CHOOSE WITH SUBCLASS REFERENCE
ARGUMENT.
class Super{
}
class A extends Super{
}
class B extends Super{
}
public class ClassCastException {
Super s1=new A();
A a1=(A)s1; //Valid Down casting
B b1=(B)s1; //Reason for ClassCastException
}
}
class Super1{
}
class A1 extends Super1{
}
class B1 extends Super1{
}
public class CastingMethods {
public static void check(Super1 a1) {
System.out.println("Super Class ref = "+a1);
}
public static void check(A1 a1) {
System.out.println("A Class ref = "+a1);
}
public static void check(B1 a1) {
System.out.println("B Class ref = "+a1);
}
A1 a1=new A1();
check(a1);
B1 b1=new B1();
check(b1);
Super1 s1=new Super1();
check(s1);
}
}
Output:
A Class ref = com.OopsPrograms.TypeCasting.A1@5e91993f
B Class ref = com.OopsPrograms.TypeCasting.B1@379619aa
Super Class ref = com.OopsPrograms.TypeCasting.Super1@cac736f
A a1=new A(); //Correct

A a1=new B(); //Error
A a1=new Super(); //Error
B a1=new B(); //Correct

B a1=new A(); //Error
B a1=new Super(); //Error
Super a1=new A(); //Correct

Super a1=new B(); // Correct
Super a1=new Super(); // Correct
INSTANCEOF: instanceof OPERATOR COMPARES GIVEN OBJECT REFERENCE WITH
THE GIVEN CLASS RETURNS TRUE IF IT CONTAINS THE GIVEN CLASS
PROPERTIES ELSE RETURN FALSE.
class Super2{
}
class A2 extends Super2{
}
class B2 extends Super2{
}
public class Instanceof {
Super2 s1=new Super2();
System.out.println(s1 instanceof Super2); // True
System.out.println(s1 instanceof A2); //False
System.out.println(s1 instanceof B2); //False
System.out.println("-----------");
A2 a1=new A2();
System.out.println(a1 instanceof Super2); //true
System.out.println(a1 instanceof A2); //true
//System.out.println(a1 instanceof B2); //No relation between A &
B class
System.out.println("-----------");
B2 b1=new B2();
System.out.println(b1 instanceof Super2); //true
System.out.println(b1 instanceof B2); //true
//System.out.println(b1 instanceof A2); //No relation between A
& B class
}
}
OUTPUT:
true
false
false
-----------
true
true
-----------
true
true
NOTE: IF YOU WANT TO ACCESS PARENT CLASS PROPEERTIES WHICH IS COMMON
TO ALL SUB-CLASS THEN, THERE IS NO NEED OF PERFORMING ANY
DOWNCASTING.
 UPCASTING IS NOTHING BUT GENERALIZATION.
 DOWNCASTINNG IS NOTHING BUT SPECIALIZATION.
class User{
}
class Customer extends User{
public void buyproduct() {
System.out.println("Customer Can Buy");
}
public void cancelproduct() {
System.out.println("Customer Can Cancel");
}
}
class Admin extends User{
public void addproduct() {
System.out.println("Admin Can Add");
}
public void removeproduct() {
System.out.println("Admin Can Remove");
}
}
class Loginpage{
public void login(User U1) {
if(U1 instanceof Customer)
{
Customer C1=new Customer();
System.out.println("Customer Object Created");
C1.buyproduct();
C1.cancelproduct();
}
else {
Admin A1=new Admin();
System.out.println("Admin Object Created");
A1.addproduct();
A1.removeproduct();
}
}
}
public class Mainuser {

Loginpage Lp=new Loginpage();
Customer C1=new Customer();
Lp.login(C1);
Admin A1=new Admin();
Lp.login(A1);
}
}
Customer Object Created

Customer Can Buy
Customer Can Cancel
Admin Object Created
Admin Can Add
Admin Can Remove
*****GOLDEN JAVA RULE****
 USING AN UPCASTED REFERENCE IF YOU CALL AN OVERRIDDEN METHOD

THEN YOU ALWAYS GET THE IMPLEMMENTATION OF SUBCLASS
class Super5{
System.out.println("Hello");
}
}
class Child extends Super5{
System.out.println("Java");
}
}
public class Main {
Super5 S1=new Child(); //Upcasting
S1.test();
}
}
OUTPUT:
Java
Note: When we use upcasting and override the method of Parent Class it will execute the
Overriden method in spite of pointing to the method of Parent class.
HOW TO RETURN THE OBJECT
 IF A METHOD IS HAVING CLASS NAME AS RETURN TYPE THEN THAT
METHOD CAN RETURN THE OBJECT OF CORRESPONDING CLASS.
 IF A METHOD IS HAVING SUPERCLASS NAME AS RETURN TYPE THEN THAT
METHOD CAN RETURN ALL OF ITS SUBCLASS OBJECT
package com.OopsPrograms.Objectreturn;
public class Demo {
public static Demo test()

{
return new Demo();
}
{
Demo d1=test();
Demo d2=test();
}
}
_____________________________________________________________________
package com.OopsPrograms.Objectreturn;
class A
{
}
class B extends A
{
}
public class Sample
{
public static A test(A a1)
{
return a1;
}
{
A a=new A();
A a1=test(a);
A a2=test(new B());
}
}
POLYMORPHISM
 ONE ENTITY SHOWING DIFFERENT BEHAVIORS AT DIFFERENT PLACES IS

CALLED POLYMORPHISM.
 POLYMORPHISM IS OF TWO TYPES
 1. COMPILE TIME POLYMORPHISM
 2. RUNTIME POLYMORPHISM
COMPILE TIME POLYMORPHISM
 BINDING THE METHOD DECLARATOPN TO METHOD DEFINITION BY THE
COMPILER AT THE COMPILE TIME BASED ON THE ARGUMENTS IS CALLED
AS COMPILE TIME POLYMORPHISM.
 SINCE THE BINDING IS DONE BEFORE THE EXECUTION IT IS CALLED AS
EARLY BINDING.
 ONCE THE BINDING IS DONE IT CANNOT BE CHANGED AT THE RUNTIME
AND HENCE IT IS ALSO CALLED AS STATIC BINDING.
 METHOD OVERLOADING IS THE BEST EXAMPLE FOR COMPILE TIME
POLYMORPHISM.
RUNTIME POLYMORPHISM
 BINDING THE METHOD DECLARATION TO METHOD DEFINITION BY THE JVM
AT THE RUN TIME BASED ON THE OBJECTS IS CALLED AS RUNTIME
POLYMORPHISM.
 SINCE THE BINDING IS DONE DURING THE EXECUTION IT IS CALLED AS
LATE BINDING.
 ONCE THE BINDING IS DONE IT CAN BE CHANGED AT THE RUNTIME &
HENCE IT IS ALSO CALLED AS DYNAMIC BINDING.
 METHOD OVERRIDING IS THE BEST EXAMPLE FOR RUN TIME
POLYMORPHISM.
RUNTIME POLYMORPHISM EXAMPLE
package com.OopsProgram.Poly;
class Animal
{
public void food() {
System.out.println("Food");
}
}
class Lion extends Animal
{
System.out.println("Non Veg");
}
}
class Elephant extends Animal
{
System.out.println("Veg");
}
}
class Checkfood
{
public void checkfood(Animal a1)
{
a1.food();
}
}
public class Runtime {
Checkfood C1=new Checkfood();
C1.checkfood(new Lion());
C1.checkfood(new Elephant());
}
}
OUTPUT:
Non Veg
Veg
ABSTRACTION
 ABSTRACTION: HIDING
 ABSTRACT: INCOMPLETE.
 HIDING THE IMPLEMENTATION DETAILS OF A CLASS & EXPOSING ONLY
THE SERVICES or BEHAVIOURS IS CALLED ABSTRACTION.
 STEPS TO ACHIVE ABSTRACTION:
1. USING INTERFACAE or ABSTRACT CLASS.
2. ABSTRACT METHOD’S IN INTERFACE or ABSTRACT CLASS.
3. OVERRIDING IS MANDATORY.
4. UPCASTING IS MANDATORY.
 ABSTRACTION IS ACHIEVED BY CREATING 3 LAYERS
1. OBJECT IMPLEMENTATION LAYER
2. OBJECT CREATION LAYER
3. OBJECT UTILIZATION LAYER.
 GENERALIZE ALL THE SUBCLASS METHODS & DECLARE THEM AS
ABSTRACT METHODS IN A COMMON SUPER CLASS or SUPER INTERFACE &
CREATE OBJECT IMPLEMENTATION LAYER.
 CREATE OBJECT CREATION LAYER BY CREATING A CLASS THAT WILL
CREATE THE OBJECTS OF IMPLEMENTATION CLASS & UPCAST IT TO SUPER
CLASS or SUPER INTERFACE REFERENCE.
 WITHIN THE OBJECT UTILIZAATION LAYER UTILIZE UPCASTED REFERENCE
RETURNED BY OBJECT CREATION LAYER TOCALL THE GENERALIZD
METHODS.
package com.OopsPrograms.Abstraction;
interface User{
public void transfer();
}
class ATM implements User{
public void transfer() {
System.out.println("Transfer of ATM ");
}
}
class Web implements User{
public void transfer() {
System.out.println("Transfer of Web");
}
}
class Transcation{
public User selecttype(int pin) {
if(pin==1234) {
User U1=new ATM();
System.out.println("Welcome to ATM");
return U1;
}
else {
User U2=new Web();
System.out.println("Welcome to Web");
return U2;
}
}
}
public class MainTranscation {
Transcation T1=new Transcation();
User U1=T1.selecttype(1234);
U1.transfer();
User U2=T1.selecttype(0000);
U2.transfer();
}
}
OUTPUT:
Welcome to ATM
Transfer of ATM
Welcome to Web
Transfer of Web
HAS-A-RELATION (ASSOCIATION):
 HAS-A RELATION IS A TYPE OF RELAATION WHERE 2 CLASSES ARE
RELATED BASED ON THE DEPENDENCY OF EXISTENCE OF ONE OBJECT
OVER THE ANOTHER CLASS OBJECT.
 HAS-A RELATION IS IMPLEMENTED BY CREATING MEMBER REFERENCE
VARIABLE POINTING TO THE OBJECT OF ANOTHER CLASS.
 TYPES OF HAS-A RELATIONSHIP IN JAVA.
 AGGREGATION
 COMPOSITION
 AGGREGATION: TWO AGGREGATED OBJECTS HAVE THEIR OWN LIFE
CYCLE BUT ONE OF THE OBJECTS HAS AN OWNER OF HAS-A RELATIONSHIP
& CHILD OBJECT CANNOT BELONG TO ANOTHER PARENT OBJECT.
FOR EXAPMLE: A LIBRARY HAS STUDENTS, IF THE LIBRARY IS DESTORYED,

STUDENTS WILL EXIST WITHOUT LIBRARY.
 COMPOSITION: TWO COMPOSITED OBJECTS CANNOT HAVE THEIR OWN

LIFE CYCLE. THAT IS A COMMPOSITE OBJECT CANNOT EXIST ON ITS OWN.
IF ONE COMPOSITE OBJECT IS DESTORYED, ALL ITS PART ARE ALSO BE
DELETED.
FOR EXAPMLE: A HOUSE CAN HAVE MULTIPLE ROOMS. A ROOM CANNOT EXIST
INDEPENDENTLY AND ANY ROOM CANNOT BELONG TO TWO DIFFERENT HOUSES.
IF THE HOUSE IS DESTORYED, ALL ITS ROOMS WILL BE AUTOMATICALLY
DESTROYED.
PACKAGES
1.java.lang
2. java.util
 OBJECT CLASS
 STRING
 STRING BUFFER & STRING BUILDER
 WRAPPER CLASS
 EXCEPTION HANDLING
 COLLECTION FRAMEWORK.
Java.lang
 IT CONTAINS ALL THE CLASSES WHICH ARE ESSENTIAL TO WRITE SIMPLE
JAVA PROGRAM or TO DEVELOP COMPLICATED JAVA APPLICATIONS.
 TO USE CLASSES OF java.lang PACKAGE WE NEED NOT WRITE ANY IMPORT
STATEMENT or FULLY QUALIFIED CLASS NAMES.
OBJECT CLASS
 OBJECT IS SUPER MOST CLASS IN JAVA
 EACH & EVERY CLASS DIRECTLY or INDIRECTLY INHERITS FROM OBJECT
CLASS.
METHODS OF OBJECT CLASS:
 hashCode() [unique integer value generated by jvm based on address of object ]
 toString()
 equals()
 wait()
 wait(long)
 wait(long,int) } -----Threads
 notify()
 notifyAll()
 clone() ------- Object cloning
 getClass()
 finalize()------- Garbage collection
hashCode()
 RETURNS A HASH CODE VALUE FOR THE OBJECT.
 HASH CODE VALUE OF AN OBJECT IS AN UNIQUE INTEGER VALUE WHICH
IS GENERATED BY THE JVM BASED ON THE ADDRESS OF THE GIVEN
OBJECT.
toString()
 RETURNS STRING REPRESENTATION OF THE OBJECT.
 STRING REPRESENTATION CONTAINS
 FULLY QUALIFIED CLASS NAME
 @CHARACTER
 HEXADECIMAL VALLUE OF HASHCODE
Equals(anotherobject)
 IT COMPARES THE HASHCODE VALUE OF GIVEN 2 OBJECTS
WITH OVERRIDING
package com.OopsPrograms.lib;
public class Sample

{
public int hashcode()

{
return 100;
}
@Override
public String toString()
{
return "Overriden String";
}
@Override
public boolean equals(Object obj)
{
return true;
}
Sample s1=new Sample();
System.out.println(s1.hashcode());
System.out.println(s2.hashcode());
System.out.println("----------");
System.out.println(s1.toString());
System.out.println(s1.equals(s2));
}
}
Output:
100
100
----------
Overriden String
Overriden String
----------
true
WITHOUT OVERRIDING
public class Sample

{
// public int hashcode()

// {
// return 100;
// }
// @Override
// public String toString()
// {
// return "Overriden String";
// }
// @Override
// public boolean equals(Object obj)
// {
// return true;
// }
System.out.println(s1.hashCode());
}
}
OUTPUT:
1365202186
1651191114
----------
com.OopsPrograms.lib.Sample@515f550a
com.OopsPrograms.lib.Sample@626b2d4a
----------
false
STRINGS
 STRING VALUE IS A GROUP OF CHARACTERS WHICH IS WRITTEN IN THE
DOUBLE QUOTES.
 WE CAN ACCESS THE CHARACTERS or PERFORM ANY OPERATIONS ON THE
STRING ONLY BY USING THE METHODS OF STRING.
 INTERNALLY STRING VALUE IS STORED AS A CHARACTER ARRAY BY THE
JVM.
String str=”HELLO”
H E L L O
METHODS OF STRING:
 length() : IT RETURNS THE COUNT OF NUMBER OF CHARACTERS PRESENT
IN THE GIVEN STRING.
 charAt(index) : IT RETURNS THE CHARACTER AT THE GIVEN INDEX FROM
THE GIVEN STRING.
 indexOf(char) : IT RETURNS THE INDEX OF THE GIVEN CHARACTER FROM
THE GIVEN STRING. IT RETURNS NEGATIVE VALUE IF THE CHARACTER
DO NOT EXIST.
 indexOf(char, startindex) : IT RETURNS THE INDEX OF THE GIVEN
CHARACTER FROM THE GIVEN STRING BY STARTING THE SEARCH FROM
THE GIVEN STARTINDEX.
 equals(string) : IT COMPARES CHARACTERS OF GIVEN TWO STRING &
RETURNS TRUE IF THEY ARE EXACTLY SAME ELSE IT RETURNS FALSE.
 equalsignoreCase(string) : IT COMPARES CHARACTERS OF GIVEN TWO
STRINGS BY IGNORING THE CASE & RETURNS TRUE IF THEY ARE
EXACTLY SAME ELSE IT RETURNS FALSE.
 substring(strat, no.of chars) : IT CREATES A STRING FROM THE GIVEN
START INDEX WITH GIVEN NO. OF CHARACTERS & RETURNS THE STRING
NOTE: length & length()
length: VARIABLE USED IN ARRAY

length() : METHOD OF STRING
public class Example {

String s1="hello";
String s2="Hello";
System.out.println("Length of s1 : " +s1.length());

System.out.println(s1.charAt(2));
System.out.println(s1.indexOf('l'));
System.out.println(s1.indexOf('l', 3));
System.out.println(s1.equalsIgnoreCase(s2));
System.out.println(s1.substring(1,3));
}
}
OUTPUT:
Length of s1 : 5
l
2
3
false
true
el
STRING CLASS:
 STRING VALUE IS GROUP OF CHARS WRITTEN WITHIN DOUBLE QUOTES.
 IN JAVA STRING IS A CLASS WHICH IS USED TO STORE GROUP OF CHARS
THE STRING OBJECT.
 STRING CLASS IS IMMEDIATE SUB-CLASS OF OBJECT CLASS.
 STRING CLASS IMPLEMENTS Serializable, Comparable<STRING>, CharSequence
interfaces.
 STRING CLASS IS FINAL & IT CANNOT BE INHERITED.
 hashCode() OF OBJECT CLASS IS OVERRIDDEN IN STRING CLASS WHICH
RETURNS AN INTEGER VALUE THAT IS GENERATED BASED ON UNICODE
VALUES OF EVERY CHARACTER PRESENT IN GIVEN STRING.
 toString() OF OBJECT CLASS IS OVERRIDDEN IN STRING CLASS WHICH
RETURNS THE STRING VALUE PRESENT IN GIVEN STRING OBJECT.
 Equals() OF OBJECT CLASS IS OVERRIDDEN IN STRING CLASS WHICH
COMPARES CHARACTERS PRESENT IN GIVEN 2 STRINGS & RETURNS TRUE
IF THEY ARE SAME ELSE RETURNS FALSE

String s1="Hello";
String s2="Hello";
System.out.println(s1.equals(s2));;
}
}
OUTPUT:
69609650
69609650
Hello
Hello
true
STRING OBJECTS ARE CREATED IN SPECIAL MEMORY AREA CALLED STRING
POOL IN HEAP AREA
THE STRING POOL CONSIST OF TWO PARTS
1. CONSTANT POOL
2. NON CONSTANT POOL
STRING OBJECTS CAN BE CREATED IN 2 WAYS

1. BY USING new OPERATOR.
2. WITHOUT USING new OPERATOR.
 IF YOU CREATE A STRING OBJECT WITHOUT USING new OPERATOR THEN

THE OBJECT WILL BE CREATED IN CONSTANT POOL.
 IF YOU CREATE A STRING OBJECT USING new OPERATOR THEN THE OBJECT
WILL BE CREATED IN NON-CONSTANT POOL.
 NOTE: OPERATOR COMPARES ADDRESS OF GIVEN TWO OBJECTS WITHIN
CONSTANT POOL DUPLICATES ARE NOT ALLOWED.
 WITHIN NON-CONSTANT POOL DUPICATES ARE ALLOWED.
HEAP AREA
STRING POOL
CONSTANT POOL
(DUPLICATES ARE NOT ALLOWED)
“hello”
“java”
NON CONSTANT POOL
(DUPLICATE ARE ALLOWED)

WE CAN CREATE OBJECT OF STRING IN 2 WAYS.
1. String s1= “hello”; // STORES IN CONSTANT POOL
2. String s1=new String(“java”); // STORES IN NON-CONSTANT POOL

String s1="hello";
String s2="hello";
String s3=new String("hello");
System.out.println(s1.equals(s2)); // values are same // true
System.out.println(s1 == s2); // address is same // true
System.out.println(s1 == s3); // address is different // false
}
}
OUTPUT:
true
true
false
String s1=”hello”;
s1=s1.concat(“java”);
Output: “hello”
StringBuffer str1=new StringBuffer(“hello”); StringBuffer is a Thread Safe class

str1=str1.append(“java”);
System.out.println (str1);
Output:hellojava
StringBuilder str2=new StringBuilder(“hello”);
Str2.append(“java”);
System.out.println (str2);
Output: hellojava
StringBuffer is a Thread Safe class:

 IMPLEMENTATION IS SYNCHRONIZED
 ALL METHODS ARE SYNCHRONIZED
STRING BUFFER & STRING BUILDER
DIFFERENCE BETWEEN STRING, STRING BUFFER, STRING BUIDER
STRING STRING BUFFER STRING BUIDER

STRING OBJECTS ARE STRINGBUFFER OBJECTS STRINGBUILDER
IMMUTABLE IN NATURE ARE MUTABLE IN OBJECTS ARE MUTABLE
NATURE IN NATURE
STRING OBJECTS CAN BE STRINGBUFFER OBJECTS STRINGBUILDER
CREATED IN 2 WAYS CAN BE CREATED ONLY OBJECTS CAN BE
1. BY USING new BY USINIG new CREATED ONLY BY
OPERATOR. OPERATOR USINIG new OPERATOR
2. WITHOUT USING
new OPERATOR
STRING OBJECTS ARE THERE IS NO STRING THERE IS NO STRING
CREATING IN STRING POOL POOL
POOL(MEMORY
ALLOCATION)
CONCAT METHOD IS APPEND METHOD IS APPEND METHOD IS
PRESENT IN STRING USED IN STRINGBUFFER USED IN
CLASS STRINGBUILDER
STRING CLASS IS NOT A STRINGBUFFER IS STRING BUILDER IS
THREAD SAFE THREAD SAFE NOT A THREAD SAFE.
# code, equals, tostring() ONLY tostring() METHOD ONLY tostring() METHOD
METHOD IS IS OVERRIDDEN IS OVERRIDDEN
OVERRIDDEN IN STRING
CLASS
A STRING BUFFER IS
LIAK A STRING BUT CAN
BE MODIFIED WITHOUT
CREATING ANY DE-
REFERENCED OBJECTS
package com.OopsPrograms.string;

String s1="hello";
s1.concat("java");
System.out.println("-----String-----");
System.out.println("-----StringBuffer-----");
StringBuffer str1=new StringBuffer("hello");
str1.append("java");
System.out.println("-----StringBuilder-----");
StringBuilder str2=new StringBuilder("hello");
str2.append("java");
}
}
Output:
-----String-----
hello
-----StringBuffer-----
hellojava
-----StringBuilder-----
hellojava
WRAPPER CLASS
 WRAPPER CLASSES ARE USED TO CONVERT PRIMITIVES TO JAVA OBJECT.
AUTOBOXING:
 IT IS A MECHANISM OF CONVERTING PRIMITIVES TO JAVA OBJECT
UNBOXING:
 IT IS A MECHANISM OF CONVERTING JAVA OBJECT INTO PRIMITIVES
FOR EVERY PRIMITIVE DATATYPE WE HAVE CORRESPONDING WRAPPER CLASS.
PRIMITIVE WRAPPER
DATATYPES CLASS
byte Byte
short Short
int Integer
long Long
double Double
float Float
char Character
boolean Boolean
 ALL WRAPPER CLASSES ARE SUB CLASSES OF OBJECT CLASSES

 ANY WRAPPER CLASS OBEJCT CAN BE UPCASTED TO OBJECT CLASS
REFERENCE.
 WRAPPER CLASS OBJECTS CAN BE USED JUST LIKE PRIMITIVES TO DO ANY
OPERATIONS
package com.OopsPrograms.wrapper;

//auto Boxing
int a=100;
//Integer i2=Integer.valueOf(a);
Integer i1=a;
System.out.println("int :" +a);
System.out.println("Integer :" +i1);
//Unboxing
//Integer i2=new Integer(180);
Integer i2=180;
//int i3=i2.intvalue();
int a1=i2;
System.out.println("Integer :" +i2);
System.out.println("int :" +a1);
}
}
int :100
Integer :100
Integer :180
int :180
EXCEPTION
OBJECT
THROWABLE
Exception
RuntimeException IOException SQLExcep AWTExcep InterruptedExce
tion tion ption
ArithmeticException EOFException
NullPointerException FileNotFoundExc
eption
ClassCastException InterruptIOExcept
IndexOutOfBoundExcepti ion
on
ArrayIndexOutOfBoundE
xception
StringIndexOutOfBoundE
xception
WHAT IS EXCEPTION?
 EXCEPTION IS AN UNEXPECTED EVENT WHICH OCCURS AT RUNTIME DUE
TO UNEXPECTED OPERATION PERFORMED BY A SINGLE LINE OF CODE.
WHAT IS EXCEPTION HANDLING?
 EXPECTION HANDLING IS WRITING CODE WHICH WILL RECOVER THE
PROGRAM FROM THE EXECUTION AND CONTINUE THE EXECUTION.
ERROR?
 ERROR IS AN UNEXPETED EVENT WHICH OCCURS AT RUNTIME DUE TO
HARDWARE or SOFTWARE FAILURE OF THE SYSTEM.
-----------------------------------------------------------------------------------------------------
 WHENEVER THERE IS AN EXCEPTION JVM WILL CREATE AN OBJECT OF
CORRESPONDING EXCEPTION CLAS.
 JVM WILL PASS THE EXCEPTION OBJECT TO THE METHOD WHICH
CREATED THE EXCEPTION BY USING THROW KEYWORD.
 IF THE METHOD IS NOT ABLE TO HANDLE THE EXCEPTION OBJECT, THEN
JVM WILL TERMINATE THE METHOD’S EXECUTION.
 IF NO METHODS ARE HANDLING THE EXECUTION OBJECT THEN JVM WILL
CALL DEFAULT EXECPTION HANDLER WHICH WILL HANDLE THE
EXCEPTION OBJECT.
 DEFAULT EXCEPTION HANDLER WILL HANDLE THE EXCEPTION AND
PRINTS
1. NAME OF THE EXCEPTION.
2. REASON OF THE EXCEPTION.
3. COMPLETE STACK TRACE.
package com.OopsPrograms.exception;

public static void check(int a) {
int res=1000/a;
}
check(1);
check(0);
check(2);
}
}
Output:
1000
Hello
Exception in thread "main" java.lang.ArithmeticException: / by zero
at com.OopsPrograms.exception.Example.check(Example.java:5)
at com.OopsPrograms.exception.Example.main(Example.java:11)
HOW TO HANDLE THE EXCEPTION.
 BY USING try & catch block
try
{
Risky lines of code
}
catch(ExceptionClass reference)
{
Alternate code
}
public class Handled {

try {
int res=1000/a;
}
catch(Exception ae) //From ArithmeticException upcasting to
Exception. We can use even Throwable
{
System.out.println("Handled");
}
}
check(1);
check(0);
check(2);
}
}
Output:
1000
Hello
Handled
500
Hello
try with multiple catch blocks
Exception e= new ArithmeticException();
Exception e2= new ArrayIndexOutOfBoundException();
Note: WITHIN A CATCH BLOCK WE CAN UPCAST UPTO THROWABLE CLASS.
 ONE TRY BLOCK CAN HAVE MULTIPLE CATCH BLOCKS.
 WE CAN’T WRITE ONLY TRY BLOCK or ONLY CATCH BLOCK.

try {
int res=1000/a;
int [] ar1= {1,2,3};
System.out.println(ar1[a]);
}
catch(Exception ae) //From ArithmeticException upcasting to
Exception. We can use even Throwable
{
// System.out.println("Handled");
ae.printStackTrace();
}
}
check(11);
check(0);
check(2);
}
}
Output:
90
java.lang.ArrayIndexOutOfBoundsException: Index 11 out of bounds for length 3
at com.OopsPrograms.exception.Handled.check(Handled.java:9)
at com.OopsPrograms.exception.Handled.main(Handled.java:19)
java.lang.ArithmeticException: / by zero
500
3
MULTIPLE CATCH BLOCKS

try {
int res=1000/a;
int [] ar1= {1,2,3};
}
catch(ArithmeticException ae) //From ArithmeticException
upcasting to Exception. We can use even Throwable
{
System.out.println("ArithmeticException");
}
catch(ArrayIndexOutOfBoundsException ae) {
System.out.println("ArrayIndex");
}
}
check(11);
check(0);
check(2);
}
}
Output :
90
ArrayIndex
ArithmeticException
500
3
*****finally block*****
 finally block IS EXECUTED IRRESPECTIVE OF OCCURANCE OF EXCEPTIONS.
 finally block SHOULD BE WRITTEN AFTER THE catch block.
NOTE: WE CAN WRITE TRY & FINALLY BLOCK BUT WE CANT HANDLE THE
EXCEPTION IN TRY & FINALLY BLOCK

try {
int res=1000/a;
{
}
finally {
System.out.println("finally block");
}
}
check(11);
check(0);
check(2);
}
}
OUTPUT:
90
finally block
ArithmeticException
finally block
500
finally block
NOTE: TO EXECUTE IMPORTNT SET OF CODES EVEN AFTER EXCEPTION WE

PREFER TO WRITE THOSE CODES WITHIN THE finally block. BECAUSE finally block
WILL EXECUTE IF THE CODE IS THROWING EXCEPTION or NOT

try {
int res=1000/a;
// int [] ar1= {1,2,3};
// System.out.println(ar1[a]);
}
{
}
// catch(ArrayIndexOutOfBoundsException ae) {
// System.out.println("ArrayIndex");
// ae.printStackTrace();
// }
finally {
System.out.println("finally block");
try {
int [] ar1= {1,2,3};
}
catch(Exception ae){
}
}
}
check(11);
check(0);
check(2);
}
}
OUTPUT:
90
finally block
ArithmeticException
finally block
1
500
finally block
3
TYPES OF EXCEPTIONS
 CHECKED EXCEPTION
 UNCHECKED EXCEPTION
CHECKED EXCEPTION
 EXCEPTION WHICH ARE CHECKED BY COMPLIER IS KNOWN AS CHECKED
EXCEPTION.
 LEAVING RUNTIME EXCEPTION & ALL OF ITS SUB CLASSES ARE BELONGS
TO CHECKED EXCEPTION.
UNCHECKED EXCEPTION:
 EXCEPTIONS WHICH ARE NOT CHECKED BY THE COMPLIER IS KNOWN AS
UNCHECKED EXCEPTION.
 RUNTIME EXCEPTION & ALL OF ITS SUBCLASSES ARE BELONGS TO
UNCHECKED EXCEPTION.
EXCEPTION PROPAGATION:
 PASSING THE EXCEPTION OBJECT FRFOMM CALLED METHOD TO CALLING
METHOD IS KNOWN AS EXCEPTION PROPAGATION.
 UNCHECKED EXCEPTIONS WILL BE IMPLICITLY PROPAGATED BY THE JVM.
NOTE: ALL CHECKED EXCEPTIONS WILL BE PROPAGATED BY THE
PROGRAMMER BY USING THROWS KEYWORD.
THROWS KEYWORD:
 THROWS KEYWORD IS USED TO PROPAGATE CHECKED EXCEPTIONS
EXPLICITLY BY THE PROGRAMMER.
THROW KEYWORD:
 THROW KEYWORD IS USED TO THROW THW EXCEPTION EXPLICITLY BY
THE PROGRAMMER ACCORDING TO THE APPLICATION REQUIREMENTS.
public class SampleChecked {

public static void test()throws Exception
{
throw new Exception();
}
try {
test();
}
catch(Exception a) {
a.printStackTrace();
}
System.out.println("Example for checked Exception");
}
}
Output:
java.lang.Exception
at com.OopsPrograms.exception.SampleChecked.test(SampleChecked.java:6)
at com.OopsPrograms.exception.SampleChecked.main(SampleChecked.java:10)
Example for checked Exception
------------------------------------------------------------------------------------------------------------------
//Examplpe for Unchecked Exception & throw throws keyword
public class SampleUnchecked {
public static void test()//throws StringIndexOutOfBoundsException
{
String s1="ABC";
System.out.println(s1.charAt(6));
// throw new StringIndexOutOfBoundsException();
}
try {
test();
}
catch(StringIndexOutOfBoundsException a) {
}
System.out.println("Example for unchecked Exception handled by
programmer");
}
}
Output:
java.lang.StringIndexOutOfBoundsException: String index out of range: 6
at java.base/java.lang.StringLatin1.charAt(StringLatin1.java:48)
at java.base/java.lang.String.charAt(String.java:1515)
at
com.OopsPrograms.exception.SampleUnchecked.test(SampleUnchecked.java:7)
at
com.OopsPrograms.exception.SampleUnchecked.main(SampleUnchecked.java:12)
Example for unchecked Exception handled by programmer
 EXCEPTIONS WHICH IS CREATED BY PROGRAMMER BASED ON
APPLICATION REQUIREMENT IS KNONW AS CUSTOMIZED EXCEPTION.
STEPS TO USE CUSTOMIZED EXCPETION:
 CREATE A CLASS WHICH EXTENDS EXCEPTION.
 CREATE AN OBJECT OF THAT CLASS BY USING THROW KEYWORD.
 HANDLE IT or PROPAGATE IT
class InsufficientBalException extends Exception{
public InsufficientBalException(String msg)//Constructor With Arguments
{
super(msg); //Super Statement
}
}
class Account{
double bal;
public void withdraw(double amt) {
if(amt>=0 && bal>=amt) {
bal=bal-amt;
System.out.println("Withdraw Succesful");
}
else {
try {
throw new InsufficientBalException("Bal Not
Avaliabe");
}
catch(InsufficientBalException a) {
}
}
}
}
public class CustomizedException {
Account a1=new Account();
a1.withdraw(500);
}
}
Output:
com.OopsPrograms.exception.InsufficientBalException: Bal Not Avaliabe
at
com.OopsPrograms.exception.Account.withdraw(CustomizedException.java:17)
at
com.OopsPrograms.exception.CustomizedException.main(CustomizedException.java:
28)
COLLECTION
package com.OopsPrograms.array;

String name;
int empid;
double sal;
public Employee(String name,int empid,double sal) {
this.name=name;
this.empid=empid;
this.sal=sal;
}
@Override
public String toString() {
return "Employee [name=" + name + ", empid=" + empid + ", sal=" +
sal + "]";
}
public static void addEmp() {
Employee e1=new Employee("Vinay",101,20000.0);
Employee e2=new Employee("Gautam",102,20000.0);
Employee e3=new Employee("Rupa",103,20000.0);
Employee[] earray= {e1,e2,e3};
for(int i=0;i<=earray.length-1;i++) {
System.out.println(earray[i]);
}
}

addEmp();
}
}
Output:
Employee [name=Vinay, empid=101, sal=20000.0]
Employee [name=Gautam, empid=102, sal=20000.0]
Employee [name=Rupa, empid=103, sal=20000.0]
 IF WE CREATE AN EMPLOYEE ARRAY THEN WE CACN ADD ONLY

EMPLOYEE OBJECTS HENCE THIS ARRAY BECOMES HOMOGENOUS.
 IF WEE WANT TO CREATE HETEROGENOUS ARRAY THE WE SHOULD
CREATE OBJECT CLASS ARRAY BECAUSE ALL THE CLASSES CAN BE
UPCASTED TO OBJECT CLASS.
Object[] aerray={e1,e2,e2,1,”abcd”,’a’,97.99}
 IF WE ADD PRIMITIVE TO OBJECT CLASS ARRAY THEN IT’S CONSIDER
THOSE PRIMITIVES AS WRAPPER CLASS WHERE ALL THE WRAPPER
CLASSES ARE SUBCLASSES OF OBJECT CLASS.
****DIFFERENCE BETWEEN ARRAY & COLLECTIONS****

ARRAY COLLECTION
FIXED IN SIZE COLLECTION IS GROWABLE IN
NATURE, SIZE OF THE COLLECTION
CAN BE INCREASE AT THE RUNTIME
IT SUPPORTS ONLY HOMOGENOUS BY DEFAULT IT SUPPORTS
HETEROGENOUS data
NO BUILT-IN METHOD SUPPORTS COLLECTIONS HAS BUILT IN
METHODS TO PERFORM BASIC &
ADVANCE OPERATIONS ON THE
GROUP OF DATA
DON’T HAVE ANY UNDERLYING DATA EVERY COLLECTION IS BUILT BY
STRUCTURE USING ATLEAST ONE DATA
STRUCTURE
COLLECTION FRAMEWORK
How to create arraylist?

By creating an object of ArrayList by using Zero Arguments Constructor.
ArrayList a=new ArrayList(); ------- > by default it creates 10 buckets in memory.
With the help of ArrayList(int initialcapacity) Constructor we control the size of array bucket.
ArrayList a=new ArrayList(12);
ArrayList is resizeable.
COLLECTIONS:
 COLLECTIONS IS A UTILITY CLASS PRESENT IN JAVA.UTIL PACKAGE
WHICH CONTAINS ONLY STATIC METHODS.
COLLECTION INTERFACE:
 COLLECTION INTERFACE IS A GROUP OF REFERENCES WHICH
REPRESENTED AS ONE UNIT.
COLLECTION AS OF 3 TYPES
 LIST
 SET
 QUEUE
LIST:
LIST HAS SOME PROPERTIES.
 LIST CAN STORE DUPLICATES.
 LIST HAS INDEX
 LIST SUPPORT MULTIPLE NULL VALUES.
 LIST PRESERVE INSERTION ORDER
 LIST IS A SUB INTERFACE OF COLLECTION WHICH FOLLOWS THE ABOVE
PROPERTIES.
ARRAYLIST:
 ARRAYLIST IS AN IMPLEMENTATION CLASS OF LIST INTERFACE.
 ARRAYLIST CAN STORE DUPLICATES.
 ARRAYLIST HAS INDEX
 ARRAYLIST SUPPORT MULTIPLE NULL VALUES.
 ARRAYLIST PRESERVE INSERTION ORDER
 UNDERLYING DATA STRUCTURE OF ARRAYLIST IS RESIZEABLE ARRAY.
 TO CREATE ARRAYLIST WE NEED TO CREATE OBJECT OF ARRAYLIST.
 WE HAVE 3 CONSTRUCTORS IN ARRAYLIST
CONSTRUCTOR OF ArrayList:
 ArrayList();
CONSTRUCTOR AB EMPTY LIST WITH INITIAL CAPACITYOF 10.

IF WE CREATE ArrayList OBJECT BY CALLING ZERO ARGUMENT
CONSTRUCTOR, IT CONSTRUCTS AN EMPTY ARRAYLIST WITH CAPACITY
OF 10
 ArrayList(Collection c)
CONSTRUCTS A LIST CONTAINING THE ELEMENTS OF THE SPECIFIED

COLLECTION
 Arraylist(int initialCapacity)
CONSTRUCTS AN EMPTY LIST WITH THE SPECIFIED INITIAL CAPACITY.

Formula: CurrentCapacity *3/2 +1
“add” method to add elements to the array (alist.add)

“size()” method to know the size of array(alist.size())
“get()”
 ARRAYLIST IS NOT A THREAD SAFE CLASS & NOT SAFE FOR USE BY
MULTIPLE THREADS.
 ARRAY LIST CLASS IS NOT SYNCHRONIZED.
import java.util.ArrayList;
public class ExampleArrayList {

// Create ArrayList
ArrayList<Object> alist=new ArrayList<Object>();
// Add Elements using add()

alist.add(10);
alist.add(10.1);
alist.add(null);
alist.add('a');
alist.add("10");
alist.add(10);
alist.add(10*10);
System.out.println("Size of arraylist = "+ alist.size());
System.out.println(alist);
//Retrieve the elements
//get(int indes) used to retrieve the data
for(int i=0;i<alist.size();i++) {
System.out.println(alist.get(i));
}
}
}
OUTPUT:
Size of arraylist = 7
[10, 10.1, null, a, 10, 10, 100]
10
10.1
null
a
10
10
100
Example e=new Example();
ArrayList<Object> a=new ArrayList<Object>();
// Add Elements
a.add(100);
a.add(25);
a.add('a');
a.add("Vinay");
a.add(1, e); //adds address of reference variable in the 1st
index
a.add(2,"Add element in 2nd index"); //adds element in 3rd index
System.out.println("Size of arraylist a :" +a.size());

System.out.println(a);
System.out.println(a.contains('a')); //To check the element
present in list and give boollean result
System.out.println(a.contains(250));
System.out.println("-----------------------");
//Remove Elements
a.remove(3); //removes element of 3rd index

System.out.println(("-----------------------"));
a.remove(e);
a.removeAll(a);// removes all the elements

}
}
OUTPUT:
Size of arraylist a :6
[100, com.OopsPrograms.array.Example@5e91993f, Add element in 2nd index, 25,
a, Vinay]
true
false
-----------------------
[100, com.OopsPrograms.array.Example@5e91993f, Add element in 2nd index, a,
Vinay]
-----------------------
[]
METHODS OF ARRAYLIST:
 add(Object ref) : USED TO ADD ONE SPECIFIC OBJECT TO LIST.
 add(int index, object ref): USED TO ADD ONE SPECIFIC OBJECT TO SPECIFIED
INDEX OF LIST.
 addAll(Collection c): TO ADD COMPLETE COLLECTION TYPE OF LIST.
 addAll(int Index, Collection c): TO ADD COMPLETE COLLECTION TYPE TO
SPECIFIED INDEX.
 remove(index): USED TO REMOVE ELEMENT BASED ON INDEX.
 remove(Object) : USED TO REMOVE ELEMENT BASED ON OBJECT.
 removeAll() : USED TO REMOVE COMPLETE ELEMENT FROM LIST.
 get(index): USED TO RETRIEVE ONE ELEMENT FROM LIST.
 clear() : USED TO REMOVE COMPLETE ELEMENTS FROM LIST.
 contains(Object) : IT CHECK THE GIVEN ELEMENT PRESENT OR NOT &
RETURN TRUE/FALSE.
 containsAll(Collection c) : IT CHECK THE COMPLETE LIST PRESENT or NOT &
RETURN TRUE/FALSE.
 size(): USED TO FIND THE SIZE OF LIST.
 isEmpty() : CHECK THE LIST IS EMPTY or NOT & RETURNS TRUE/FALSE
ADD USER DEFINED ELEMENTS TO ARRAYS
class Employees{
String name;
int id;
double sal;
public Employees(String name,int id, double sal) {
super();
this.name=name;
this.id=id;
this.sal=sal;
}
public String toString() {
return "Empployee Details [name: "+name+ ", id: "+id+ ", sal:
"+sal+"]";
}
}
public class UserdefinedElements {
// Create Employee Objects
Employees e1=new Employees("Vinay",101, 10000.0);
Employees e2=new Employees("GAlok",102, 10000.0);
Employees e3=new Employees("VinayR",104, 10000.0);
Employees e4=new Employees("Irshad",103, 10000.0);
// Create ArrayList and Add Employees

ArrayList<Employees> e=new ArrayList<Employees>();
e.add(e1);
e.add(e2);
e.add(e1);
e.add(e3);
e.add(e4);
// Retrive using for loop and get method
for(int i=0;i<=e.size()-1;i++) {
System.out.println(e.get(i));
}
}
}
Output:
Empployee Details [name: Vinay, id: 101, sal: 10000.0]
Empployee Details [name: GAlok, id: 102, sal: 10000.0]
Empployee Details [name: Vinay, id: 101, sal: 10000.0]
Empployee Details [name: VinayR, id: 104, sal: 10000.0]
Empployee Details [name: Irshad, id: 103, sal: 10000.0]
TRY TO CREATE CUSTOMER OBJECT ADD TO ARRAYLIST
DATA MEMBERS: CUSTOMERNAME, CUSTOMERID, CUSTOMER PASSWORD
CHECK YOUR OBJECT PRESENT IN ARRAYLIST.
VECTOR:
 VECTOR CAN STORE DUPLICATES.
 VECTOR HAS INDEX
 VECTOR SUPPORT MULTIPLE NULL VALUES.
 VECTOR PRESERVE INSERTION ORDER.
 UNDERLYING DATA STRUCTURE OF VECTOR IS RESIZABLE ARRAY.
 THE INCREASE OF CAPACITY CAN BE CONTROLED BY THE PROGRAMMER
BY SPECIFYING THE CAPACITY INCREMENT IN THE CONSTRUCTOR
CONSTRUCTORS OF VECTOR:
 Vector(): CONSTRUCTS AN EMPTY VECTOR SO THAT ITS INTERNAL DATA
ARRAY HAS SIZE 10 & ITS STANDARD CAPACITY INCREMENT IS ZERO.
 Vector(collection c): CONSTRUCT A VECTOR CONTAINING THE ELEMENTS OF
THE SPECIFIED COLLECTION.
 Vector(int initialcapacity): CONSTRUCT AN EMPTY VECTOR WITH THE
SPECIFIED INITIAL CAPACITY & WITH ITS CAPACITY INCREMENT EQUAL
TO ZERO.
 Vector(int initialCapacity, int capacity increment): CONSTRUCTS AN EMPTY
VECTOR WITH THE SPECIFIED INITIAL CAPACITY & CAPACITY
INCREMENT.
------------------------------------------------------------------------------------------------
 VECTOR IMPLEMENTATION IS SYNCHRONIZED
 VECTOR IS THREAD SAFE.
 IF MULTIPLE THREADS ACCESS AN VECTOR CONCURRENTLY, & AT LEAST
ONE OF THE THREADS MODIFIES THE VECTOR STRUCTURALLY, IT WILL
NOT IMPACT ON OTHER THREADS
import java.util.Vector;
class Student{
String name;
double marks;
long phoneno;
public Student(String name,double marks,long phoneno) {
this.name=name;
this.marks=marks;
this.phoneno=phoneno;
}
public String toString(){
return "Student Details [Student Name : " +name+ ",Student Marks
: "+marks+ ", Student Phoneno: "+phoneno+"]";
}
}
public class StudentArray {

Student s1=new Student("Vinay",70.0,7204469689l);
Student s2=new Student("Rupa",80.0,984569689l);
Student s3=new Student("Dhina",90.0,72044694215l);
Vector<Object> v=new Vector<Object>();
v.add(s1);
v.add(s2);
v.add(s3);
for(int i=0;i<=v.size()-1;i++) {
System.out.println(v.get(i));
}
}
}
SET
 SET DO NOT STORE DUPLICATES
 SET DO NOT HAVE INDEX.
 SET SUPPORT TO STORE ONLY ONE NULL VALUES.
 SET DON NOT PRESERVE INSERTION ORDER.
HASHSET:
 HASHSET DO NOT STORE DUPLICATES.
 HASHSET DO NOT HAVE INDEX.
 HASHSET SUPPORT TO STORE ONLY ONE NULL VALUES.
 SET DON NOT PRESERVE INSERTION ORDER.
 UNDERLYING DATASTRUCTURE OF HASHSET IS HASH TABLE.
Hashset<Object> h=new Hashset<Object>();

Hashset Hashmap Hashing
1 Key Value Key *16 Reminder
5 1 Null 1 16 1
16 5 Null 5 16 5
0 16 Null 16 16 0
Null 0 Null 0 16 0
4 Null Null Null 16 Null
4 Null 4 16 4
CONSTRUCTOR OF HASHSET:
 Hashset() : CONSTRUCT A NEW EMPTY SET WITH INITIAL CAPACITY (16) &
LOAD factor (0.75).
 Hashset(collection c): CONSTRUCT A NEW SET CONTAINING THE ELEMENTS IN
THE SPECIFIED COLLECTION .
 Hashset(int initial capacity): CONSTRUCTS A NEW EMPTY SET WITH SPECIFIED
INITIAL CAPACITY & DEFAULT LOAD FACTOR(0.75).
 Hashset(int initialcapacity, float loadfactor): CONSTRUCTS A NEW EMPTY SET
WITH THE SPECIFIED INITIAL CAPACITY & THE SPECIFIED LOAD FACTOR.
 HASHSET IMPEMENTATION IS NOT SYNCHRONIZED.
 HASHSET IS NOT THREAD SAFE.
1. ADD CUSTOMER OBJECT TO HASHSET & RETRIVE IT.

DATA MEMBERS: NAME,CID,CPWD.
2. WHAT IS THE OUTPUT OF ,7,8,10,11,16,NULL,0 IF YOU ADD THESE ELEMENT
IN HASHSET?
LINKED HASHSET:
 LINKED HASHSET DO NOT STORE DUPLICATES.
 LINKED HASHSET DO NOT HAVE INDEX.
 LINKED HASHSET SUPPORT TO STORE ONLY ONE NULL VALUES.
 LINKED HASHSET ALWAYS PRESERVE INSERTION ORDER.
 UNDERLYING DATA STRUCTURES OF LINKED HASHSET IS HAS TABLE &
LINKED LIST.
CONSTRUCTOR OF LINKEDLIST:
 LinkedHashset() : CONSTRUCTS A NEW EMPTY SET WITH INITIAL CAPACITY
(16) & LOAD factor (0.75).
 LinkedHashset (collection c): CONSTRUCTS A NEW EMPTY SET CONTAINING
THE ELEMENTS IN THE SPECIFIED COLLECTION.
 LinkedHashset (int initial capacity): CONSTRUCTS AN NEW EMPTY SET WITH
SPECIFIED INITIAL CAPACITY & DEFAULT LOAD FACTOR (0.75).
 LinkedHashset (int initialcapacity, float loadfactor): CONSTRUCTS A NEW EMPTY
SET WITH THE SPECIFIED INITIAL CAPACITY & THE SPECIFIED LOAD
FACTOR.
 LINKEDHASHSET IMPEMENTATION IS NOT SYNCHRONIZED.
 LINKEDHASHSET IS NOT THREAD SAFE.
import java.util.LinkedHashSet;
public class LinkedHashset {

LinkedHashSet<Integer> l=new LinkedHashSet<Integer>();

l.add(10);
l.add(20);
l.add(40);
l.add(null);
// for(Integer i:l) {
// System.out.println(i);
// }
System.out.println(l);
l.forEach(obj -> System.out.println(obj));
}
}
Output:
[10, 20, 40, null]
10
20
40
null
import java.util.Vector;
class Student{
String name;
double marks;
long phoneno;
public Student(String name,double marks,long phoneno) {
this.name=name;
this.marks=marks;
this.phoneno=phoneno;
}
public String toString(){
return "Student Details [Student Name : " +name+ ",Student Marks
: "+marks+ ", Student Phoneno: "+phoneno+"]";
}
}
public class StudentArray {

Student s1=new Student("Vinay",70.0,7204469689l);
Student s2=new Student("Rupa",80.0,984569689l);
Student s3=new Student("Dhina",90.0,72044694215l);
Vector<Object> v=new Vector<Object>();
v.add(s1);
v.add(s2);
v.add(s3);
for(int i=0;i<=v.size()-1;i++) {
System.out.println(v.get(i));
}
}
}
Output:
Student Details [Student Name : Vinay,Student Marks : 70.0, Student Phoneno:
7204469689]
Student Details [Student Name : Rupa,Student Marks : 80.0, Student Phoneno:
984569689]
Student Details [Student Name : Dhina,Student Marks : 90.0, Student Phoneno:
72044694215]
DIFFERENCE BETWEEN ARRAYLIST & VECTOR?
ARRAYLIST VECTOR
ITS NOT THREAD SAFE ITS THREAD SAFE
NOT SYNCHRONIZED SYNCHRONIZED
REMOVE THE DUPLICATES ELEMENTS FROM ARRAYLIST
import java.util.HashSet;
public class RemoveDuplicates {

ArrayList<Integer> a1=new ArrayList<Integer>();
a1.add(1);
a1.add(3);
a1.add(12);
a1.add(4);
a1.add(1);
a1.add(12);
a1.add(20);
// Remove the duplicates
// Convert ArrayList to HashSet
HashSet<Integer> h1=new HashSet<Integer>(a1);
System.out.println(h1);
}
}
OUTPUT:
[1, 3, 12, 4, 1, 12, 20]
[1, 3, 4, 20, 12]
RETRIVE THE 3RD ELEMENT FROMM HASHSET
public class Element {

HashSet<Integer> h1= new HashSet<Integer>();

h1.add(20);
h1.add(30);
h1.add(null);
h1.add(1);
h1.add(5);
System.out.println(h1);
//Retrive 3rd element
//Convert to List
ArrayList<Integer> a1=new ArrayList<Integer>(h1);
System.out.println(a1.get(3));
}
}
Output:
[null, 1, 20, 5, 30]
5
SORTING OF THE ELEMENTS USING COMPARETO METHOD( CompareTo() )
//import java.util.Collection;
import java.util.Collections;
//import java.util.HashSet;
public class SortList {


a1.add(25);
a1.add(20);
a1.add(5);
a1.add(1245);
a1.add(1);
a1.add(-20);
a1.add(42);
a1.add(20);
System.out.println("Before Sorting: "+a1);
Collections.sort(a1);
System.out.println("After Sorting: "+a1);
Collections.sort(a1,Collections.reverseOrder());
System.out.println("Reverse Orders: "+a1);
}
}
Output:
Before Sorting: [25, 20, 5, 1245, 1, -20, 42, 20]
After Sorting: [-20, 1, 5, 20, 20, 25, 42, 1245]
Reverse Orders: [1245, 42, 25, 20, 20, 5, 1, -20]
//import java.util.Collection;
import java.util.Collections;
public class SortList {


a1.add(25);
a1.add(20);
a1.add(5);
a1.add(1245);
a1.add(1);
a1.add(-20);
a1.add(42);
a1.add(20);
System.out.println("Before Sorting: "+a1);
System.out.println("--------------");
Collections.sort(a1);
System.out.println("After Sorting: "+a1);
System.out.println("Reverse Orders: "+a1);
HashSet<Integer> h1=new HashSet<Integer>(a1);
System.out.println("Removing Duplicates Using HashSet: "+h1);
System.out.println("Reverse Orders of : "+h1);
}
}
Output:
Before Sorting: [25, 20, 5, 1245, 1, -20, 42, 20]
--------------
After Sorting: [-20, 1, 5, 20, 20, 25, 42, 1245]
--------------
Reverse Orders: [1245, 42, 25, 20, 20, 5, 1, -20]
--------------
Removing Duplicates Using HashSet: [1, -20, 20, 5, 25, 42, 1245]
--------------
Reverse Orders of : [1, -20, 20, 5, 25, 42, 1245]
COLLECTION SORT.
 Sort(List <i> )
 Sort(List <i> , Comparator c)
<<Comparator>> ----- > compare(obj1, obj2)
Collections.sort(a, Collections.reverseorder( ) );
TREESET:
 IT IS A NON-LINEAR DATA STRUCTURE WHERE DATA IS STORED
ACCORDING TO SOME RELATION.
 TREE CONSISTS OF NODES & LINKS.
 NODE CONSISTS OF DATA & ADDRESS OF OTHER DATA.
 THE LINK REPRESENTS THE RELATION BETWEEN ONE NODES TO
ANOTHER NODE.
 TREESET DO NOT STORE DUPLICATES.
 TREESET DO NOT HAVE INDEX
 TREESET DO NOT SUPPORT TO STORE NULL VALUES (NOOT EVEN ONE
NULL VALUE ) IF YOU TRY TO ADD NULL VALUES THE JVM WILL
THROWS NULL POINTER EXCEPTION.
 TREESET DO NOT ALLOW HETEROGENOUS DATA.
 TREESET DO NOT PRESERVE INSERTION ORDER.
 UNDERLYING DATA STRUCTURE OF TREESET IS “ BINARY SEARCH
TREE”.
TREE SET CONSTRUCTOR:
1. Default Natural Sorting.
TreeSet t=new TreeSet( );
CREATES AN EMPTY TREESET OBJECTS WHERE ELEMENTS WILL BE

INSERTED ACCORDING TO DEFAULT NATURAL SORTING ORDER.
2. Camparator c.
TreeSet t= new TreeSet(comparator c);
CREATES AN EMPTY TREESET OBJECT WHERE ELEMENTS WILL BE

INSERTED ACCORDING TO CUSTOMIZED SORTING ORDER.
3. Collection object
TreeSet t=new TreeSet(collection c);
4. SortedSet s
TreeSet t=new TreeSet(sortedset s);
import java.util.TreeSet;
public class TreeExample

{
{
TreeSet<Integer> t1=new TreeSet<Integer>();
TreeSet<String> t2=new TreeSet<String>();
t1.add(5);
t1.add(10);
t1.add(4);
t1.add(6);
t1.add(3);
t1.add(2);
t2.add("Vinay");
t2.add("Abhi");
t2.add("Zoo");
t2.add("12345678");
t2.add("raj");
t2.add("Raj");
t2.add("123as45678");
t2.add("xy12345678");
t2.add("12345678asd");
System.out.println(t1);
System.out.println(t2);
}
}
Output:
[2, 3, 4, 5, 6, 10]
--------------
[12345678, 12345678asd, 123as45678, Abhi, Raj, Vinay, Zoo, raj, xy12345678
CUSTOMIZED & RETRIVING
import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;
class Customized implements Comparator<Integer>{
@Override
public int compare(Integer o1, Integer o2) {
return o2-o1;
}
}
public class TreeCustomized
{
{
Customized c=new Customized();
TreeSet<Integer> t=new TreeSet<Integer>(c);
t.add(20);
t.add(-20);
t.add(2);
t.add(5);
t.add(7);
t.add(9);
t.add(1);
System.out.println(t);
Iterator<Integer> i1=t.iterator(); //retrieving

while(i1.hasNext()) {
System.out.println(i1.next());
}
}
}
Output:
[20, 9, 7, 5, 2, 1, -20]
20
9
7
5
2
1
-20
FILE HANDLING
 FILE HANDLING IS USED TO READ & WRITE THE DATA TO A FILE.
 FILE OPERATIONS IN JAVA
 THE FOLLOWING OPERATIONS CAN BE PERFORMED ON A FILE IN JAVA:
 CREATE A FILE
 READ FROM A FILE
 WRITE TO A FILE
 DELETE A FILE
CREATE FILE:
 WE CAN USE FILE CLASS IN JAVA TO CREATE A FILE OBJECT.

 createNewFile(); : USED TO CREATE FILE OBJECT.
 EXAMPLE:
 File obj=new File(“filename.txt”);
 Obj.createNewFile();
 FILE CLASS IS PRESENT IN JAVA.IO PACKAGE.
package com.OopsPrograms.filehandling;
import java.io.File;
import java.io.IOException;
public class Create {

File obj=new File("F:\\Vinay QSpider\\JAVA Pgms\\File
Handling\\myfile.txt");
try
{
obj.createNewFile();
}
catch(IOException e) {
e.printStackTrace();
}
}
}
WRITE TO FILE:
 BY USING FileWritter CLASS WE CAN WRITE DATA TO FILE.
 EXAMPLE: FileWritter write=new FileWritter(obj);
 write() IS USED TO WRITE THE DATA TO FILE.
 close() IS USED TO THE FILE, ADTER CLASE WE CANT WRITE ANYTHING TO
A FILE.
 OR WE CAN USE flush();
READ FROM A FILE
 TO READ THE DATA FROM FILE WE CAN USE SAME SCANNER CLASS &
SUPPLY IT TO A FILE OBJECT
 EXAMPLE: Scanner sc=new Scanner(File obj);
While(sc.hasNext())
{
String line=sc.nextLine();
System.out.println(line);
}
DELETE A FILE:
 Delete() : TO DELETE A FILE IN JAVA WE CAN USE FILE OBJECT DELETE
METHOD.
 IT DELETES A DIRECTORY MENTIONED IN THE PATH ONLY IF THE
DIRECTORY IS EMPTY.
if(obj.delete())
{
System.out.print;n(“my file is deleted”);
}
else
{
}
System.out.println(“Name of file =” +obj.getName());

System.out.println(“Loaction =” +obj.getAbsolutePath());
System.out.println(obj.canRead());
System.out.println(obj.length());
package com.OopsPrograms.filehandling;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Scanner;
public class Create {

{
//Create a file
File obj=new File("F:\\Vinay QSpider\\JAVA Pgms\\File
Handling\\myfile.txt");
try
{
obj.createNewFile();
}
catch(IOException e)
{
}
//Write to a File
FileWriter write = null;
try
{
write = new FileWriter("F:\\\\Vinay QSpider\\\\JAVA
Pgms\\\\File Handling\\\\myfile.txt");
}
catch (IOException e)
{
}
Scanner sc=new Scanner(System.in);
System.out.println("Enter your message");
String msg=sc.nextLine();
try
{
write.write(msg);
}
{
}
try {
write.close();
}
{
}
// Read file
Scanner sc1;
try {
sc1 = new Scanner(obj);
while(sc1.hasNext())
{
String lines=sc1.nextLine();
System.out.println(lines);
}
}
catch (FileNotFoundException e)
{
}
// Delete the file

if(obj.delete())
{
System.out.println("Succefully Deleted");
}
else
{
}
}
}
STREAMS IN JAVA:
 IN JAVA, A SEQUENCE OF DATA IS KNOWN AS A STREAM.
 THIS CONCEPT IS USED TOPERFORM INOUT & OUTPUT OPERATIONS ON A
FILE.
 THERE ARE TWO TYPES OF STREAM
 INPUT STREAM
 FileInputStream
 ObjectInputStream
 OUTPUT STREAM
 FileOutputStream
 ObjectOutputStream
SERIALIZATION:
 THE PROCESS OF WRITING STATE OF OBJECT TO A FILE IS CALLED
SERIALIZATION.
 IT IS THE PROCESS OF CONVERTING AN OBJECT FROM JAVA SUPPORTED
FORM TO FILE SUPPORTED FORM OR NETWORK SUPPORTED FORM.
 BY USING FileOutPutStream & ObjectOutPutStream classes we can achive
Serialization.
 Example :
FileOutPutStream fos=new FileOutPutStream (“myfile.txt”);
ObjectOutPutStream oos=new ObjectOutPutStream(fos);
Oos.writeObject(ref);
className ref=(className)ois.readObject();
System.out.println(ref.a+” , “+ref.b);
DE-SERIALIZATION:
 THE PROCESS OF READING STATE OF OBJECT FROM A FILE IS CALLED DE-
SERIALIZATION.
 IT IS THE PROCESS OF CONVERTING AN OBJECT FROM FILE SUPPORTED
FORM or NETWORK SUPPORTED FORM IN TO JAVA SUPPORTED FORM.
 BY USING FileInPutStream & ObjectInPutStream CLASSES WE CAN ACHIVE DE-
SERIALIZATION.
EXAMPLE:
FileInPutStream fis=new FileInPutStream(“myfile.txt”);
ObjectInPutStream ois=new ObjectInPutStream(fis);
className ref=(className)ois.readObject();
 WE CAN SERIALIZE ONLY SERIALIZABLE OBJECT.
 TO ACHIVE SERIALIZATION
 CLASS MUST IMPLEMENTS SERILIZABLE INTERFACE
 Serializable Interface: SERIALIZABLE INTERFACE PRESENT IN JAVA.IO
PACKAGE IT DOESN’T CONTAIN ANY METHODS, IT IS KNOWN AS MARKER
INTERFACE.
 IF WE SERIALIZE NON-SERIALIZABE OBJECT THEN WE WILL GET
java.io.NotSerializableException.
 TRANSI

Java Notes Final

Uploaded by

Document Information

Original Description:

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Java Notes Final

Uploaded by

Copyright:

Available Formats

OPERATORS:

OPERATOR PERFORMS OPERATIONS ON OPRERANDS AND PRODUCE RESULTS

public class com {

LOGICAL AND (&&)

CONDITION 1 CONDITION 2 RESULT

public class Logical {

LOGICAL OR ( || ) OPERATOR WILL RETURN FALSE IF AND ONLY IF THE RESULT

TRUTH TABLE OF LOGICAL OR(||)

CONDITION 1 CONDITION 2 RESULT

BITWISE OPERATOR WILL PERFORM BITWISE OPERATIONS ON EVERY BIT OF

0011001 0011001 0011001

public class Bit {

PS F:\Vinay QSpider\JAVA Pgms> javac Bit.java

-CONCATENATION OPERATOR (+) IS USED TO JOIN A STRING VALUE WITH ANY

EX: - “HELLO” + “WORLD”

public class conc {

FUNCTIONS IS NAMED BLOCK OF CODE USED TO CODE REUSEABLITY

accessspecifier accessmodifier returntype methodname(parameteers)

public static void main (String[] args)

 IF METHODS RETUTNS ANY VALUE THEN THE RETURNED VALUE SHOULD

TYPES OF FUNCTION CALL

SEQUENCE FUNCTION CALL

SAME METHOD CALLING MORE THEN ONE METHOD IS CALLED AS SEQUENCE

DECISION MAKING STATEMENTS

public class number {

PS F:\Vinay QSpider\JAVA Pgms> javac Ifelseif.java

1) public class Bill {

PS F:\Vinay QSpider\JAVA Pgms> javac Bill.java

PS F:\Vinay QSpider\JAVA Pgms> java Bill

IF WE WRITE AN ”IF” STATEMENT WITHIN THE BODY OF ANOTHER IF

STATEMENT THEN IT IS KNOWN AS NESTED IF.

public static void main(String[] args)

public static void main(String[] args)

PS F:\Vinay QSpider\JAVA Pgms\codingbat> javac Nested1.java

GIVEN NUMBER IS EVEN OR ODD.**//

IT IS A TYPE OF DECISION MAKING STATEMENTS WHICH IS USED WHENEVER

case choice 1:statement

PS F:\Vinay QSpider\JAVA Pgms\codingbat> javac quiz.java

LOOPING STATEMENTS ARE USED TO EXECUTE ONE OR MULTIPLE STATEMENTS

START check did you reach the end

public class loop1 {

public class onetoten {

Print the numbers from 10 to 1?

Calculate sum of even number from 1 to 100?

Print the number 10 to 1 using while loop.

DO WHILE LOOP IS USED WHENEVER THE STATEMENTS OF THE LOOP SHOULD BE

WRITING THE LOOP WITHIN THE BODY OF ANOTHER LOOP.

PS F:\Vinay QSpider\JAVA Pgms\codingbat\looping statements> javac nestedloop.java

public class nestedloop {

PS F:\Vinay QSpider\JAVA Pgms\codingbat\looping statements> javac nestedloop.java

Lower Bound Upper Bound

DECLARATION & CREATION

LOWER BOUND(START INDEX)=0

public class PrintArray {

Using for loop

public class Array3 {

PS F:\Vinay QSpider\JAVA Pgms\codingbat\array> javac Array3.java

//copy the given array and print in new array

public class Array5 {

public static void main(String[] args) {

PS F:\Vinay QSpider\JAVA Pgms\codingbat\array> javac Array5.java

Find the even numbers from Array

USING FOR EACH LOOP TO RETRIVE THE ELEMENTS FROM THE