Maipathi Sir Core and Adv Java and JDBC

Dt : 16/6/2022(Day-1)
Note:
=>Every Language will have its own Alphabets,Grammer and Construction Rules.
CoreJava:(Language)
1.Programming Components(Java Alphabets)
ii
2.Programming Concepts
ath
3.Object Oriented Programming features.
ip
1.Programming Components(Java Alphabets)
(a)Variables
Ma
1.Primitive DataType Variables(will hold Values)
(a)Static variables
sh
(b)NonStatic variables
(i)Instance Variables
ate
(ii)Local Variables
2.NonPrimitive DataType Variables(will object references)

nk
(a)Static variables
(b)NonStatic variables
Ve
(i)Instance Variables
(ii)Local Variables
(b)Methods
1.static methods
2.NonStatic methods(Instance Methods)
PAGE:1
(c)Blocks
(d)Constructors
(e)Classes
(f)Interfaces
(g)AbstractClasses
ii
2.Programming Concepts
ath
(a)Object Oriented Programming Concept
(b)Exception handling process
ip
(c)Multi-Threading Concept
(d)Java Collection Framework(JCF)
(e)Files in Java
Ma
(f)Networking in Java
sh
3.Object Oriented Programming features.

ate
(a)Class
(b)Object
nk
(c)Abstraction
(d)Encapsulation
Ve
(e)PolyMorphism
(f)Inheritance
Note:
=>Using CoreJava components and concepts we can develop StandAlone Applications.
PAGE:2
faq:
define StandAlone Application?
=>The applications which are installed in one computer and performs actions
in the same computer are known as StandAlone Applications or DeskTop applications
or Windows Applications.
ii
ath
Note:
=>According to developer StandAlone applications means,
ip
No HTML input
No Server Environment
NO DataBase Storage.
Ma
=============================================================================
sh
*imp
define Program?
ate
=>Set-of-Instructions is a program.
nk
define Programming?
=>The process used to construct program is known as Programming.

Ve
Note:
=>The process of converting 'Analysis and Design' into Source code is known as
Programming.
PAGE:3
define programmer?
=>The person who writes the programs is known as Programmer o developer.
==========================================================================
Note:
=>After writing the program,save the program with language extention.
Test.c
ii
Test.cpp
ath
Test.java
=>After Saving the program,the program will have the following two stages:
ip
(a)Compilation process
(b)Execution process
Ma
sh
(a)Compilation process:
=>The process of checking the program constructed according to the rules of

ate
language or not,is known as Compilation process.
=>C,c++ and Java Languages will use Compiler in Compilation process.

nk
=>After Compilation process is successfull,then Compiled Codes are generated.
=>C and C++ programs generate Objective Code and Java Programs generate
Ve
ByteCode.
(b)Execution process:
=>The process of running CompiledCodes and checking the required output is
generated or not,is known as Execution process.
PAGE:4
=>In c and c++ languages,the Objective code is converted into ExecutableCode
and generate result.
=>In Java Language,the ByteCode is executed on JVM(Java Virtual Machine).
Diagram:
ii
ip ath
Ma
sh
============================================================================
faq:
ate
wt is the diff b/w
(i)Objective Code
nk
(ii)Byte Code
Ve
(i)Objective Code:
=>The Compiled Code generated from c and c++ programs is known as Objective
Code.
=>while Objective Code generation,OperatingSystem is participated because of
PAGE:5
this reason Objective Code is PlatForm dependent code.
Dis-Advantage:
=>The ObjectiveCode which is generated from one Platform cannot be executed on
other PlatForms.
ii
Note:
ath
=>C and c++ languages which are generating Objective Code ara PlatForm dependent
languages.
ip
-----------------------------------------------------------------------
(ii)Byte Code:
Ma
=>The CompiledCode generated from Java programs is known as Byte Code.
=>while ByteCode generation,OperatingSystem is not participated because of this

sh
reason ByteCode is Platform Independent code.
ate
Advantage:
=>The ByteCode generated from one Platform can be executed on all Platforms
nk
based on JVM.
Ve
Note:
=>Java Language which is generating ByteCode is Platform independent language.
Diagram:
PAGE:6
ii
ip ath
Ma
sh
============================================================================
Dt : 17/6/2022(Day-2)
ate
*imp
Java Software:
nk
1995 - Java Alpha&Beta

Ve
1996 - JDK 1.0
1997 - JDK 1.1
1998 - JDK 1.2
2000 - JDK 1.3
2002 - JDK 1.4
PAGE:7
-----------------------------------------------------
2004 - Java5
2006 - Java6
2011 - Java7
--------------------------------------------
2014 - Java8
ii
2017 - Java9
ath
2018 - Java10 & Java11
2019 - Java12 & Java13
ip
2020 - Java14 & Java15
2021 - Java16 & Java17
2022 - Java18
Ma
=========================================================
sh
faq:
wt is the diff b/w

ate
(i)JDK
(ii)JRE
nk
(i)JDK:
Ve
=>JDK stands for 'Java Development Kit' and which is having JavaCompiler,
JavaLibrary and JVM.
JavaCompiler:
=>JavaCompiler is used to compile the Source Code and generate ByteCode.
PAGE:8
JavaLibrary:
=>JavaLib will provide pre-defined components which are used in application
development.
=>JavaLib is represented with the word 'java'.
=>JavaLib is collection of 'packages'.
ii
=>packages are collection of 'Classes and Interfaces'.
ath
=>'classes and Interfaces' are collection of 'Variables and Methods'.
ip
Diagram:
Ma
=>The following are some important packages:
sh
CoreJava packages:
java.lang - Language package(default package)

ate
java.util - Utility package
java.io - IO Streams and files package

nk
java.net - Networking package
AdvJava packages:
Ve
java.sql - DataBase Connection package
javax.servlet - Servlet Programming package
javax.servlet.jsp - JSP Programming package
JVM:
PAGE:9
=>JVM Stands for 'Java Virtual Machine' and which is used to execute
Java ByteCode
=>JVM internally having the following partitions:
(i)Class Loader SubSystem
(ii)Runtime Data Area
(iii)Execution Engine
ii
ath
faq:
define Virtual Machine?
ip
=>The s/w program which internally having the behaviour like machine is known as
Virtual Machine.
Ma
--------------------------------------------------------------------
(ii)JRE:
sh
=>JRE stands for 'Java Runtime Environment' and which is having JavaLib and
JVM.
ate
=>JRE is internal partition of JDK.

nk
Diagram:
Ve
PAGE:10
ii
ip ath
Ma
================================================================
*imp
Installing Java S/w and Setting path:

sh
step-1 : Download JDK from Oracle WebSite,based on PlatForm(OS)
ate
step-2 : Install JDK(Java s/w)

nk
Note:
=>After Installation process is successfull,then we can find the folder with

Ve
name 'java' in program files.
C:\Program Files\Java\jdk-17.0.3.1
step-3 : Set JavaPath in 'Environment variables'
PAGE:11
RightClick on MyComputer->Properties->Advanced System Settings->
Environment Variables->click 'new' from 'System Variables'
Variable name : path
ii
Variable value : C:\Program Files\Java\jdk-17.0.3.1\bin;
ip ath
step-4 : Click 'ok' for three times
Ma
=================================================================
Dt : 18/6/2022
*imp
sh
Writing,Saving,Compiling and Executing Java Program:
*imp
ate
define 'class'?
=>'class' is a Structured Layout generating objects.

nk
=>'class' in Java can hold Variables,methods(functions) and main()
Variables - data holders

Ve
Methods - Actions
main() - Starting point of program execution
=>we use 'class' keyword in Java to declare classes
structure of 'class' in Java:
PAGE:12
class Class_name
//variables
//methods
//main()
ii
}
ath
Note:
ip
=>main() in Java will have the following Pre-defined Built-in format:
public static void main(String[] args)

Ma
==================================================================
Ex_Program-1:
sh
wap to display the msg as "Welcome to Java"?
ate
class Display
{
nk
{
Ve
System.out.print("Welcome to Java");
================================================================
step-1 : create one folder in any drive
PAGE:13
E:\Demo134
step-2 : Open notepad and type the program
step-3 : Save the program in folder(Destination folder)
ii
Click on File->Save->Browse the Folder->name the file(Display.java)->Click 'save'.
ath
Note:
ip
=>Open CommandPrompt to perform Compilation and execution process.
Ma
=>To open CommandPrompt,goto destination folder->type 'cmd' in Address bar and
press 'enter'.
sh
step-4 : Compile the program as follows
syntax:
ate
javac Class_name.java
Ex:
nk
javac Display.java
Ve
step-5 : Execute the program as follows
syntax:
java Class_name
Ex:
java Display
PAGE:14
=======================================================================
*imp
JVM Architecture with Internals:
=>JVM Stands for 'Java Virtual Machine' and which is used to execute
Java ByteCode
ii
=>JVM internally having the following partitions:
ath
(i)Class Loader SubSystem
(ii)Runtime Data Area
ip
(iii)Execution Engine
Diagram:
Ma
sh
ate
nk
Ve
PAGE:15
ii
ip ath
Ma
sh
ate
------------------------------------------------------------
Dt : 20/6/2022
nk
(i)Class Loader SubSystem:
=>Class Loader SubSystem will load Java ByteCode onto Runtime Data Area using
Ve
Loader.
(ii)Runtime Data Area:
=>This Runtime Data Area divided into the following partitions:
(a)Method Area
PAGE:16
(b)Heap Area
(c)Java Stack Area
(d)PC Register Area
(e)Native Method Area
(a)Method Area:
ii
=>The memory block where the class is loaded is known as Method Area.
ath
=>while class loading the static components of class will get the memory
within the class.
ip
=>In this process the main() method will get the memory within the class and
Ma
which is automatically copied onto JavaStackArea to start the execution process.
(b)Heap Area:
sh
=>The memory location where the objects are created is known as HeapArea.
=>while object creation the NonStatic components of class will get the
ate
memory within the object.

nk
(c)Java Stack Area:
=>The memory block where the methods are executed is known as Java Stack Area.
Ve
=>main() is the first method copied onto JavaStack area to start execution
process and this main() method will call remaining methods for execution.
faq:
define Method Frame?
PAGE:17
=>The partition of JavaStackArea where method is copied for execution is known
as Method Frame.
(d)PC Register Area:
=>Program Counter(PC) register will record the status of method execution in
JavaStackArea.
ii
=>In this process every method executing in JavaStackArea will have its own
ath
PC-Register and all these PC-Registers are opened in a separate memory block
known as PC-Register Area.
ip
(e)Native Method Area:
Ma
=>The methods which are declared with 'native' keyword in JavaLib are known
as Native methods.
sh
=>These Native methods internally having c or c++ code.
=>These Native methods from the program are separated and loaded onto
ate
Separate memory block known as Native method Area.
=>ExecutionEngine will execute native methods using JNI(Java Native method

nk
Interface) and this JNI internallu uses Native method Libraries.

Ve
(iii)Execution Engine:
=>ExecutionEngine is a executor or processor of JVM and which starts the
execution process from main() available in JavaStackArea.
=>ExecutionEngine internally having the following two transaltors:
(i)Interpreter
PAGE:18
(ii)JIT(Just-In-Time)-Compiler
(i)Interpreter:
=>Interpreter will start the execution process and executes the nonmal
instructions in a program.(Non-Multimedia Instructions)
ii
=>when interpreter finds Stream instructions then the execution control is
ath
transferred to the JIT-Compiler.
ip
(ii)JIT(Just-In-Time)-Compiler:
Ma
=>JIT-Compiler will execute Stream instructions or Multimedia Instructions.
sh
ate
nk
============================================================================
Ve
Dt : 21/6/2022
faq:
why JavaLang use Interpreter in Execution process?
=>when we have Interpreter in execution process then we can accept the request
in the middle of execution process,which is preferable for Server application
PAGE:19
development.
Note:
=>When we have interpreter in execution process then we can call JavaLang as
'Interpreted Language'
========================================================================
ii
Summary:
ath
(i)Method Area where Classes are loaded
(ii)Heap Area where Objects are Created
ip
(iii)JavaStackArea where methods are executed(Execution Area)
Ma
============================================================================
Naming Conventions in Java:
=>The coding rules followed by the programmer in writing JavaPrograms are known
sh
as Naming Conventions in Java.
ate
(i)packages:
def : packages are collection 'Classes and Interfaces'

nk
rule : packages must in LowerCase

Ve
(ii)Classes and Interfaces:
def : Classes and Interfaces are collection of 'Variables and Methods'
rule : In Classes and Interfaces the starting letter must be Capital(UpperCase)
(iii)Variables and methods:
PAGE:20
def : Variables are the dataholders
Methods are the actions
rule : In Variables and Methods the firstWord must be LowerCase and from second
word onwards the starting letter must be capital.
Ex Variables:
ii
rollNo,panCardNo,phoneNo...
ath
Ex Methods :
getSalary(),readLine(),toUpperCase() ...
ip
(iv)keywords:
Ma
def : Built-in words or Pre-defined words are known as Keywords.
rule : Keywords must be in LowerCase.

sh
=======================================================================
*imp
ate
DataTypes in Java:
=>The types of data which we are expecting as input to JavaPrograms are known
nk
as DataTypes in Java.
=>DataTypes in Java are categorized into two types:

Ve
1.Primitive DataTypes
2.NonPrimitive DataTypes
1.Primitive DataTypes:
=>The 'single valued data formats' are known as Primitive DataTypes.
PAGE:21
=>These Primitive DataTypes are categorized into four types:
(a)Integer datatypes
(b)Float datatypes
(c)Character datatype
(d)Boolean datatype
ii
(a)Integer datatypes:
ath
=>The numeric data without decimal point representation is known as Integer
datatype.
ip
Ex:
12,345,567,...
=>Types:
Ma
(i)byte - 1 Byte(16 bits)
sh
(ii)short - 2 Bytes
(iii)int - 4 Bytes
ate
(iv)long - 8 Bytes
nk
(b)Float datatypes:
=>The numeric data with decimal point representation is known as Float

Ve
datatype
Ex:
12.34,67.23,...
=>Types:
(i)float - 4 Bytes
PAGE:22
(ii)double - 8 Bytes
(c)Character datatype:
=>The 'Single valued Character' which is represented in single quotes is known
as Character datatype.
Ex:
ii
'k','u','g',...
ath
=>Types:
char - 2 Bytes
ip
(d)Boolean datatype :
Ma
=>The datatype which is represented in the form of true or false is known as
Boolean datatype.
sh
=>Types:
boolean - 1 bit
ate
------------------------------------------------------------------------------
nk
*imp
2.NonPrimitive DataTypes:
Ve
=>The 'group valued data formats' are known as NonPrimitive DataTypes or
Referential datatypes
=>These NonPrimitive DataTypes are categorized into four types:
(a)Class
(b)Interface
PAGE:23
(c)Array
(d)Enum
==========================================================================
*imp
Object Oriented Programming:
=>The process of constructing applications using Class-Object concept is known
ii
as Object Oriented Programming.
ath
=>In Object Oriented Programming we control NonPrimitive datatypes,which means
we work with NonPrimitive data types.
ip
*imp
define 'Object'?
Ma
=>'Object' is a Storage related to a class holding NonStatic components of
sh
Class.
=>Objects are created part of HeapArea in JVM.

ate
=>we use 'new' keyword to create objects in Java.
syntax of Object creation:

nk
Class_name obj_name = new Class_name();
======================================================================
Ve
faq:
wt is the diff b/w
(i)static components
(ii)NonStatic components
PAGE:24
(i)static components:
=>The components which are declared with 'static' keyword are known as Static
components.
=>These static components will get the memory within the class while class
loading.
ii
(ii)NonStatic components:
ath
=>The components which are declared without 'static' keyword are known as
NonStatic components.
ip
=>These NonStatic components will get the memory within the object while
Object creation.
Ma
=========================================================================
Dt : 22/6/2022
sh
*imp
Variables in Java:
ate
=>Variables are the dataholders.
=>Based on DataTypes the variables are categorized into two types:

nk
(i)Primitive DataType variables
(ii)NonPrimitive DataType variables

Ve
(i)Primitive DataType variables :
=>The variables which are declared with primitive datatypes like byte,short,
int,long,float,double,char and boolean are known as Primitive DataType variables.
=>These primitive DataType variables will hold values.
PAGE:25
(ii)NonPrimitive DataType variables:
=>The variables which are declared with NonPrimitive datatypes like Class,
Interface,Array and Enum are known as NonPrimitive Datatype variables or
reference Variables.
=>These NonPrimitive DataType variables will hold 'object references'.
ii
====================================================================
ath
*imp
=>Based on 'static' keyword the variables in Java are categorized into two types:
ip
1.static Variables
2.NonStatic Variables
Ma
1.static Variables:
sh
=>The variables which are declared with static keyword outside the methods are
known as static variables or Class Variables.

ate
=>These Static variables will get the memory within the class while class
loading and can be accessed with class_name.

nk
Ex_Program : DemoVariables1.java
Ve
class DemoVariables1
static int a=10;//memory in class
public static void main(String[] args) //memory in class
PAGE:26
System.out.println("====main()====");
System.out.println("The value a:"+a);
Execution flow:
ii
ip ath
Ma
sh
ate
--------------------------------------------------------------------
*imp
nk
2.NonStatic Variables
=>The variables which are declared without static keyword are known as
Ve
NonStatic Variables.
=>These NonStatic variables are categorized into two types:
(a)Instance Variables
(b)Local Variables
PAGE:27
(a)Instance Variables:
=>The NonStatic variables which are declared outside the methods are known as
Instance Variables or Object Variables.
=>These Instance Variables will get the memory within the object while object
creation and can be accessed with Object_name.
ii
(b)Local Variables:
ath
=>The NonStatic variables which are declared inside the methods are known as
Local Variables or Method Variables.
ip
=>These Local Variables will get the memory within the Method_frame while
method execution.
Ma
Ex_Program : DemoVariables2.java
sh
class DemoVariables2
{
ate
int b=20;//Instance variable memory in Object

nk
static int c=30;//Local Variable memory in Method_frame

Ve
DemoVariables2 ob = new DemoVariables2();//Object Creation
System.out.println("====main()====");
System.out.println("The value b:"+ob.b);
System.out.println("The value c:"+c);
PAGE:28
}
Execution Flow:
ii
ip ath
Ma
=========================================================================
faq:
sh
define static Local Variables?
ate
=>There is no concept of Static local variables in Java.(Compilation Error)
faq:
nk
define Global Variables in Java?

Ve
=>There is no concept of Global Variables in Java,because the variables
memories are in Classes or Objects or Method Frames.
================================================================
*imp
Methods in Java:
=>Methods are the actions which are performed to generate results.
PAGE:29
=>Based on Static Keyword the methods are categorized into two types:
1.Static methods
2.NonStatic methods or Instance methods
1.Static methods:
=>The methods which are declared with static keyword are known as static
ii
methods or Class methods.
ath
=>These static methods will get the memory within the class while class loading
and can be accessed with Class_name.
ip
structure of static methods:
static return_type method_name(Para_list)
{
Ma
//method_body
sh
}
Rule:
ate
=>Static methods can access static variables directly,but cannot access instance
variables.
nk
Types of static methods:

Ve
=>Static methods are categorized into two types:
(i)Built-in static methods
(ii)User defined static methods
(i)Built-in static methods:
PAGE:30
=>The static methods which are already available from JavaLib are known as
Built-in static methods or Pre-defined Static methods.
(ii)User defined static methods:
=>The static methods which are defined by the user are known as User defined
static method.
ii
-----------------------------------------------------------------------
ath
2.NonStatic methods or Instance methods:
=>The methods which are declared without static keyword are known as NonStatic
ip
methods or Instance methods.
Ma
=>These Instance methods will get the memory within the object while object
creation and can be accessed with Object_name.
structure of Instance methods:

sh
return_type method_nam(para_list)
{
ate
//method_body
}
nk
Rule:
=>Instance methods can access both variables,Instance variables and Static

Ve
Variables.
Types of Instance methods:
=>Instance methods are categorized into two types:
(i)Built-in Instance methods
PAGE:31
(ii)User defined Instance methods
(i)Built-in Instance methods:
=>The instance methods which are already available from JavaLib are known as
Built-in Instance methods or Pre-defined Instance methods.
ii
(ii)User defined Instance methods:
ath
=>The instance methods which are defined the user are known as User defined
Instance methods.
ip
========================================================================
Assignment:
Ma
Construct the program from the following Layout:
sh
Dt : 23/6/2022
ate
Program : DemoMethods1.java
class DemoMethods1
nk
int a=10;//Instance variable memory in Object

Ve
static int b=20;//Static Variable memory in Class
void m1()//Instance method memory in Object
System.out.println("====Instance method m1()=====");
PAGE:32
System.out.println("The value b:"+b);
static void m2()//Static method memory in Class
System.out.println("====static method m2()=====");
//System.out.println("The value a:"+a);
ii
ath
}
public static void main(String[] args)//memory in Class
ip
{
Ma
DemoMethods1 ob = new DemoMethods1();//Object Creation
ob.m1();//Instance method_call
DemoMethods1.m2();//Static method_call
sh
}
}
ate
Execution flow:
nk
Ve
PAGE:33
ii
ip ath
============================================================================
faq:
define parameters?
Ma
=>parameters are the variables which are used to transfer the data from one
sh
method to another method.
=>Based on parameters the methods are categorized into two types:

ate
(i)Methods without parameters
(ii)Methods with parameters

nk
(i)Methods without parameters:

Ve
=>The methods which are declared without parameters are known as 0-parameter
methods or Methods without parameters.
(ii)Methods with parameters:
=>The methods which are declared with parameters are known as Parameterized
PAGE:34
methods or Methods with parameters.
faq:
define return_type?
=>return_type specify the methods will return the value after method execution
ii
or not.
ath
=>Based on return_type methods are categorized into two types:
(i)Non-Return_type methods
ip
(ii)Return_type methods
(i)Non-Return_type methods:
Ma
=>The methods which will not return the value after method execution are known
sh
as Non-Return_type methods.
=>The methods which are declared with 'void' are known as Non-Return_type
ate
methods.
nk
(ii)Return_type methods:
=>The methods which will return the value after method execution are known as
Ve
Return_type methods.
=>The methods which are declared without 'void' are known as Return_type
methods,which means 'void' replaced with datatype.
=>we use 'return' statement to return the value after method execution.
=>The returned value will come back to the method_call.
PAGE:35
==================================================================
*imp
Types of Classes:
=>In Java the classes are categorized into types:
(a)User defined classes
(b)Built-in classes or Pre-Defined classes
ii
ath
(a)User defined classes:
=>The classes which are defined by the programmer are known as User defined
ip
classes.
Ex:
Display
Ma
DemoVariable1
sh
...
(b)Built-in classes or Pre-Defined classes:

ate
=>The classes which are already constructed and available from JavaLib are
known as Built-In classes or Pre-Defined Classes.

nk
Ex:
System
Ve
String
Scannner
...
=========================================================================
*imp
PAGE:36
Reading input to Java Programs:
=>we use the following Built-in methods from 'java.util.Scanner' class to
read data into JavaPrograms:
1.nextByte()
2.nextShort()
3.nextInt()
ii
4.nextLong()
ath
5.nextFloat()
6.nextDouble()
ip
7.nextBoolean()
8.nextLine()
Ma
=>These methods are NonStatic methods and will get the memory within the
Scanner Class object.

sh
syntax of Object creation for 'Scanner' class:
Scanner s = new Scanner(System.in);

ate
=>'System.in' represent connecting OS-Buffer to 'Scanner' class Object.

nk
Syntax of Scanner class methods:

Ve
public byte nextByte();
syntax:
byte b = s.nextByte();
public short nextShort();
PAGE:37
syntax:
short v = s.nextShort();
public int nextInt();
syntax:
int i = s.nextInt();
ii
ath
public long nextLong();
syntax:
ip
long l = s.nextLong();
public float nextFloat();

Ma
syntax:
sh
float f = s.nextFloat();
ate
public double nextDouble();
syntax:
nk
double d = s.nextDouble();
Ve
public boolean nextBoolean();
syntax:
boolean b = s.nextBoolean();
public String nextLine();
PAGE:38
syntax:
String str = s.nextLine();
----------------------------------------------------------------
Ex_Program:
wap to read and display user details like name,mailId and phNo?
ii
Program : DemoMethods2.java
ath
import java.util.Scanner;
class DemoMethods2
ip
{
{
Ma
sh
System.out.println("Enter the Name:");
String name = s.nextLine();

ate
System.out.println("Enter the MainId:");
String mailId = s.nextLine();

nk
System.out.println("Enter the PhNo:");
long phNo = s.nextLong();

Ve
System.out.println("====UserDetails===");
System.out.println("Name="+name);
System.out.println("MailId="+mailId);
System.out.println("PhoneNo="+phNo);
PAGE:39
}
==================================================================
ii
ip ath
Ma
sh
ate
nk
Ve
PAGE:40
Dt : 24/6/2022
Execution flow:
ClassFiles:
DemoMethods2.class
Scanner.class(Built-in class)
ii
ip ath
Ma
sh
ate
nk
Ve
================================================================
Note:
=>If we read String data after reading numeric data,the String data will be
Skipped in reading.
PAGE:41
=>This can be overcomed using the following parse methods:
byte b = Byte.parseByte(s.nextLine());
short sh = Short.parseShort(s.nextLine());
int i = Integer.parseInt(s.nextLine());
long l = Long.parseLong(s.nextLine());
float f = Float.parseFloat(s.nextLine());
ii
double d = Double.parseDouble(s.nextLine());
ath
===============================================================
Note:
ip
=>In the process of Constructing JavaApplications we must be SubClasses and
one MainClass.
Ma
SubClass - Other than MainClass and holding Variables and methods
MainClass - Class in application holding main() method is known as MainClass

sh
================================================================
Ex_Program : Wap to read two integer values and perform arithmetic operation
ate
based on User choice?
nk
class Addition
{
Ve
int add(int x,int y)
return x+y;
PAGE:42
class Subtraction
int sub(int x,int y)
return x-y;
ii
}
ath
class Multiplication
ip
int mul(int x,int y)
return x*y;
Ma
}
sh
}
class Division
ate
float div(int x,int y)

nk
return (float)x/y;//TypeCasting
Ve
class ModDivision
int modDiv(int x,int y)
PAGE:43
{
return x%y;
class DemoMethods3 //MainClass
ii
ath
{
ip
System.out.println("Enter the Interger value1:");
int v1 = s.nextInt();
Ma
System.out.println("Enter the Interger value2:");
sh
System.out.println("====Choice====");
System.out.println("1.add\n2.sub\n3.mul\n4.div\n5.modDiv");
ate
System.out.println("Enter the Choice:");
int choice = s.nextInt();

nk
switch(choice)
{
Ve
case 1:
Addition ad = new Addition();
int r1 = ad.add(v1,v2);
System.out.println("Sum:"+r1);
break;
PAGE:44
case 2:
Subtraction sb = new Subtraction();
int r2 = sb.sub(v1,v2);
System.out.println("Sub:"+r2);
break;
case 3:
ii
Multiplication ml = new Multiplication();
ath
int r3 = ml.mul(v1,v2);
System.out.println("Mul:"+r3);
ip
break;
case 4:
Ma
Division dv = new Division();
float r4 = dv.div(v1,v2);
sh
System.out.println("Div:"+r4);
break;
ate
case 5:
ModDivision md = new ModDivision();

nk
int r5 = md.modDiv(v1,v2);
System.out.println("ModDiv:"+r5);
Ve
break;
default:
System.out.println("Invalid Choice...");
}//end of switch
PAGE:45
}
===========================================================================
Assignment:
wap to read two integer values and perforn the following operations based on
User Choice:
1.Greater
ii
2.Smaller
ath
SubClasses : Greater,Smaller
ip
MainClass : DemoMethods4
Ma
==================================================================
Note:
=>Construct the execution flows for above two programs

sh
========================================================================
ate
nk
Ve
PAGE:46
Dt : 25/6/2022
Execution flow of above program(Arithmetic Operations)
ClassFiles:
Addition.class
Subtraction.class
Multiplication.class
ii
Division.class
ath
ModDivision.class
DemoMethods3.class(MainClass)
ip
Ma
sh
ate
nk
Ve
=====================================================================
faq:
define switch-case?
=>switch-case is a Selection statement and which is used to select one from
PAGE:47
multiple available options or cases.
syntax:
switch(value)
case 1 : statements;
break;
ii
case 2 : statements;
ath
break;
ip
.
case n : statements;
break;
Ma
default : statements;
sh
}
ate
Behaviour:
=>switch-value is compared with available options or cases,when the switch-value

nk
is matched with any available option then the statements are executed.
=>After executing the statements we use 'break' to stop the switch-case

Ve
execution.
=>when the switch-value is not matched with any available options or cases then
the default is executed.
=======================================================================
Assignment-1 :
PAGE:48
wap to read employee basic Sal and calaculate totSal?
totSal = bSal+HRA+DA;
HRA = 93% of bSal
DA = 63% of bSal
ii
Note:
ath
=>bSal must be min 12000/-
ip
SubClass : EmployeeSalary
=>double calTotSal(bSal)
Ma
MainClass : DemoMethods5
sh
====================================================================
Assignment-2:
ate
wap to read six subject marks and Calculate totMarks,percentage and result.
nk
result :
per => 70 to 100 destinction

Ve
per => 60 to <70 FirstClass
per => 50 to <60 SecondClass
per => 35 to <50 ThirdClass
=>Else, Fail
PAGE:49
SubClass : StudentResult
=>String calculate(per)
Note:
=>If all the Sub marks are in b/w 0 to 100,then calculate totMarks,percentage
result.
ii
======================================================================
ip ath
Ma
sh
ate
nk
Ve
PAGE:50
Dt : 29/6/2022
Packages in Java:
=>package is a collection of 'Classes and Interfaces'
=>packages in Java are categorized into two types:
1.Built-in packages
2.User defined packages
ii
ath
1.Built-in packages:
=>The packages which are already constructed and available from JavaLib are
ip
known as Pre-defined packages or Built-in packages.
java.lang
Ma
=>The following are some important Built-in packages related to CoreJava:
- Language package(default package)
java.io - Input Output Streams and Files package

sh
java.util - Utility package
java.net - Networking package

ate
*imp
nk
2.User defined packages:
=>The packages which are defined by the programmer are known as User defined
Ve
packages or Custom Packages
=>we use 'package' keyword to define User defined packages.
syntax:
package package_name;
=========================================================================
PAGE:51
*imp
Creating Java Project using IDE Eclipse:(IDE - Integrated Development Environent)
step-1 : Open IDE Eclipse,while opening name the workspace and click 'launch'
step-2 : Create Java Project
Click on File->new->Project->Java->selcet 'Java Project' and click next->
name the project and click 'finish'.
ii
step-3 : Create packages in 'src'
ath
Right Click on 'src'->new->package,name the package and click 'finish'
ip
step-4 : Create classes in packages
Ma
RightClick on package->new->Class,name the class and click 'finish'
step-5 : Open MainClass and execute the program.

sh
ate
nk
Ve
PAGE:52
ii
ip ath
Ma
Ex:
sh
EmployeeSalary.java
package test;
ate
public class EmployeeSalary {

public double calTotSal(int bSal) {
double totSal = bSal+(0.93*bSal)+(0.63*bSal);
return totSal;
}
nk
}
Ve
DemoMethods5.java(MainClass)
package maccess;
import test.EmployeeSalary;
public class DemoMethods5 {
public static void main(String[] args) {
PAGE:53
System.out.println("Enter the bSal:");
int bS = s.nextInt();
if(bS>=12000)
EmployeeSalary es = new EmployeeSalary();
ii
double totSal = es.calTotSal(bS);//Method_call
ath
System.out.println("BSal:"+bS);
System.out.println("TotSal:"+totSal);
ip
}//end of if
else
{
Ma
System.out.println("Invalid bSal...");
sh
}
s.close();
ate
}
nk
=====================================================================
Ex:
Ve
StudentResult.java
package test;
public class StudentResult {
public String calculate(float per) {
if(per>=70 && per<=100) {
return "Distiction";
}
else if(per>=60 && per<70) {
return "FirstClass";
PAGE:54
}
return "SecondClass";
}
return "ThirdClass";
}
else {
return "Fail";
}
}
ii
}
ath
DemoMethods5.java(MainClass)
package maccess;
ip
import test.StudentResult;
public class DemoMethods6 {

Ma
sh
int i=1,totMarks=0;
ate
while(i<=6)
{
nk
System.out.println("Enter the marks of Subject"+i);
int sub = s.nextInt();

Ve
if(sub<0 || sub>100)
System.out.println("Invalid Marks...");
continue;//skip the below lines from the loop
PAGE:55
totMarks=totMarks+sub;
i++;
}//end of loop
System.out.println("Total Marks:"+totMarks);
float per = (float)totMarks/6;
System.out.println("Per:"+per);
ii
StudentResult sr = new StudentResult();
ath
String result = sr.calculate(per);//MethodCall
System.out.println("Result:"+result);
ip
s.close();
}
}
Ma
======================================================================
sh
ate
nk
Ve
PAGE:56
Dt : 30/6/2022
faq:
define 'import' statement?
=>'import' statement is used to make class or interface available from one
package to another package
=>This importing process in java can be done in three ways:
ii
ath
(i)Using 'import package_name.CName/IName; '
(ii)Using 'import package_name.*; '
(iii)Using 'Fully qualified names'
ip
(i)Using 'import package_name.CName/IName; '
Ma
=>In this importing process we specify the CName or IName to make aavailable
to current running program.

sh
=>This importing process is also known 'Explicit importing process'.
Ex:
ate
nk
(ii)Using 'import package_name.*; '

Ve
=>In this importing process all the classes and interfaces from the package
are available to current running program.
=>This importing process is also known as 'Implicit importing process'.
Ex:
import java.util.*;
PAGE:57
import test.*;
(iii)Using 'Fully qualified names':
=>The process of declaring classes and interfaces with package_names part of
programming code are known as 'Fully qualified names'
ii
ath
Ex:
java.util.Scanner s = new java.util.Scanner(System.in);
test.EmployeeSalary es = new test.EmployeeSalary();
ip
============================================================
Ma
faq:
define 'static' import?
=>The process of declaring the 'import' statement with 'static' keyword is

sh
known as 'static import' and which is introduced by Java5 version.
syntax:
ate
import static package_name.CName/IName.*;
Ex:
nk
import static java.lang.Math.*;

Ve
Advantage:
=>when we use 'static import',then the static members of class or Interface
can be accessed directly without Class_name or Interface_name
=============================================================================
faq:
PAGE:58
define sqrt() method?
=>sqrt() is Built-in static method from java.lang.Math class and which is used
to find the sqrt of given number.
Method Signature:
public static double sqrt(double);
ii
ip ath
Ma
sh
ate
nk
syntax:
double result = Math.sqrt(value);

Ve
Ex:
DemoStaticImport.java(MainClass)
package maccess;
PAGE:59
import static java.lang.Math.*;
public class DemoStaticImport {
public static void main(String[]
args) {
Scanner s = new
Scanner(System.in);
System.out.println("Enter the
ii
value:");
ath
double val = s.nextDouble();
double result =
sqrt(val);//method_call
ip
System.out.println("SQRT of Ma
"+val+" is "+result);
s.close();
}
}
sh
ate
o/p:
Enter the value:
123
nk
SQRT of 123.0 is 11.090536506409418
=========================================================================
Ve
faq:
define Access Modifiers?
=>Access Modifiers specify the scope of programming components in Project
folder.(Java project)
=>The following are some important access modifiers in Java:
PAGE:60
(a)public
(b)private
(c)protected
(d)default
(a)public:
ii
=>'public' programming components are accessed within the Project.
ath
(b)private:
=>'private' programming components are accessed only within the class.
ip
(c)protected:
Ma
=>'protected' programming components are accessed within the package.
Note:
sh
=>'protected' programming components can be accessed by the ChildClass
declared outside the package.

ate
(d)default:
nk
=>The programming components which are declared without any access modifiers
in Class are considered as 'default programming components'.

Ve
=>The default programming components are accessed only within the package.
Diagram:
PAGE:61
ii
ip ath
Note:
Ma
=>we must not use 'default' keyword in Class to declare programming components.
(compilation Error)
sh
=======================================================================
ate
*imp
Blocks in Java:
=>The set-of-statements which are declared within the flower brackets and
nk
executed automatically is known as 'block'.

Ve
=>Blocks in Java are categorized into two types:
1.Static blocks
2.Non-Static blocks(Instance blocks)
PAGE:62
Dt : 1/7/2022
1.Static blocks:
=>The blocks which are declared with static keyword are known as
static blocks.
syntax:
static
ii
{
ath
//statements;
ip
Behaviour:
Ma
=>The static block is executed only once when the class is used
for first time.(Static block is executed only once while class

sh
loading)
ate
Note:
=>static blocks are used in DAO(Data Access Object) Layer of MVC

nk
(Model View Controller) to hold DataBase Connection codes.

Ve
Ex :
STest.java
package test;
public class STest {
public static int z=30;
static {
System.out.println("====SubClass Static block====");
System.out.println("The value z:"+z);
PAGE:63
}
}
DemoStaticBlock.java(MainClass)
package maccess;
import test.STest;
public class DemoStaticBlock {
public static int k=10;
STest.z=200;//Using STest for first time
ii
STest.z=400;//Using STest for Second time
ath
System.out.println("===main()====");
System.out.println("The value k:"+k);
}
static {
System.out.println("====MainClass Static block====");
ip
} Ma
}
o/p:
====MainClass Static block====

sh
The value k:10
ate
====SubClass Static block====
The value z:30

nk
===main()====
The value k:10

Ve
-----------------------------------------------------
2.Non-Static blocks(Instance blocks):
=>The blocks which are declared without static keyword are known
as NonStatic blocks or Instance blocks.
syntax:
PAGE:64
{
//statements;
Behaviour:
ii
=>Instance block is executed automatically while Object creation.
ath
=>Instance block is executed for all the multiple object creations.
ip
Ex:
ITest.java
package test;
Ma
public class ITest {
public static int a=20;
public int b=30;
sh
{
System.out.println("====SubClass Instance block====");
ate

}
}
nk
DemoInstanceBlock.java(MainClass)
Ve
package maccess;
import test.ITest;
public class DemoInstanceBlock {
public static int z=10;
ITest.a=200;//Using ITest for first time
ITest ob1 = new ITest();//Object1
ITest ob2 = new ITest();//Object2
System.out.println("===main()====");
PAGE:65
}
}
o/p:
====SubClass Instance block====
The value a:200
The value b:30
ii
====SubClass Instance block====
ath
The value a:200
The value b:30
ip
===main()====
The value z:10

Ma
=========================================================
Execution flow above program:

sh
ClassFiles:
ITest.class
ate
DemoInstanceBlock.class(MainClass)
nk
Ve
PAGE:66
ii
ip ath
Ma
======================================================
Note:
=>Class in Java can generate any number of Objects without

sh
restriction and the multiple objects are independent by their
ate
memory location on HeapArea.
==========================================================
Assignment:
nk
Construct the SourceCode for the following layout:

Ve
Layout Diagram:
PAGE:67
ii
ip ath
Ma
==========================================================
sh
Note:
=>Static block is also known as Static initializer which means

ate
using static block we can initialize static variables while class
loading.
nk
=============================================================
faq:
Ve
wt is the diff b/w
(i)block
(ii)method
=>Blocks are executed automatically,but methods are executed on
method call.
PAGE:68
=>Blocks will have highest priority in execution than methods.
Static block will have highest priority than static method
Instance block will have highest priority than Instance method.
=============================================================
*imp
Constructors in Java:
ii
=>Constructor is a method having the same name of the class and
ath
executed while object creation,because the constructor call is
available in Object creation syntax attached with 'new' keyword.
ip
Note:
Ma
=>while declaring constructors we must not use return_type,because
the constructors will have class_return_type.

sh
structure of Constructor:
Class_name(para_list)
ate
//method_body
nk
}
Ve
=>Based on parameters the Constructors are categorized into
two types:
1.Constructors without parameters
2.Constructors with parameters
PAGE:69
Ve
nk
ate
sh
PAGE:70
Ma
ip ath
ii
Dt : 2/7/2022
1.Constructors without parameters:
=>The constructors which are declared without parameters are known as
0-parameter constructors or Constructors without parameters.
Ex_Program:
ii
CTest1.java
ath
package test;
public class CTest1 {
static
{
ip
System.out.println("====Static block====");
} Ma
{
System.out.println("====Instance block====");
}
public CTest1()//Constructor
{
sh
System.out.println("====CTest1()====");
}
public void dis()//Instance method
ate
{
System.out.println("====dis()=====");
}
}
nk
DemonCon1.java(MainClass)
Ve
package maccess;
import test.CTest1;
public class DemoCon1 {
CTest1 ob = new CTest1();//Con_Call
ob.dis();//method_call
}
}
PAGE:71
o/p:
====Static block====
====Instance block====
====CTest1()====
====dis()=====
ii
==================================================================
ath
faq:
wt is the diff b/w
ip
(i)Constructor
(ii)Instance method
Ma
=>Constructor is executed while Object creation process,but Instance method
sh
is executed after Object creation.
ate
faq:
wt is the diff b/w

nk
(i)Instance block
(ii)Constructor
Ve
=>Both components are executed while Object Creation,but Instance block
will have highest priority in execution than constructor.
faq:
wt is the diff b/w
PAGE:72
(i)static block
(ii)Constructor
=>static block is executed only once when the class is used for first time.
=>Constructor is executed only once while object creation
==============================================================
ii
faq:
ath
define default Constructor?
=>The constructor without parameters which is added by the compiler at
ip
compilation stage is known as 'default constructor'.
faq:
Ma
In wt situation default constructor is added?
sh
=>The class which is declared without any constructors then it is added
with default constructor.

ate
====================================================================
Note:
nk
=>If the constructor is declared with return_type then it is considered as
Normal method.
Ve
=====================================================================
*imp
2.Constructors with parameters:
=>The Constructors which are declared with parameters are known as
Parameterized Constructors or Constructors with parameters.
PAGE:73
=>we pass parameters to constructors while Con_Call,which means while
Object creation.
Ex:
CTest2.java
package test;
ii
public CTest2(int x)//Con_with_parameters
ath
{
System.out.println("====CTest2(x)====");
System.out.println("The value x:"+x);
}
public void dis(int y)//Instance_method_with_parameters
ip
{
System.out.println("====dis(y)====");
Ma
System.out.println("The value y:"+y);
}
}
DemoCon2.java(MainClass)
sh
package maccess;
import test.CTest2;
ate

CTest2 ob = new CTest2(121);//Con_Call
ob.dis(123);//method_call
}
nk
}
Ve
o/p:
====CTest2(x)====
The value x:121
====dis(y)====
The value y:123
PAGE:74
=================================================================
Note:
=>The class in Java can be declared with any number of Constructors,but
only one constructor is called while object creation.
Ex:
ii
CTest3.java
ath
package test;
public CTest3() {
System.out.println("====0_para_Con====");
ip
}
public CTest3(int x) { Ma
System.out.println("====CTest3(x)====");
}
public CTest3(int y,int z) {
System.out.println("====CTest3(y,z)====");
sh
}
}
ate
package maccess;
nk
import test.CTest3;
Ve
CTest3 ob1 = new CTest3();//0_Para_Con_call

CTest3 ob2 = new CTest3(12);//1_para_Con_Call
CTest3 ob3 = new CTest3(12,34);//2_para_con_Call
}
}
o/p:
====0_para_Con====
PAGE:75
====CTest3(x)====
The value x:12
====CTest3(y,z)====
The value y:12
The value z:34
=====================================================================
ii
Advantage of Constructors:
ath
=>Constructors are used to initialize instance variables while Object
creation and which saves the execution time and generate HighPerformance
ip
of an application.
Ma
================================================================
*imp
Loading the data to Object:

sh
=>Loading the data to Object can be done in three ways:
(a)using Object name

ate
(b)Using Setter methods
(c)Using Constructors
nk
(a)using Object name:

Ve
=>we can use Object reference variable or Object name to load the data
to the Objects.
Ex:
Product.java
PAGE:76
package test;
public class Product {
public String pCode,pName;
public float pPrice;
public int pQty;
}
Display.java
package test;
public class Display {
ii
public void dis(Product p) {
ath
System.out.println("====ProductDetails====");
System.out.println("ProdCode:"+p.pCode);
System.out.println("ProdName:"+p.pName);
System.out.println("ProdPrice:"+p.pPrice);
System.out.println("ProdQty:"+p.pQty);
ip
} Ma
}
package maccess;
sh
ate
import test.Product;
import test.Display;
nk

Ve
Product p = new Product();//Object
System.out.println("Enter the ProdCode:");
p.pCode = s.nextLine();
System.out.println("Enter the ProdName:");
PAGE:77
p.pName = s.nextLine();
System.out.println("Enter the ProdPrice:");
p.pPrice = s.nextFloat();
System.out.println("Enter the ProdQty:");
p.pQty = s.nextInt();
Display d = new Display();//Object
ii
d.dis(p);//reference variable as parameter
ath
s.close();
ip
}
o/p:
Ma
Enter the ProdCode:
sh
A121
Enter the ProdName:

ate
Mouse
Enter the ProdPrice:

nk
1200
Enter the ProdQty:

Ve
12
====ProductDetails====
ProdCode:A121
ProdName:Mouse
ProdPrice:1200.0
PAGE:78
ProdQty:12
ii
ath
=============================================================
Assignment:
ip
wap to read and display User details?
(uname,pword,fname,lname,addr,maid,phNo)
Ma
Note:
=>Construct pattern like above program.

sh
===========================================================
ate
nk
Ve
PAGE:79
Dt : 4/7/2022
(b)Using Setter methods:
=>We can use 'Setter methods' to set the data to the objects
and we can also use 'Getter methods' to get the data from the
Objects.
ii
Rule:
ath
=>Every variable in class will have its own 'Setter method' and
'Getter method'.
ip
Ex:
UserDetails.java
Ma
package test;
public class UserDetails {
sh
public String uName,mailId;
public long phNo;
//uName,mailId,phNo are Instance variable memory in Object
ate
public String getuName() {

return uName;
}
public void setuName(String uName) {
//uName is local variable memory in method
nk
frame
this.uName = uName;
}
Ve
public String getMailId() {

return mailId;
}
public void setMailId(String mailId) {
//mailId is local variable memory in method frame
this.mailId = mailId;
}
public long getPhNo() {
return phNo;
}
PAGE:80
public void setPhNo(long phNo) {
//phNo is local variable memory in method frame
this.phNo = phNo;
}
Display2.java
package test;
public class Display2 {
ii
public void dis(UserDetails ud) {
ath
System.out.println("===Display UserDetails====");
System.out.println("UserName:"+ud.getuName());
System.out.println("MailId:"+ud.getMailId());
System.out.println("PhoneNo:"+ud.getPhNo());
}
ip
}
Ma
package maccess;
sh
import test.UserDetails;
ate
import test.Display2;

nk

Ve
UserDetails ud = new UserDetails();//Object
System.out.println("Enter the UserName:");
ud.setuName(s.nextLine());
System.out.println("Enter the MailId:");
ud.setMailId(s.nextLine());
PAGE:81
ud.setPhNo(s.nextLong());
Display2 d = new Display2();
d.dis(ud);//reference variable as parameter
s.close();
ii
}
ath
o/p:
Enter the UserName:
ip
nit.v
Enter the MailId:
v@gmail.com
Ma
Enter the PhNo:
sh
9898981234
===Display UserDetails====
ate
UserName:nit.v
MailId:v@gmail.com
nk
PhoneNo:9898981234
------------------------------------------------------
Ve
*imp
define 'this' keyword?
=>'this' keyword in java represents object,which meams 'this'
keyword holding the reference of object.
Note:
PAGE:82
=>In the process of loading data from Local Variables to
Instance variables and if we have same variable names then we
use 'this' keyword.
============================================
Assignment:
wap to read and display User details?
ii
(uname,pword,fname,lname,addr,maid,phNo)
ath
Note:
=>Use setter methods and Getter methods
ip
===========================================================
faq:
define Setter methods?

Ma
=>The methods which are used to set the data to the objects
sh
are known as 'Setter methods'
ate
faq:
define Getter methods?

nk
=>The methods which are used to get the data from the Objects
are known as 'Getter methods'.

Ve
==========================================================
(c)Using Constructors:
=>Constructors are used to initialize instance variables while
Object creation process.
Ex:
PAGE:83
BookDetails.java
package test;
public class BookDetails {
public String bCode,bName,bAuthor;
public float bPrice;
public int bQty;
//bCode,bName,bAuthor,bPrice,bQty are Instance variables
public BookDetails(String bCode,String bName,String bAuthor,
float bPrice,int bQty)
{
this.bCode=bCode;
ii
this.bName=bName;
ath
this.bAuthor=bAuthor;
this.bPrice=bPrice;
this.bQty=bQty;
}
public void getBookDeatils()
ip
{
System.out.println("====BookDetails====");
Ma
System.out.println("BCode:"+bCode);
System.out.println("BName:"+bName);
System.out.println("BAuthor:"+bAuthor);
System.out.println("BPrice:"+bPrice);
System.out.println("BQty:"+bQty);
sh
}
}
ate
Display3.java
package test;
nk
public class Display3 {

public void dis(BookDetails bd) {
bd.getBookDeatils();
}
Ve
package maccess;
import java.util.*;
import test.BookDetails;
PAGE:84
import test.Display3;
System.out.println("Enter the BookCode:");
String bC = s.nextLine();
ii
System.out.println("Enter the BookName:");
ath
String bN = s.nextLine();
System.out.println("Enter the BookAuthor:");
ip
String bA = s.nextLine();
Ma
System.out.println("Enter the BookPrice:");
float bP = s.nextFloat();
System.out.println("Enter the BookQty:");

sh
int bQ = s.nextInt();
BookDetails bd = new BookDetails(bC,bN,bA,bP,bQ);//Con_call

ate
Display3 d = new Display3();
d.dis(bd);//reference variable as parameter

nk
s.close();
}
Ve
o/p:
Enter the BookCode:
A121
Enter the BookName:
PAGE:85
C-Lang
Enter the BookAuthor:
B-Swamy
Enter the BookPrice:
1234.56
Enter the BookQty:
ii
12
ath
====BookDetails====
BCode:A121
ip
BName:C-Lang
BAuthor:B-Swamy
BPrice:1234.56
Ma
BQty:12
sh
========================================================
Assignmnet-1:
ate
wap to read and display Cutsormer details?
(accNo,custName,balance,accType,hNo,streetName,city,pinCode,
nk
mailId,phNo)
Ve
(i)using Object reference variable
(ii)Using Setter methods
(iii)Using Constructor
========================================================
PAGE:86
Dt : 5/7/2022
faq:
define 'static' Constructor in Java?
=>There is no concept of 'static' constructor in Java,because
Constructor means executed while object creation process and
cannot be Class_level.(Compilation Error)
ii
======================================================
ath
*imp
Strings in Java:
ip
=>The sequenced collection of characters which are represented
in double quotes is known as 'string'.
Ex:
Ma
"nit","hyd",...
sh
=>In strings the characters are organized based on index values
=>Strings in Java are not Arrays.

ate
=>The following classes from java.lang package are used to
create string objects:

nk
1.String class
2.StringBuffer class
Ve
3.StringBuilder class
1.String class:
=>'String' class is from java.lang package and which generate
'Immutable String objects'.(The objects once created cannot be
modified are known as Immutable Objects or Secured Objects or
PAGE:87
Constant objects)
=>we use the following two syntaxes to create 'String' objects:
syntax-1 : Using 'String Literal process'
Ex:
String s1 = "java";
ii
syntax-2 : using 'new operator process'
ath
Ex:
String s2 = new String("program");
ip
-------------------------------------------------------
Ex:
wap to read and display the String?

Ma
Program : DemoString1.java
sh
package maccess;
import java.util.*;
public class DemoString1 {
ate

System.out.println("Enter the String:");
int len = str.length();//to find length of String
nk
System.out.println("str:"+str);
System.out.println("length of str:"+len);
System.out.println("===Display Using index value===");
Ve
for(int i=0;i<=len-1;i++)
{
char ch = str.charAt(i);
System.out.print(ch);
}//end of loop
System.out.println
("\n====Display in reverse based on index value===");
for(int i=len-1;i>=0;i--)
{
PAGE:88
System.out.print(ch);
}//end of loop
int count=0;
{
switch(ch)
{
case 'a':
case 'A':count++;
break;
ii
case 'e':
case 'E':count++;
ath
break;
case 'i':
case 'I':count++;
break;
case 'o':
ip
case 'O':count++;
break; Ma
case 'u':
case 'U':count++;
break;
}//end of switch
}//end of loop
System.out.println("\n====Number of Vowels====");
sh
System.out.println("count:"+count);
s.close();
}
ate
o/p:
nk
Enter the String:
java program
Ve
str:java program
length of str:12
===Display Using index value===
java program
====Display in reverse based on index value===
PAGE:89
margorp avaj
====Number of Vowels====
count:4
----------------------------------------------------
Diagram:
ii
ip ath
Ma
sh
ate
nk
=====================================================
Ve
faq:
define charAt() method?
=>charAt() method is used to retrieve the character from the
String based on index value.
syntax:
char ch = str.charAt(index);
PAGE:90
faq:
define length() method?
=>length() method is used to find the length of given String.
syntax:
int len = str.length();
ii
ath
faq:
define toString() method?
ip
=>toString() method is used to display the data from the String
object.
syntax:
Ma
String data = str.toString();
sh
Note:
ate
=>toString() method is auto-executable method and which is
executed automatically when we display object ref variable.

nk
=============================================================
Assignment:
Ve
Wap to read a String and display the following:
Count of Vowels =
Count of Consonents =
Count of Numerics =
Sum of Numerics =
PAGE:91
Count of Others =
I/P :
str = "java17 by 2021 Sept is 99% LTS product"
Vowels =6
ii
Consonents = 16
ath
Numerics = 8
Sum = 31
ip
Others =8
Ma
===========================================================
sh
ate
nk
Ve
PAGE:92
Dt : 6/7/2022
faq:
define TypeCasting process?
=>The process of converting one datatype value into another
datatype value is known as TypeCasting process.
=>We use the following processes to perform TypeCasting
ii
process on Primitive DataTypes:
ath
1.Widening process
2.Narrowing process
ip
1.Widening process:
=>The process of converting Lower Datatypes into Higher

Ma
Datatypes is known as Widening process or UpCasting process.
sh
char->byte->short->int->long->float->double
ate
2.Narrowing process:
nk
=>The process of converting Higher Datatypes into Lower
Datatypes is known as Narrowing process or DownCasting process.

Ve
double->float->long->int->short->byte->char
-------------------------------------------------------
faq:
define ASCII?
PAGE:93
=>ASCII stands for 'American Standard Code for Information
Interchange',and which is generated for every character entered
from the Keyboard.(Every character will have its own ASCII code)
UpperCase Letters => 65 to 90
LowerCase Letters => 97 to 122
ii
Numbers (0-9) => 48 to 57
ath
Ex:
ip
ASCIIValues.java
package maccess;
public class ASCIIValues {
Ma
System.out.println("====UpperCase Letters====");
for(int i=65;i<=90;i++)
{
sh
char ch = (char)i;//DownCasting-Explicit TypeCasting
System.out.print(ch+" ");
}//end of loop
ate
System.out.println("\n====LowerCase Letters====");
for(int i=97;i<=122;i++)
{
nk
}//end of loop
System.out.println("\n====Numbers(0-9)====");
for(int i=48;i<=57;i++)
Ve
{
}//end of loop
}
}
o/p:
PAGE:94
====UpperCase Letters====
ABCDEFGHIJKLMNOPQRSTUVWXYZ
====LowerCase Letters====
abcdefghijklmnopqrstuvwxyz
====Numbers(0-9)====
0123456789
ii
==============================================
ath
Assignment:(Solution)
Wap to read a String and display the following:
ip
package maccess;
Ma
import java.util.*;
sh
ate
int len = str.length();

int c1=0,c2=0,count=0,sum=0;
{
char ch1 = str.charAt(i);
nk
switch(ch1)
{
case 'a':
Ve
case 'A':count++;
break;
case 'e':
case 'E':count++;
break;
case 'i':
case 'I':count++;
break;
case 'o':
case 'O':count++;
PAGE:95
break;
case 'u':
case 'U':count++;
break;
}//end of switch
int k = (int)ch1;//Generating ASCII Value
if((k>=65 && k<=90) || (k>=97&& k<=122))
{
c1++;
}//end of if
if(k>=48 && k<=57)//ASCII Values of Numbers
ii
{
c2++;
ath
char ch =(char)k;
String st = String.valueOf(ch);//Convert char to
String
int z = Integer.parseInt(st);//Convert String_to_int
sum=sum+z;
ip
}//end if
}//end of loop Ma
System.out.println("Count of Consonents:"+(c1-count));
System.out.println("Count of Vowels:"+count);
System.out.println("Count of Numbers:"+c2);
System.out.println("count of others:"+(len-(c1+c2)));
System.out.println("Sum of numbers:"+sum);
s.close();
sh
}
}
ate
o/p:
Enter the String:

nk
java17 by 2021 Sept is 99% LTS product
Count of Consonents:16
Ve
Count of Vowels:6
Count of Numbers:8
count of others:8
Sum of numbers:31
====================================================
PAGE:96
Assignment-1 :
wap to read a String and display number of words in the String?
i/p : "java is good programming language"
o/p : Number of words : 5
ii
ath
Assignment-2 :
wap to read a String and check the String is palindrome String
ip
or not?(without using Built-in method)
Ma
======================================================
define String Concatenation process?
=>The process of combining multiple Strings into a single

sh
String is known as Concatenation process.
=>In Java,we use the following to perform String Concatenation

ate
process:
(i)concat() method
nk
(ii)'+' symbol
Ve
package maccess;
String s1 = "java";
String s2 = "program";
String s3 = "language";
System.out.println("===Using concat() method===");
String s4 = s1.concat(s2);
PAGE:97
String s5 = s1.concat(s2).concat(s3);
System.out.println("s4:"+s4.toString());
System.out.println("===Using + symbol===");
String s6 = s1+s2;
String s7 = s1+s2+s3;
}
}
ii
ath
o/p:
===Using concat() method===
s4:javaprogram
ip
s5:javaprogramlanguage Ma
===Using + symbol===
s6:javaprogram
s7:javaprogramlanguage
sh
=========================================================
ate
Note:
=>In String Concatenation process separate object is created

nk
to hold concatenated Strings,because the String objects are
Immutable objects.
Ve
========================================================
define String Comparision process?
=>The process of comparing two strings is known as String
Comparision process.
=>String Comparision process can be done in three ways:
(i)Using 'equals()' method
PAGE:98
(ii)Using 'compareTo()' method
(iii)Using 'is equal to'(==) operator
ii
ip ath
Ma
sh
ate
nk
Ve
PAGE:99
Dt : 7/7/2022
(i)Using 'equals()' method:
=>'equals()' method will compare two Strings and generate
boolean result.
Method Signature:
public boolean equals(java.lang.Object);
ii
public boolean equalsIgnoreCase(java.lang.String);
ath
syntax:
ip
boolean k = s1.equals(s2);
Note:
Ma
=>In realtime equals() method is used in Authentication process.
sh
(User Identification process)
ate
*imp
(ii)Using 'compareTo()' method:

nk
=>compareTo() method also compares to Strings and generate
integer result.
Ve
Method Signature:
public int compareTo(java.lang.String);
public int compareToIgnoreCase(java.lang.String);
syntax:
PAGE:100
int z = s1.compareTo(s2);
if z==0 ,then Strings are equal
if z>0 ,then s1 greater than s2
if z<0 ,then s1 less than s2
ii
Note:
ath
=>In realtime compareTo() method is used in Sorting process.
ip
Ex : DemoString4.java
package maccess;
import java.util.*;
Ma
System.out.println("Enter the String1:");
sh
String s1 = s.nextLine().trim();
System.out.println("Enter the String2:");
String s2 = s.nextLine().trim();
ate
System.out.println("====equals()====");
boolean k = s1.equalsIgnoreCase(s2);
if(k) {
System.out.println("====Strings are Equal====");
}else {
nk
System.out.println("====Strings are Not-Equal===");

}
System.out.println("====compareTo()=====");
Ve
int z = s1.compareToIgnoreCase(s2);
if(z==0) {
System.out.println("====Strings are Equal====");
}else {
System.out.println("====Strings are Not-Equal====");
}
s.close();
}
}
PAGE:101
o/p:
Enter the String1:
java
Enter the String2:
java
====equals()====
ii
====Strings are Equal====
ath
====compareTo()=====
====Strings are Equal====
ip
==========================================================
Note:
Ma
=>trim() method is used to remove the spaces before and after
the String.
sh
=>IgnoreCase' specify compare the content without considering
the case.
ate
==========================================================
(iii)Using 'is equal to'(==) operator:

nk
=>'is equal to'(==) operator will compare the object
references when used on NonPrimitive datatype variables.

Ve
Ex : DemoString5.java
package maccess;
String s1 = "java";
String s2 = "java";
String s3 = new String("java");
PAGE:102
String s4 = new String("java");
System.out.println("===String Literal process====");
if(s1==s2) {
System.out.println("String are equal...");
}else {
System.out.println("Strings are Not-Equal..");
}
System.out.println("===new operator process===");
if(s3==s4) {
System.out.println("String are equal...");
}else {
ii
System.out.println("Strings are Not-Equal...");
}
ath
}
}
o/p:
ip
===String Literal process==== Ma
String are equal...
===new operator process===
Strings are Not-Equal...

sh
-----------------------------------------------------------
ate
faq:
define String Constant pool?

nk
=>The Separate partition of HeapArea where String objects are
created is known as String Constant Pool.

Ve
faq:
wt is the diff b/w 'String literal process' and 'new operator
process' in Creating Objects?
(i)In String Literal process,the ExecutionControl will check
PAGE:103
the 'String Constant pool',is any object having the same data
=>If available,then use the reference of existing object
without creating new object.
=>If not available,then create new object
(ii)In new operator process,one object is created directly
part of HeapArea,but the object will hold the reference of
ii
Object available in String Constant pool.
ath
=======================================================
Execution flow of above program:
ip
Ma
sh
ate
nk
Ve
========================================================
PAGE:104
Dt : 8/7/2022
2.StringBuffer class:
=>'StringBuffer' class is from java.lang package and which
generate 'Mutable String Objects'.
(The objects once created canbe modified are known as Mutable
Objects)
ii
=>The following are the constructors from StringBuffer:
ath
public java.lang.StringBuffer();
public java.lang.StringBuffer(int);
ip
public java.lang.StringBuffer(java.lang.String);
Ma
public java.lang.StringBuffer(java.lang.CharSequence);
Note :
=>Java8 'java.lang.String' is having 16 Constructors

sh
=>Java17 'java.lang.String' is having 15 Constructors
ate
Case-1 : Using 'StringBuffer()'
syntax:
nk
StringBuffer sb = new StringBuffer();
=>In this syntax the StringBuffer object is created with the

Ve
capacity 16(Characters).
=>we use append() method to add the data to StringBuffer object.
=>when the length crossed the capacity,then the capacity
increases automatically by doubling the capacity and adding 2.
16==>(16+16+2)===>34==>(34+34+2)==>70...
PAGE:105
=> we can perform insert(),delete() and reverse() opertaions
on StringBuffer object.
Ex : SBuffer1.java
package maccess;
public class SBuffer1 {
StringBuffer sb = new StringBuffer();//Con_Call
ii
System.out.println("default capacity:"+sb.capacity());
ath
System.out.println("length:"+sb.length());
sb.append("program");//adding to buffer object
System.out.println("sb:"+sb.toString());
System.out.println("capacity:"+sb.capacity());
ip
sb.append("language");
Ma
sb.append("nit");
sh
sb.insert(4,"JAVA");
ate
sb.delete(4,10);
nk
sb.deleteCharAt(7);
Ve
System.out.println("====reverse()====");
System.out.println(sb.reverse());
}
}
o/p:
default capacity:16
PAGE:106
length:0
sb:program
capacity:16
length:7
sb:programlanguage
capacity:16
ii
length:15
ath
sb:programlanguagenit
capacity:34
ip
length:18
sb:progJAVAramlanguagenit
capacity:34
Ma
length:22
sh
sb:progmlanguagenit
capacity:34
ate
length:16
sb:progmlaguagenit
nk
capacity:34
length:15
Ve
====reverse()====
tinegaugalmgorp
========================================================
Case-2 : Using 'StringBuffer(int)'
syntax:
PAGE:107
StringBuffer sb = new StringBuffer(4);
capacity equal to the number passed as parameter while object
creation.
Ex:SBuffer2.java
ii
package maccess;
ath
StringBuffer sb = new StringBuffer(4);//Con_Call
ip
sb.append("java");
Ma
sb.append("N");
sh
}
ate
o/p:
nk
default capacity:4
length:0
Ve
sb:java
capacity:4
length:4
sb:javaN
capacity:10
PAGE:108
length:5
===========================================================
Case-3 : Using 'StringBuffer(java.lang.String)"
syntax:
StringBuffer sb = new StringBuffer("NIT");
ii
capacity equal to "16 + length of String passed as parameter".
ip ath
Ma
sh
ate
Ex : SBuffer3.java
package maccess;
nk

StringBuffer sb = new StringBuffer("NIT");
Ve
sb.append("HYD");
sb.deleteCharAt(0);
PAGE:109
sb.append("languageprogramming");
}
}
o/p:
default capacity:19
ii
length:3
ath
sb:NITHYD
capacity:19
ip
length:6
sb:ITHYD
capacity:19
Ma
length:5
sh
sb:ITHYDlanguageprogramming
capacity:40
ate
length:24
===========================================================
nk
Case-4 : Using 'StringBuffer(java.lang.CharSequence)'
syntax:
Ve
StringBuffer sb1 = new StringBuffer("JAVA");
StringBuffer sb2 = new StringBuffer(sb1);
=>In this syntax one StringBuffer object will hold the reference
of another StringBuffer object.
=>In this syntax StringBuffer object is created equal to
PAGE:110
"16+ length of Strings available in referred objects"
ii
ip ath
Ex : SBuffer4.java
package maccess;
Ma
StringBuffer sb1 = new StringBuffer("JAVA");
sb1.append("NIT");
sh
StringBuffer sb2 = new StringBuffer(sb1);//Con_Call
System.out.println("sb2:"+sb2.toString());
System.out.println("default capacity:"+sb2.capacity());
ate
System.out.println("length:"+sb2.length());
}
}
nk
o/p:
Ve
sb2:JAVANIT
default capacity:23
length:7
========================================================
Assignment-1:
wap to read a String and check the String Palindrome String or
PAGE:111
not?(using predefined method)
Assignment-2:
wap to read a String and display the reverse of words in the
String?
ii
i/P : "java language program"
ath
o/P : "avaj egaugnal margorp"
====================================================
ip
Ma
sh
ate
nk
Ve
PAGE:112
Dt : 9/7/2022
Note:
=>StringBuffer class is 'Synchronized class'.
faq:
define 'synchronized class'?
=>The classes which are declared with synchronized methods are
ii
knonw as synchronized classes.
ath
faq:
ip
define synchronized methods?
Ma
=>The methods which are declared with 'synchronized' keyword
are known as synchronized methods.

sh
faq:
wt is an execution behaviour of synchronized method?

ate
=>These synchronized methods will be under 'synchronized lock'
and the method can be used by only one user at-a-time.

nk
====================================================
3.StringBuilder class:
Ve
=>'StringBuilder' class is from java.lang package and which
also generate Mutable objects.
=>The following are the constructors from 'StringBuilder'
class:
public java.lang.StringBuilder();
PAGE:113
public java.lang.StringBuilder(int);
public java.lang.StringBuilder(java.lang.String);
public java.lang.StringBuilder(java.lang.CharSequence);
=>StringBuilder class is having same behaviour like
StringBuffer,but StringBuilder is NonSynchronized class.
ii
faq:
ath
define NonSynchronized class?
=>The classes which are declared with NonSynchronized methods
ip
are known as NonSynchronized classes.
Ma
=================================================
Note:
=>Synchronized classes are also known as Thread-Safe classes.

sh
=>NonSynchronized classes are Non-Thread-Safe classes.
=>java.lang.String class also Thread-Safe class becuase the

ate
object Immutable objects.
=========================================================
nk
*imp
=>The following are the Utility Classes used on String Objects:

Ve
1.StringTokenizer
2.StringJoiner(Java8 - version)
1.StringTokenizer:
=>'StringTokenizer' class is from 'java.util' package and
PAGE:114
which is used to break the given String into pieces(tokens)
based on delimiter.
=>The following are some important method from
'StringTokenizer':
(i)hasMoreTokens()
(ii)nextToken()
ii
(iii)countTokens()
ath
(i)hasMoreTokens():
ip
=>This method will check the token is available or not,and
generate boolean result.
Method Signature:
Ma
public boolean hasMoreTokens();
sh
(ii)nextToken():
ate
=>This nextToken() method will retrieve the token from
the StringTokenizer object.

nk
Method Signature:
public java.lang.String nextToken();

Ve
(iii)countTokens():
=>This method is used to display the count of tokens.
Method Signature:
public int countTokens();
PAGE:115
syntax:
StringTokenizer ob = new StringTokenizer(str-Var,"delimiter");
Ex:
DemoTokenizer.java
package maccess;
import java.util.*;
ii
public class DemoTokenizer {
ath
StringTokenizer ob = new StringTokenizer(str," ");
ip
System.out.println("====Number of Tokens===");
int count = ob.countTokens(); Ma
System.out.println("Count:"+count);
System.out.println("====Display Tokens===");
while(ob.hasMoreTokens())
{
String tk = ob.nextToken();//Taking the token
System.out.println(tk.toString());
sh
System.out.println("No of Tokens:"+ob.countTokens());
}//end of loop
s.close();
ate
}
}
nk
o/p:
Enter the String:

Ve
java program
====Number of Tokens===
Count:2
====Display Tokens===
java
PAGE:116
No of Tokens:1
program
No of Tokens:0
Diagram:
ii
ip ath
Ma
sh
==================================================
ate
*imp
2.StringJoiner(Java8 - version)
=>StringJoiner class is from java.util package introduced

nk
by Java8 version and which is used to join the Strings based on

Ve
delimiter.
=>The following are some important methods of StringJoiner:
public java.util.StringJoiner setEmptyValue
(java.lang.CharSequence);
public java.lang.String toString();
public java.util.StringJoiner add
PAGE:117
(java.lang.CharSequence);
public java.util.StringJoiner merge
(java.util.StringJoiner);
public int length();
syntax:
ii
StringJoiner sj = new StringJoiner("delimiter");
ath
===========================================================
ip
Ma
sh
ate
nk
Ve
PAGE:118
Dt : 11/7/2022
Ex : DemoJoiner.java
package maccess;
import java.util.*;
public class DemoJoiner {
StringJoiner sj1 = new StringJoiner("/");
sj1.setEmptyValue("StringJoiner is empty...");
System.out.println("sj1:"+sj1.toString());
sj1.add("12");
ii
sj1.add("July");
ath
sj1.add("2022");
StringJoiner sj2 = new StringJoiner("-");
sj2.add("SRN");
sj2.add("HYD");
ip
sj2.add("612345");
Ma
sj1.merge(sj2);
System.out.println("length:"+sj1.length());
}
}
sh
o/p:
ate
sj1:StringJoiner is empty...
sj1:12/July/2022
nk
sj2:SRN-HYD-612345
sj1:12/July/2022/SRN-HYD-612345
Ve
length:27
=========================================================
Note:
=>The message which is setted through 'setEmptyValue()' method
will be display when StringJoiner object is empty.
PAGE:119
======================================================
faq:
define iClasses?
=>The classes which are used to perform operation on other
objects are known as Utility classes.
======================================================
ii
*imp
ath
WrapperClasses in Java:
=>The Pre-defined classes from java.lang package,which are
ip
used to make Primitive datatypes available in the form of objects
are known as 'WrapperClasses'.

Ma
=>Every Primitive DataType will have its own WrapperClass and
there are eight WrapperClasses.

sh
List of WrapperClasses:
ate
DataTypes WrapperClass
nk
byte Byte
short Short
Ve
int Integer
long Long
float Float
double Double
char Character
PAGE:120
boolean Boolean
faq:
define Boxing process?
=>The process of binding primitive datatypes into WrapperClass
objects is known as Boxing process.
ii
ath
Note:
=>This Boxing process is performed using Constructors
ip
=>The following are the list of Constructors from WrapperClasses:
WrapperClass List-of-Constructors
Ma
Byte Byte(byte),Byte(String)
sh
Short Short(short),Short(String)
Integer Integer(int),Integer(String)
ate
Long Long(long),Long(String)
Float Float(float),Float(double),Float(String)
nk
Double Double(double),Double(String)
Character Character(char)
Ve
Boolean Boolean(boolean),Boolean(String)
Ex:
wap to demonstrate Integer WrapperClass objects.
PAGE:121
DemoWrapperClass1.java
package test;
public class DemoWrapperClass1 {
//Boxing Process
Integer ob1 = new Integer(12);//Con_call_int
Integer ob2 = new
Integer("13");//Con_Call_int_in_String_form
Float ob3 = new Float(12.34F);//Con_Call_with_float
Float ob4 = new Float(123.45);//Con_Call_with_double
Float ob5 = new
ii
Float("234.56");//Con_Call_with_float_in_String
ath
Character ob6 = new Character('A');//Con_Call_with_char
Boolean ob7 = new Boolean(true);//Con_Call_with_boolean
Boolean ob8 = new
Boolean("false");//Con_Call_with_boolean_in_String
ip
System.out.println("====Data from Objects====");
System.out.println("ob1:"+ob1.toString());
Ma
sh
}
ate
o/p:
nk
====Data from Objects====
ob1:12
Ve
ob2:13
ob3:12.34
ob4:123.45
ob5:234.56
ob6:A
PAGE:122
ob7:true
ob8:false
ii
ip ath
Ma
======================================================
define UnBoxing Process?

sh
=>The process of taking Primitive datatypes outof WrapperClass
objects is known as UnBoxing process.

ate
=>The following methods are used to perform UnBoxing process:

nk
public byte byteValue();
public short shortValue();

Ve
public int intValue();
public long longValue();
public float floatValue();
public double doubleValue();
public char charValue();
PAGE:123
public boolean booleanValue();
Ex:
DemoWrapperClass2.java
package test;
//Boxing Process
ii
Integer ob1 = new Integer(12);//Con_call_int
ath
Float ob2 = new Float(12.34F);//Con_Call_with_float
Character ob3 = new Character('A');//Con_Call_with_char
Boolean ob4 = new Boolean(true);//Con_Call_with_boolean
//UnBoxing process
int i = ob1.intValue();
ip
float f = ob2.floatValue();
char ch = ob3.charValue(); Ma
boolean b = ob4.booleanValue();
System.out.println("====Display Values====");
System.out.println("Integer value:"+i);
System.out.println("Float value:"+f);
System.out.println("Character value:"+ch);
sh
System.out.println("Boolean value:"+b);
}
ate
o/p:
nk
====Display Values====
Integer value:12
Ve
Float value:12.34
Character value:A
Boolean value:true
========================================================
PAGE:124
Dt : 12/7/2022
faq:
define AutoBoxing process?
=>The boxing process which is performed automatically is known
as AutoBoxing process.
ii
Note:
ath
=>In AutoBoxing process the Primitive DataType values are
assigned to NonPrimitive datatype variables.
ip
faq:
define AutoUnBoxing process?

Ma
=>The UnBoxing process which is performed automatically is
sh
known as AutoUnBoxing process.
ate
Ex : DemoWrapperClass3.java
package test;
nk

//AutoBoxing Process
Integer ob1 = 12;
Ve
Float ob2 = 12.34F;

Character ob3 = 'A';
Boolean ob4 = true;
//AutoUnBoxing process
int i = ob1;
float f = ob2;
char ch = ob3;
boolean b = ob4;
System.out.println("====Display Values====");
System.out.println("Integer value:"+i);
PAGE:125
System.out.println("Float value:"+f);
System.out.println("Character value:"+ch);
System.out.println("Boolean value:"+b);
}
}
====================================================
faq:
ii
why we have to make Primitive DataType values available in the
ath
form of objects?
=>The Frameworks like JCF(Java Collection Framework),
ip
Hibernate with JPA,Spring-JDBC,... will work only with objects
Ma
because of this reason we have to make Primitive DataTypes
available in the form of objects.
---------------------------------------------------------
sh
Note:
=>The Objects generated from WrapperClasses are

ate
'Imutable Objects'.
==========================================================
nk
*imp
RelationShips in Java:
Ve
=>Class Communications in Java are known as RelationShips in
Java.
=>RelationShips in Java are categorized into three types:
1.References
2.Inheritance
PAGE:126
3.InnerClasses
1.References:
=>The process in which one object holding the reference of
another object is known as 'references concept' and which is also
ii
known 'Objects interlinking process'.
ath
Advantage:
ip
=>The methods of one object can access the members of another
object using reference.

Ma
Ex:
sh
Address.java
package test;
ate
public class Address {

public String hNo,sName,city;
public int pinCode;
}
nk
Employee.java
Ve
package test;
public class Employee {
public String id,name,desg;
public Address ad;
public Employee(Address ad) {
this.ad=ad;
}
}
ReadInput.java
PAGE:127
package test;
public class ReadInput {
public void read(Scanner s,Employee e)
{
System.out.println("Enter the EmpId:");
e.id = s.nextLine();
System.out.println("Enter the EmpName:");
e.name = s.nextLine();
System.out.println("Enter the EmpDesg:");
e.desg = s.nextLine();
ii
System.out.println("Enter the HNO:");
e.ad.hNo = s.nextLine();
ath
System.out.println("Enter the SName:");
e.ad.sName = s.nextLine();
System.out.println("Enter the City:");
e.ad.city = s.nextLine();
System.out.println("Enter the PinCode:");
ip
e.ad.pinCode = s.nextInt();
} Ma
}
Display.java
package test;
sh
public void dis(Employee e) {
System.out.println("====EmployeeDetails===");
ate
System.out.println("Id:"+e.id);
System.out.println("Name:"+e.name);
System.out.println("Desg:"+e.desg);
System.out.println("HNo:"+e.ad.hNo);
nk
System.out.println("SName:"+e.ad.sName);
System.out.println("City:"+e.ad.city);
System.out.println("PinCode:"+e.ad.pinCode);
Ve
}
}
DemoRef1.java(MainClass)
package maccess;
import test.*;
PAGE:128
import java.util.*;
public class DemoRef1 {
Address ad = new Address();//Con_Call
Employee e = new Employee(ad);//Con_call
ii
ReadInput ob = new ReadInput();
ath
ob.read(s, e);
Display d = new Display();
ip
d.dis(e);
}
}
Ma
Diagram:
sh
ate
nk
Ve
PAGE:129
ii
ip ath
Ma
sh
=============================================================
ate
nk
Ve
PAGE:130
Dt : : 13/7/2022
Ex-2:
Product.java
package test;
public class Product {
public String pCode,pName;
}
ii
ReadInput.java
ath
package test;
import java.util.*;
public Product p;
ip
public ReadInput(Product p) {
this.p=p; Ma
}
public void read(Scanner s) {
System.out.println("Enter the ProdCode:");
p.pCode = s.nextLine();
System.out.println("Enter the ProdName:");
p.pName = s.nextLine();
sh
}
}
ate
Display.java
package test;
nk
public Product p;
public Display(Product p) {
this.p=p;
Ve
}
public void dis() {
System.out.println("====ProductDetails====");
System.out.println("ProdCode:"+p.pCode);
System.out.println("ProdName:"+p.pName);
}
}
PAGE:131
package maccess;
import test.*;
import java.util.*;
ii
Product p = new Product();
ath
ReadInput ob = new ReadInput(p);
Display d = new Display(p);
ip
ob.read(s);
d.dis();
s.close();
Ma
}
sh
}
o/p:
ate
Enter the ProdCode:
A121
nk
Enter the ProdName:
Mouse
Ve
====ProductDetails====
ProdCode:A121
ProdName:Mouse
diagram:
PAGE:132
ii
ip ath
=========================================================
Note:
Ma
=>Multiple Objects can hold the reference of same object.
=>One object can hold references of any number of objects.

sh
==========================================================
Assignment:
ate
wap to read and display Student details using references concept?
Layout:
nk
Ve
PAGE:133
ii
ip ath
==========================================================
Ma
*imp
2.Inheritance in Java:
=>The process of extracting the features from one class to another

sh
class is known as Inheritance process.
ate
=>To perform inheritance process in Java,we use 'extends' keyword
to interlink classes.
nk
Diagram:
Ve
PAGE:134
ii
ath
syntax:
ip
class A Ma
{
/PClass_body
}
sh
class B extends A
ate
//CClass_body
}
nk
Ve
=>In Inheritance process we always create object for ChildClass,
because the ChildClass object will hold the members of both PClass
and CClass.
=====================================================
Case-1 : NonStatic members from the PClass or SuperClass
Case-2 : Static members from the PClass or SuperClass
PAGE:135
Case-3 : Constructors from the PClass or SuperClass
Case-1 : NonStatic members from the PClass or SuperClass
=>All the NonStatic members of PClass will get the memory within
the CClass object and can be accessed with CClass_object_name.
ii
Ex:
ath
PClass.java
package test;
public class PClass {
ip
public int a=10;
public void m1() { Ma
System.out.println("====PClass m1()====");
}
{
System.out.println("====PClass Instance block====");
sh
}
}
ate
CClass.java
package test;
nk
public class CClass extends PClass{

public int b=20;
public void m2() {
Ve
System.out.println("====CClass m2()====");
}
{
System.out.println("====CClass InStance block====");
}
}
PAGE:136
DemoInheritance1.java(MainClass)
package maccess;
import test.*;
public class DemoInheritance1 {
CClass ob = new CClass();//Object for ChildClass
ob.m1();//PClass_method_call
ob.m2();//CClass_method_call
}
}
ii
ath
o/p:
====PClass Instance block====
The value a:10
ip
====CClass InStance block==== Ma
The value b:20
====PClass m1()====
The value a:10

sh
====CClass m2()====
ate
The value b:20

nk
ClassFiles:
Ve
PClass.class
CClass.class
DemoInheritance1.class(MainClass)
PAGE:137
Ve
nk
ate
sh
PAGE:138
Ma
ip ath
ii
=============================================================
Dt : 14/7/2022
Note:
(i)In inheritance process PClass is loaded onto MethodArea
first and then CClass is loaded.
(ii)In inheritance process while object creation NonStatic
ii
components of PClass will get the memory first and then the
ath
NonStatic components of CClass will get the memory.
(iii)CClass can access the members of PClass,but PClass cannot
ip
access the members of CClass.
Ma
=======================================================
Case-2 : Static members from the PClass/SuperClass
=>The Static members of PClass will get the memory within the
sh
PClass,but can be accessed with CClass_name
ate
Ex:
PClass.java
nk
package test;
public static int a=10;
Ve
public static void m1() {

System.out.println("====PClass m1()====");
System.out.println("The value a:"+a);;
}
static {
System.out.println("====PClass static block====");
}
}
PAGE:139
CClass.java
package test;
public static int b=10;
System.out.println("====CClass m2()====");
}
static {
System.out.println("====CClass static block====");
ii
}
ath
}
DemoInheritance2.java(mainClass)
ip
package maccess;
import test.*; Ma
System.out.println("*****Using Class*****");
CClass.m1();//PClass method_call
CClass.m2();//CClass method_call
sh
System.out.println("****Using Object****");
CClass ob = new CClass();
ob.m1();
ate
ob.m2();
}
}
nk
o/p:
*****Using Class*****
Ve
====PClass static block====
The value a:10
====PClass m1()====
The value a:10
====CClass static block====
PAGE:140
The value b:10
====CClass m2()====
The value b:10
o/p:
ii
====Using Object====
ath
====PClass static block====
The value a:10
ip
====CClass static block====
The value b:10
====PClass m1()====
Ma
The value a:10
sh
====CClass m2()====
The value b:10

ate
nk
Execution flow of above program:(using Class)

Ve
ClassFiles:
PClass.class
CClass.class
DemoInheritance2.class(mainClass)
PAGE:141
ii
ip ath
Ma
Execution flow of above program:(using Object)
ClassFiles:
sh
PClass.class
CClass.class
ate
DemoInheritance2.class(mainClass)
nk
Ve
PAGE:142
ii
ip ath
Ma
=======================================================
faq:
sh
define Empty Object reference?
=>The Object reference which is generated with 0-members

ate
is known as Empty Object reference.

nk
faq:
In wt situation Empty Object reference is generated?

Ve
=>when we create object for the class which is declared only
with static members,then 'Empty Object reference' is created.
faq:
can we access Static members of class using Object reference
PAGE:143
variable?
=>Yes,we can access static members of class using Object
reference,because Object reference also generated from the
class and belongs to class.
===================================================
*imp
ii
Case-3 : Constructors from the PClass or SuperClass
ath
(i)0-parameter constructor from the PClass or SuperClass.
ip
=>when we have 0-parameter constructor in PClass then the
Ma
compiler at compilation stage will add super() to the CClass
constructor and which is PClass Con_Call.

sh
Ex:
PClass.java
ate
package test;
public PClass() {
System.out.println("===PClass()====");
nk
}
}
Ve
CClass.java
package test;
public CClass() {
super();
System.out.println("===CClass()===");
}
}
PAGE:144
package maccess;
import test.*;
CClass ob = new CClass();//CClass_Con_call
}
}
ii
o/p:
ath
===PClass()====
===CClass()===
---------------------------------------------------------
ip
Ma
sh
ate
nk
Ve
PAGE:145
Dt : 15/7/2022
Diagram:
ii
ip ath
Ma
(ii)Parameterized constructor in PClass/SuperClass
sh
=>when we have parameterized constructor in PClass then
we must add super() to the CClass constructor and which is

ate
PClass Constructor call.

nk
Ex:
PClass.java
Ve
package test;
public PClass(int x) {
System.out.println("====PClass(x)====");
}
}
CClass.java
PAGE:146
package test;
public CClass(int x) {
super(x);//PClass Con_Call
}
}
package maccess;
ii
import java.util.*;
ath
import test.*;
ip
System.out.println("Enter the value x:");

Ma
int x = s.nextInt();
sh
CClass ob = new CClass(x);//CClass_Con_call
s.close();
ate
}
nk
o/p:
Ve
Enter the value x:
121
====PClass(x)====
The value x:121
----------------------------------------------------------
PAGE:147
faq:
define Constructor Chaining process?
=>The process of calling one constructor from another
constructor is known as Constructor Chaining process or
Constructor Interlinking process.
=====================================================
ii
faq:
ath
define Method Overriding process?
=>The method with same method signature in PClass and CClass,
ip
then PClass method is replaced by CClass method while object
Ma
creation process is known as Method Overriding process.
=>Same method signature means,
same return_type
sh
same method_name
same para_list
ate
same para_type
nk
Case-1 : Instance method Overriding process
=>when we have same Instance method signature in PClass and

Ve
CClass,then PClass Instance method is replaced by CClass
Instance method is known as Instance method Overriding process.
Diagram:
PAGE:148
ii
ip ath
Ma
Ex:
sh
PClass.java
ate
package test;
public void m(int x) //Overrided_method
{
nk
System.out.println("====PClass m(x)====");
}
}
Ve
CClass.java
package test;
public void m(int x) //Overriding method
{
System.out.println("====CClass m(x)====");
PAGE:149
}
}
package maccess;
import test.*;
ob.m(121);
ii
}
ath
}
o/p:
ip
====CClass m(x)====
The value x:121

Ma
========================================================
Case-2 : Static method Overriding process

sh
=>There is no concept of Static method Overriding process
because the static methods are binded to classes and available

ate
in classes.
nk
faq:
define Method Hiding process?

Ve
=>when we have Same Static method signature in PClass and
CClass,then PClass method is hided by CClass method while
execution process is known as Method Hiding process.
Note:
PAGE:150
=>Method Hiding means the execution control cannot reach
PClass method because the same method signature available in
CClass for execution.
Ex:
PClass.java
ii
package test;
ath
public static void m(int x) //memory in Class Hided method
{
System.out.println("====PClass m(x)====");
ip
}
} Ma
CClass.java
package test;
sh
public static void m(int x) //memory in Class
{
System.out.println("====CClass m(x)====");
ate

}
}
nk
package maccess;
Ve
import test.*;
CClass.m(121);
}
}
o/p:
PAGE:151
====CClass m(x)====
The value x:121
Diagram:
ii
ip ath
Ma
========================================================
Summary:
sh
(i)Same Instance method signature in PClass and CClass,is known
as Method Overriding process.

ate
(ii)Same Static method Signature in PClass and CClass,is known
as Method Hiding process.

nk
==========================================================
Case-3 : Constructor Overriding process

Ve
=>There is no concept of Constructor Overriding process,
because we cannot have same constructor names in PClass and
CClass.
=============================================================
PAGE:152
Dt : 16/7/2022
faq:
def Generalization Process?
=>The process in which one object is created holding all the
members of PClass and only Overriding methods from the CClass is
known as Generalization process.
ii
=>we use the following syntax to perform Generalization process:
ath
PClass ob = new CClass();
ip
Diagram:
Ma
sh
ate
nk
Ve
Ex:
PClass.java
package test;
public void m1(int x) {
System.out.println("====PClass m1(x)====");
}
PAGE:153
public void m2(int y) {
System.out.println("====PClass m2(y)====");
}
}
CClass.java
package test;
ii
System.out.println("====CClass m1(x)====");
ath
}
public void m3(int z) {
System.out.println("====CClass m3(z)====");
ip
}
} Ma
package maccess;
import test.*;
sh
PClass ob = (PClass)new CClass();//Generalization
ate
process
ob.m1(12);
ob.m2(13);
//ob.m3(14);//Compilation Error
nk
}
}
Ve
o/p:
====CClass m1(x)====
The value x:12
====PClass m2(y)====
The value y:13
PAGE:154
========================================================
Note:
=>In realtime Generalization process is used to restrict
ChildClass to have only Overriding methods.
======================================================
Note:
ii
=>Generalization process is also known as Widening process or
ath
UpCasting process or Implicit TypeCasting process.
ip
PClass ob = (PClass)new CClass();
Ma
=======================================================
faq:
define Specialization process?

sh
=>The process of constructing the CClass by taking one feature
from the PClass is known as Specialization process.

ate
=>In Specialization process the PClass must be Pre-defined
class or Built-in class,if not it raises

nk
'java.lang.ClassCastException'
=>we use the following syntax to perform Specialization process:

Ve
CClass ob = (CClass)new PClass();
=>This Specialization process is also known as Narrowing process
or DownCasting process or Explicit TypeCasting process.
Ex:
Cloning process
PAGE:155
De-Serialization process
==========================================================
faq:
define Method Overloading process?
=>More than one method with same name but differentiated by
their Para_list or Para_type is known as Method Overloading
ii
process.
ath
Note:
=>The return_type of methods are not considered in Method
ip
Overloading process.
Ma
Case-1 : Instance method Overloading process
Case-2 : Static method Overloading process

sh
Case-3 : Constructor Overloading process
ate
Case-1 : Instance method Overloading process
=>More than one Instance method with same name,but

nk
differentiated by their Para_list or para_type is known as
Instance method Overloading process.

Ve
Ex:
PClass.java
package test;
public void m(int a) {
System.out.println("====PClass m(a)===");
PAGE:156
}
}
CClass.java
package test;
public void m(int a,int b) {
System.out.println("====m(a,b)====");
ii
ath
}
public void m(int a,int b,int c) {
System.out.println("====m(a,b,c)====");
ip
} Ma
}
package maccess;
sh
import test.*;
ate

ob.m(12);
ob.m(13,14);
ob.m(12,13,14);
nk
}
}
Ve
o/p:
====PClass m(a)===
The value a:12
====m(a,b)====
The value a:13
PAGE:157
The value b:14
====m(a,b,c)====
The value a:12
The value b:13
The value c:14
====================================================
ii
faq:
ath
define substring() method?
=>substring() method is used to retrieve part of string based
ip
on index values.
Method Signature:
public java.lang.String substring(int);

Ma
public java.lang.String substring(int,int);
sh
Ex:
ate
DemoString6.java
package maccess;
nk

Ve

String s1 = str.substring(4);
String s2 = str.substring(1, 5);
s.close();
}
}
PAGE:158
o/p:
Enter the String:
program
s1:ram
s2:rogr
===========================================================
ii
Assignment:
ath
wap to read and display Student details?
ip
1.read RollNo
Ma
=>RollNo must be 10 digits(Alphanumeric),else invalid rollNo
2.If the rollNo is validated,the read name and branch
=>branch must be in CSE or EEE or ECE,else invalid branch

sh
3.If the branch is verified,then check RollNo and branch matched
or not
ate
05 - CSE
04 - ECE
nk
02 - EEE
03 - MECH
Ve
01 - Civil
4.If RollNo and Brach Validated and Verified successfully,then
read 6 sub marks and perform calculations...
===========================================================
PAGE:159
Dt : 18/7/2022
BranchVarification.java
package maccess;
public class BranchVerification {
public boolean k=false;
public boolean verify(String br) {
//Java7 version
switch(br) {
ii
case "CSE" : k=true;
ath
break;
case "ECE" : k=true;
break;
case "EEE" : k=true;
break;
ip
}//end of switch
return k; Ma
}//end of method
}
RollNoBranchValidation.java
sh
package maccess;
public class RollNoBranchValidation {
public String br = null;
ate
public String generate(String brCode) {

switch(brCode) {
case "05" : br ="CSE";
break;
nk
case "04" : br = "ECE";

break;
case "02": br = "EEE";
break;
Ve
}//end of switch
return br;
}
}
StudentMainClass.java
package maccess;
import java.util.*;
PAGE:160
public class StudentMainClass {
System.out.println("Enter the RollNo:");
String rollNo = s.nextLine();
if(rollNo.length()==10) {
System.out.println("Enter the StuName:");
System.out.println("Enter the Branch:");
String branch = s.nextLine().toUpperCase();
BranchVerification bv = new BranchVerification();
ii
boolean k = bv.verify(branch);
if(k)
ath
{
RollNoBranchValidation ob = new
RollNoBranchValidation();
String br = ob.generate(rollNo.substring(6, 8));
if(br==null) {
ip
System.out.println("Invalid brCode in
rollNo..."); Ma
}//end of if
else
{
if(br.equals(branch)) {
System.out.println("RollNo matched with
branch");
sh
System.out.println("RollNo:"+rollNo);
System.out.println("Name:"+name);
System.out.println("Branch:"+branch);
ate
}//end of if
else
{
System.out.println("RollNo not belongs
nk
to branch");
}
}
}//end of if
Ve
else
{
System.out.println("Invalid Branch...");
}
}else {
System.out.println("Invalid RollNo...");
}
s.close();
}
}
PAGE:161
o/p:
Enter the RollNo:
1234560490
Enter the StuName:
Raj
ii
Enter the Branch:
ath
ECE
RollNo matched with branch
ip
RollNo:1234560490
Name:Raj
Branch:ECE
Ma
===============================================
sh
faq:
wt is the diff b/w

ate
(i)Validation
(ii)Verification
nk
(i)Validation:
Ve
=>The process of checking the data available in correct
format or not,is known as Validation process.
(ii)Verification:
=>The process of checking the data available or not,is known
PAGE:162
as Verification process.
=====================================================
Case-2 : Static method Overloading process:
=>More than one Static method with same name but differentiated
by their para_list or para_type is known as Static method
Overloading process.
ii
ath
Ex:
PClass.java
ip
package test;
public static void m(int x) {
Ma
System.out.println("===PClass m(x)====");
}
}
sh
CClass.java
ate
package test;
public static void m(int x,int y) {
System.out.println("===CClass m(x,y)====");
nk
}
Ve
public static void m(int x,float y) {

System.out.println("===CClass m(x,y)====");
}
}
PAGE:163
package maccess;
import test.*;
CClass.m(12);
CClass.m(12,13);
CClass.m(13, 14.56F);
}
}
ii
o/p:
ath
===PClass m(x)====
The value x:12
===CClass m(x,y)====
ip
The value x:12 Ma
The value y:13
===CClass m(x,y)====
The value x:13

sh
The value y:14.56
ate
===========================================================
faq:
nk
wt is the diff b/w
(a)super
Ve
(b)this
(c)super()
(d)this()
(a)super:
=>'super' is a keyword used to access the variables and
PAGE:164
methods from the PClass or SuperClass.
(b)this:
=>'this' keyword is used to access the variables and methods
from the same class or Current running class.
ii
(c)super():
ath
=>'super()' is used to execute constructors from the PClass
or SuperClass
ip
(d)this():
Ma
=>'this()' is used to execute constructors from the Same
class or Current running class.

sh
Ex:
ate
PClass.java
package test;
nk
public int x=20;

public void m(int a)//Overrided_method
{
Ve
System.out.println("====PClass m(a)====");
}
}
CClass.java
package test;
public int x=30;
PAGE:165
public void m(int a) //Overriding method
{
System.out.println("====CClass m(a)====");
}
public void access(int v1,int v2)
{
System.out.println("The value PClass x:"+super.x);
System.out.println("The value CClass x:"+this.x);
m(v1);
m(v2);
ii
}
}
ath
package maccess;
ip
import test.*;
public class DemoInheritance10 { Ma
ob.access(12,13);
}
}
sh
o/p:
ate
The value PClass x:20
The value CClass x:30

nk
====CClass m(a)====
The value a:12

Ve
====CClass m(a)====
The value a:13
=======================================================
faq:
can we use 'super' and 'this' keywords to access the static
PAGE:166
members of Class?
=>Yes,we can use 'super' and 'this' keywords to access the
static members of class,but these keywords must be used only
inside NonStatic methods because these keywords are Pre-defined
NonPrimitive datatype instance variables.
==============================================================
ii
ip ath
Ma
sh
ate
nk
Ve
PAGE:167
Dt : 19/7/20220
Ex:
PClass.java
package test;
public static int x=100;
public static void m(int p) {
System.out.println("====PClass m(p)====");
System.out.println("The value p:"+p);
ii
}
ath
}
CClass.java
ip
package test;
public class CClass extends PClass{ Ma
public static int x=200;
public static void m(int p) {
System.out.println("====CClass m(p)====");
}
public void access(int v1,int v2) {
sh
System.out.println("PClass value x:"+super.x);
System.out.println("CClass Value x:"+this.x);
super.m(v1);//PClass_method_call
ate
this.m(v2);//CClass_method_call
}
}
nk
package maccess;
Ve
import test.*;
ob.access(12, 13);
}
}
o/p:
PAGE:168
PClass value x:100
CClass Value x:200
====PClass m(p)====
The value p:12
====CClass m(p)====
The value p:13
ii
====================================================
ath
Ex:
PClass.java
ip
package test;
public PClass(int a,int b) {
Ma
this(a);//Con_Call_from_Same_class_1_para
}
public PClass(int a) {
sh
}
}
ate
CClass.java
package test;
nk
public CClass(int a,int b,int c,int d) {
this(a,b,c);//Con_Call_from_Same_Class_3_para
Ve
System.out.println("The value d:"+d);
}
public CClass(int a,int b,int c) {
super(a,b);//PClass_Con_Call_2_para
}
}
PAGE:169
package maccess;
import test.*;
CClass ob = new CClass(11,12,13,14);//Con_Call_4_para
}
}
ii
o/p:
ath
The value a:11
The value b:12
The value c:13
ip
The value d:14 Ma
======================================================
Note:
=>while calling constructor from the constructor the Con_call

sh
must be the first statement,which means 'super()' and 'this()'
ate
must be first statement.
===================================================
nk
*imp
Types of Inheritances:
Ve
=>Inheritances are categorized into following:
1.Single Inheritance
2.Multiple Inheritance
3.Multi-Level Inheritance
4.Hierarchal Inheritance
5.Hybrid Inheritance
PAGE:170
Diagrams:
ii
ip ath
Ma
sh
ate
nk
=================================================
Ve
=>In realtime these inheritances are categorized into two types:
1.Single Inheritance
2.Multiple Inheritance
1.Single Inheritance:
=>The process of extracting the features from one class
PAGE:171
at-a-time is known as Single Inheritance process.
Ex:
above programs
2.Multiple Inheritance:
=>The process of extracting the features from more than one
ii
class at-a-time is known as Multiple Inheritance process.
ath
Note:
ip
=>Multiple Inheritance process using classes in Java is not
Ma
available,because which generate replication of programming
components and raises ambiguity.
=>These ambiguity state application will generate wrong results.

sh
=>we can perform Multiple Inheritance process using Interfaces.
============================================================
ate
Assignment Solution:(References)
nk
Address.java
package test;
Ve
public class Address {

public String hNo,sName,city;
public int pinCode;
}
Contact.java
package test;
public class Contact {
public String mailId;
PAGE:172
public long phNo;
}
Result.java
package test;
public class Result {
public int totMarks;
public float per;
public String result;
public void calculate()
ii
{
ath
per = (float)totMarks/6;
if(per>=70 && per<=100) {
result="Distiction";
}
ip
result="FirstClass";
} Ma
result="SecondClass";
}
result= "ThirdClass";
}
sh
else {
result= "Fail";
}
ate
}
}
nk
Student.java
package test;
public class Student {
Ve
public String rollNo,name,branch;

public Address ad;
public Contact c;
public Result r;
public Student(Address ad,Contact c,Result r) {
this.ad=ad;
this.c=c;
this.r=r;
}
}
PAGE:173
ReadInput.java
package test;
import java.util.*;
public void read(Scanner s,Student stu) {
System.out.println("Enter the rollNo:");
stu.rollNo=s.nextLine();
System.out.println("Enter the Name:");
stu.name=s.nextLine();
ii
System.out.println("Enter the Branch:");
ath
stu.branch=s.nextLine();
System.out.println("Enter the HNo:");
stu.ad.hNo=s.nextLine();
System.out.println("Enter the StreetName:");
stu.ad.sName=s.nextLine();
ip
System.out.println("Enter the City:");
stu.ad.city=s.nextLine();
Ma
System.out.println("Enter the PinCode:");
stu.ad.pinCode=Integer.parseInt(s.nextLine());
System.out.println("Enter the MailId:");
stu.c.mailId=s.nextLine();
stu.c.phNo=Long.parseLong(s.nextLine());
sh
System.out.println("====Enter 6 Sub Marks===");
int i=1,totMarks=0;
while(i<=6)
ate
{
System.out.println("Enter the marks of Subject"+i);
int sub = s.nextInt();
if(sub<0 || sub>100)
nk
{
System.out.println("Invalid Marks...");
continue;//skip the below lines from the loop
}
Ve
totMarks=totMarks+sub;
i++;
}//end of loop
stu.r.totMarks=totMarks;
stu.r.calculate();
}
}
Display.java
PAGE:174
package test;
public void dis(Student stu) {
System.out.println("RollNo:"+stu.rollNo);
System.out.println("Name:"+stu.name);
System.out.println("Branch:"+stu.branch);
System.out.println("HNo:"+stu.ad.hNo);
System.out.println("SName:"+stu.ad.sName);
System.out.println("City:"+stu.ad.city);
System.out.println("PinCode:"+stu.ad.pinCode);
System.out.println("MailId:"+stu.c.mailId);
ii
System.out.println("PhNo:"+stu.c.phNo);
System.out.println("TotMarks:"+stu.r.totMarks);
ath
System.out.println("Per:"+stu.r.per);
System.out.println("Result::"+stu.r.result);
}
}
ip
package maccess;
Ma
import test.*;
sh
import java.util.*;

ate

nk
Address ad = new Address();
Contact c = new Contact();

Ve
Result r = new Result();
Student stu = new Student(ad,c,r);
ReadInput ob1 = new ReadInput();
ob1.read(s, stu);
Display ob2 = new Display();
PAGE:175
ob2.dis(stu);
s.close();
=======================================================
ii
ip ath
Ma
sh
ate
nk
Ve
PAGE:176
Dt : 20/7/2022
*imp
Interfaces in Java:
=>Interface is a Collection of Variables,abstract methods and
Concrete methods from Java8 version onwards.
Note:
ii
=>Upto Java7 version interface is a collection of Variables
ath
and abstract methods.
ip
faq:
define abstract methods?

Ma
=>The methods which are declared without method_body are
known as abstract methods.

sh
structure of abstract methods:

ate
return_type method_name(para_list);
nk
faq:
Ve
define concrete methods?
=>The methods which are declared with method_body are known
as Concrete methods.
structure of concrete methods:
PAGE:177
return_type method_name(para_list)
//method_body
=====================================================
ii
Coding rules of Interface:
ath
Rule-1 : we use 'interface' keyword to declare interfaces.
ip
syntax:
interface Interface_name
Ma
{
sh
//members
}
ate
Rule-2 : The programming components which are declared within the

nk
interface are automatically 'public'
Note:
Ve
=>The programming components which are declared within the
class without any access modifier are automatically 'default'.
Rule-3 : The interface can be declared with both primitive
datatype variables and NonPrimitive datatype variables.
PAGE:178
Rule-4 : The variables which are declared within the interface
are automatically 'final and static variables'
Note:
(i)static variables in interfaces will get the memory within
the interface while interface loading and can be accessed with
ii
interface_name.
ath
(ii)final variables must be initialized with values and once
initialized cannot be modified.
ip
(final variables are also known as secured variables or Constant
variables)
Ma
Rule-5 : The methods which are declared within the interface are
sh
automatically NonStatic abstract methods.
ate
Rule-6 : Interfaces cannot be instantiated,which means we cannot
create object for Interfaces.

nk
Note:
=>In Java interfaces are abstract components

Ve
Rule-7 : Interfaces are implemented to classes using 'implements'
keyword and the classes are known as implementation classes.
syntax:
PAGE:179
class IClass implements Interface
//members
Rule-8 : These implementation classes must construct the body
ii
for abstarct methods of interface,which means the methods are
ath
implemented.
ip
Ma
sh
ate
nk
Ex:
IArithmetic.java
Ve
package test;
public interface IArithmetic
{
public abstract void calculate(int x,int y);
}
Addition.java
package test;
public class Addition implements IArithmetic{
PAGE:180
public void calculate(int x,int y)
{
System.out.println("Sum:"+(x+y));
}
}
DemoInterface1.java(MainClass)
package maccess;
import test.*;
public class DemoInterface1 {
ii
ath
//IArithmetic ob = new IArithmetic();//CompilationError
Addition ob = new Addition();
ob.calculate(12, 13);
}
}
ip
Ma
-----------------------------------------------------------
Rule-9 : The interface can be declared with any number of
abstract methods and all these abstract methods must be

sh
implemented in implementation classes
ate
Rule-10 : Implementation classes can also be declared with
Non-Implemented methods.
nk
Ve
PAGE:181
ii
ip ath
Ex:
ITest.java Ma
package test;
public interface ITest {
public abstract void m1(int x);
public abstract void m2(int y);
}
sh
IClass.java
ate
package test;
public class IClass implements ITest{
public void m1(int x) //Implemented method
nk
{
System.out.println("====m1(x)====");
}
Ve
public void m2(int y) //Implemented method

{
System.out.println("====m2(y)====");
}
public void m3(int z) //Non-Implemented method
{
System.out.println("====m3(z)====");
PAGE:182
}
}
package maccess;
import test.*;
IClass ob = new IClass();//Implementation object
ob.m1(12);
ii
ob.m2(13);
ath
ob.m3(14);
}
}
ip
o/p:
====m1(x)====
The value x:12

Ma
====m2(y)====
sh
The value y:13
====m3(z)====
ate
The value z:14
-----------------------------------------------------------
nk
Note:
=>There is no concept of static abstract methods in Java.

Ve
=>abstract keyword in interfaces is not manditory.
=>There is no concept of declaring NonStatic variables in
interfaces,because the variables are automatically static
variables.
---------------------------------------------------------
PAGE:183
Rule-11 : Interface can be implemeted to any number of
implementation classes.
Diagram:
ii
ip ath
Ma
sh
ate
Ex:
IComparable.java
nk
package test;
public interface IComparable {
public abstract int compareTo(int x,int y,int z);
Ve
Greater.java
package test;
public class Greater implements IComparable{
public int compareTo(int x,int y,int z) {
if(x>y && x>z) return x;
else if(y>x && y>z) return y;
PAGE:184
else return z;
}
}
Smaller.java
package test;
public class Smaller implements IComparable{
if(x<y && x<z) return x;
else if(y<x && y<z) return y;
ii
else return z;
ath
}
}
ip
package maccess; Ma
import java.util.*;
import test.*;

sh
ate
System.out.println("Enter the value1:");

nk

Ve
System.out.println("1.Greater\n2.Smaller");
System.out.println("Enter the choice:");
PAGE:185
switch(s.nextInt()) {
case 1:
int r1 = new Greater().compareTo(v1, v2, v3);
System.out.println("Greater value:"+r1);
break;
case 2:
ii
int r2 = new Smaller().compareTo(v1, v2, v3);
ath
System.out.println("Smaller value:"+r2);
break;
ip
default:
Ma
System.out.println("Invalid choice...");
}//end of switch
s.close();
sh
}
}
ate
o/p:
Enter the value1:

nk
12
Enter the value2:

Ve
13
Enter the value3:
14
====Choice====
1.Greater
PAGE:186
2.Smaller
Enter the choice:
Smaller value:12
Dt : 21/7/2022
Assignment-1:
ii
wap to perform Arithmetic operations using Interface as
ath
follows:
ip
Ma
sh
ate
nk
Assignment-2:
Ve
wap to perform BankTransaction process using Interfaces as
follows:
Layout:
PAGE:187
ii
ip ath
Ma
(i)Read pinNo
=>The pinNo must be in 1111 or 2222 or 3333,else invalid

sh
pinNo
ate
=>In the pinNo invalidated for three times then display the
msg as "Transaction Blocked' and terminate the program.
(ii)If the pinNo is verified successfully,then show the following

nk
Choice:
Ve
1.WithDraw
2.Deposit
1.WithDraw:
=>read the amt
=>The amt must be greater than 0 and Multiples of 100,else
PAGE:188
invalid amt
=>If the amt is validated,then create object for implementation
class 'WithDraw' and pass amt as parameter to process()
method and perform transaction.
=>Part of method check amt is less than bal or not,
then perform transaction.
ii
=>when transaction Successfull
ath
o/p:
Amt withdrawn :
ip
Balance amt :
2.Deposit
Ma
=>read the amt
sh
=>The amt must be greater than 0 and Multiples of 100,else
invalid amt
ate
=>If the amt is validated,then create object for implementation
class 'Deposit' and pass amt as parameter to process()

nk
method and perform transaction.
=>Perform the transaction directly

Ve
=>when transaction Successfull
o/p:
Amt Deposited :
Balance amt :
===============================================================
PAGE:189
Rule-12 : There is no concept of declaring blocks and
constructors in Interfaces.(CompilationError)
Rule-13 : One interface can take the features of another
interface using 'extends' keyword
ii
Diagram:
ip ath
Ma
sh
ate
nk
Ve
Ex:
ITest1.java
package test;
public interface ITest1 {
}
PAGE:190
ITest2.java
package test;
public interface ITest2 extends ITest1{
}
IClass.java
package test;
public class IClass implements ITest2{
ii
ath
System.out.println("x:"+x);
}
System.out.println("y:"+y);
}
ip
}
Ma
package maccess;
import test.*;
sh
IClass ob = new IClass();
ob.m1(12);
ate
ob.m2(23);
}
}
nk
==========================================================
*imp
Ve
Concrete methods in Interfaces:(Java8 - new feature)
=>From Java8 version onwards the interfaces can be declared
with Concrete methods.
=>The following are the concrete methods can be declared in
Interfaces:
PAGE:191
(a)static concrete methods(Java8)
(b)default concrete methods(Java8)
(c)private concrete methods(Java9 - 2017)
(a)static concrete methods(Java8):
=>The concrete methods which are declared with static keyword
ii
in interfaces are known as Static concrete methods,introduced
ath
by Java8 version.
=>These static concrete methods will get the memory within
ip
the interface and can be accessed with Interface_name.
Coding rule:
Ma
=>Static concrete methods of Interface are not available to
sh
implementation classes,which means static concrete methods
cannot be accessed with Impl_Class_name

ate
Diagram:
nk
Ve
PAGE:192
ii
ip ath
Ex:
ITest.java
package test;
Ma
public static void m2(int y) {
sh
System.out.println("====static m2(y)===");
}
ate
IClass.java
nk
package test;
Ve
}
}
package maccess;
import test.*;
PAGE:193
ITest.m2(121);//Static method_call
//IClass.m2(121);
ob.m1(122);
}
}
o/p:
ii
====static m2(y)===
ath
The value y:121
====m1(x)====
ip
The value x:122
Ma
==========================================================
sh
ate
nk
Ve
PAGE:194
Dt : 22/7/2022
(b)default concrete methods(Java8):
=>The concrete methods which are declared with 'default'
keyword in interfaces are known as default concrete methods.
=>These default concrete methods are only NonStatic methods.
Coding Rule:
ii
=>These default concrete methods are available to
ath
implementation classes and can be accessed with implementation
class object reference.
ip
Ex:
ITest.java
Ma
package test;
sh
public default void m2(int y) {
ate

}
}
nk
IClass.java
package test;
Ve

}
}
package maccess;
PAGE:195
import test.*;
IClass ob = new IClass();//Implementation Object
ob.m1(12);
ob.m2(23);
}
}
o/p:
ii
====m1(x)====
ath
The value x:12
====m2(y)====
ip
The value y:23
Ma
=======================================================
Summary:
=>In Multiple Inheritance process we must use Static concrete

sh
methods.
=>In Non-Multiple Inheritance process we must use default

ate
Concrete methods.
==========================================================
nk
*imp
(c)private concrete methods(Java9 - 2017):

Ve
=>The concrete methods which are declared with 'private'
keyword in interfaces are known as Private Concrete methods
introduced by Java9 version.
=>Private concrete methods are categorized into two types:
(i)Static private concrete methods
PAGE:196
(ii)NonStatic private concrete methods
Coding rule:
=>These private concrete methods are accessed by the NonPrivate
concrete methods of same Interface.
ii
Ex:
ath
ITest.java
package test;
ip
private void m2(int y) { Ma
System.out.println("===m2(y)====");
}
private static void m3(int z) {
System.out.println("===m3(z)====");
sh
}
public default void access(int y,int z) {
this.m2(y);
ate
ITest.m3(z);
}
}
nk
IClass.java
package test;
Ve

System.out.println("===m1(x)===");
}
}
package maccess;
import test.*;
PAGE:197
IClass ob = new IClass();//Implementation object
ob.m1(12);
ob.access(13,14);
}
}
o/p:
ii
===m1(x)===
ath
The value x:12
===m2(y)====
The value y:13
ip
===m3(z)==== Ma
The value z:14
======================================================
Comparision Diagram:
sh
ate
nk
Ve
PAGE:198
====================================================
*imp
Single Inheritance Models:
Diagrams:
ii
ip ath
Ma
sh
ate
nk
Ve
=====================================================
*imp
Multiple Inheritance process using Interfaces:
Model-1 : Extracting the features from more than one interface
PAGE:199
into a class.
(Class implemeted from more than one interface)
Diagram:
ii
ip ath
Ma
Model-2 : Extracting the features from one class and any number
of interfaces into a class.

sh
(Class extending from one class and implementing from any number
ate
of interfaces)
Diagram:
nk
Ve
PAGE:200
ii
ath
Model-3 : Extracting the features from More than one interface
ip
into an Interface. Ma
(Interface extending from more than one Interface)
Diagram:
sh
ate
nk
Ve
=============================================================
PAGE:201
Dt : 26/7/2022
Ex_Program : Model-1
ITest1.java
package test;
public void m1(int x);
System.out.println("====ITest1 m2(y)====");
ii
}
ath
public default void m3(int z) {
System.out.println("===ITest1 m3(z)====");
}
}
ip
ITest2.java
package test;
Ma
public void m1(int x);
sh
System.out.println("====ITest2 m2(y)====");
}
ate
public default void m33(int z) {

System.out.println("===ITest1 m33(z)====");
}
nk
}
IClass.java
package test;
Ve
public class IClass implements ITest1,ITest2{

}
}
DemoMultipleInheritance1.java(MainClass)
PAGE:202
package maccess;
import test.*;
public class DemoMultipleInheritance1 {
ob.m1(12);
ITest1.m2(13);
ITest2.m2(14);
ob.m3(15);
ob.m33(16);
}
ii
}
ath
o/p:
===m1(x)===
ip
The value x:12
====ITest1 m2(y)====
The value y:13

Ma
====ITest2 m2(y)====
sh
The value y:14
===ITest1 m3(z)====
ate
The value z:15
===ITest1 m33(z)====
nk
The value z:16
=====================================================
Ve
PClass.java
package test;
System.out.println("===PClass m1(x)===");
PAGE:203
}
}
ITest.java
package test;
}
ii
ath
CClass.java
package test;
public class CClass extends PClass implements ITest{
ip
System.out.println("===m2(y)===");
Ma
}
}
sh
package maccess;
import test.*;
ate

ob.m1(12);
ob.m2(13);
nk
}
}
Ve
o/p:
===PClass m1(x)===
The value x:12
===m2(y)===
The value y:13
PAGE:204
=====================================================
ITest1.java
package test;
}
ii
ITest2.java
ath
package test;
}
ip
ITest3.java
package test;
Ma
public interface ITest3 extends ITest1,ITest2{
public abstract void m3(int z);
}
sh
IClass.java
ate
package test;
public class IClass implements ITest3{
nk
}
Ve
}
System.out.println("z:"+z);
}
}
package maccess;
PAGE:205
import test.*;
ob.m1(12);
ob.m2(13);
ob.m3(14);
}
}
ii
ath
o/p:
x:12
y:13
ip
z:14 Ma
========================================================
Assignment-1:(Solution)
sh
wap to perform Arithmetic operations using Interface .
ate
IArithmetic.java
package test;
nk
public interface IArithmetic {

public abstract double calculate(int x,int y);
}
Ve
Addition.java
package test;
public class Addition implements IArithmetic{
public double calculate(int x,int y) {
return x+y;
}
}
PAGE:206
Subtraction.java
package test;
public class Subtraction implements IArithmetic{
return x-y;
}
}
ii
Multiplication.java
ath
package test;
public class Multiplication implements IArithmetic{
return x*y;
ip
}
} Ma
Division.java
package test;
public class Division implements IArithmetic{
sh
return (double)x/y;
}
ate
ModDivision.java
nk
package test;
public class ModDivision implements IArithmetic{
Ve
return x%y;
}
}
package maccess;
import test.*;
PAGE:207
import java.util.*;
System.out.println("Enter the Value-1");
ii
ath
ip
Ma
case 1:
sh
System.out.println
("sum:"+ new Addition().calculate(v1, v2));

ate
break;
case 2:
nk
System.out.println
("Sub:"+new Subtraction().calculate(v1, v2));

Ve
break;
case 3:
System.out.println
("Mul:"+new Multiplication().calculate(v1, v2));
break;
PAGE:208
case 4:
System.out.println
("Div:"+new Division().calculate(v1, v2));
break;
case 5:
System.out.println
ii
("ModDiv:"+new ModDivision().calculate(v1, v2));
ath
break;
default:
ip
}//end of switch
s.close();
Ma
}
sh
}
======================================================
ate
wap to perform BankTransaction process using Interfaces

nk
Balance.java
Ve
package test;
public class Balance {
public double bal=2000;
public void getBalance() {
System.out.println("Balance Amt:"+bal);
}
}
Transaction.java
PAGE:209
package test;
public interface Transaction {
public static final Balance b = new Balance();
public abstract void process(int amt);
}
WithDraw.java
package test;
public class WithDraw implements Transaction{
public void process(int amt) {
ii
if(amt<=b.bal)
ath
{
System.out.println("Amt withDrawn:"+amt);
b.bal=b.bal-amt;
b.getBalance();
System.out.println("Transaction Completed...");
ip
}//end of if
else Ma
{
System.out.println("Insufficient fund....");
}
}
}
sh
Deposit.java
ate
package test;
public class Deposit implements Transaction{
System.out.println("Amt Deposited:"+amt);
nk
b.bal=b.bal+amt;
b.getBalance();
}
Ve
CheckPinNo.java
package test;
public class CheckPinNo {
public boolean verify(int pinNo) {
return switch(pinNo) {
case 1111 : yield true;
PAGE:210
default : yield false;
};
}
}
BankMainClass.java(MainClass)
package maccess;
ii
import java.util.*;
ath
import test.*;
public class BankMainClass {
ip
int count=0;
Ma
xyz:
sh
while(true) {
System.out.println("Enter the pinNo:");

ate
int pinNo = s.nextInt();
boolean k = new CheckPinNo().verify(pinNo);

nk
if(k)
{
Ve
System.out.println("1.WithDraw\n2.Deposit");
case 1:
PAGE:211
System.out.println("Enter the amt:");
int a1 = s.nextInt();
if(a1>0 && a1%100==0)
new WithDraw().process(a1);
}//end of if
ii
else
ath
{
System.out.println("Invalid amt...");
ip
}
case 2:
break xyz;
Ma
sh
if(a2>0 && a2%100==0)

ate
new Deposit().process(a2);
nk
}//end of if
else
Ve
break xyz;
default:
PAGE:212
break xyz;
}//end of switch
}//end of if
else
ii
System.out.println("Invalid pinNo...");
ath
count++;
ip
if(count==3)
{
Ma
System.out.println("Sorry ! Transaction blocked...");
break;//stop the loop

sh
}
}//end of loop
ate
}
nk
===============================================================
Dt : 27/7/2022
Ve
faq:
define labled loop?
=>The process of declaring iterative statement with lable is
known as labled loop or labled iterative statement.
=>we can stop the loop execution based on lable name.
PAGE:213
syntax:
break lable_name;
============================================================
faq:
wt is the diff b/w
(i)break
ii
(ii)continue
ath
=>'break' is used to stop the switch-case execution and also
used to stop iterative statements.
ip
=>'continue' is used to skip the lines from the iteration.
Ma
============================================================
faq:
define switch-case-yield?
sh
=>switch-case-yield statement introduced by Java13 version and
which is used to construct switch return type.

ate
syntax:
nk
return switch(value)
{
Ve
case 1 : yield result;
case 2 : yield result;
case n : yield result;
PAGE:214
default : yield default_value;
};
Note:
=>In switch-case-yield the default is manditory.
=========================================================
ii
*imp
ath
Generalization using Interfaces:
=>In Generalization process using interfaces,one object is
ip
created holding all the members of Interface and only Overriding
members from the implementation class.

Ma
=>we use the following syntax to perform Generation process
using Interfaces:
sh
syntax:
Interface ob = (Interface)new ImplClass();

ate
Ex:
nk
ITest.java
package test;
Ve

System.out.println("===m2(y)===");
}
}
IClass.java
PAGE:215
package test;
}
System.out.println("===m3(z)===");
}
}
ii
ath
package maccess;
import test.*;
ip
ITest ob = new IClass();//Generalization process
Ma
ob.m1(12);
ob.m2(13);
//ob.m3(14);//Compilation Error
//IClass ob2 = (IClass)new ITest();//Compilation Error
}
}
sh
o/p:
ate
===m1(x)===
x:12
nk
===m2(y)===
y:13
Ve
===========================================================
Note:
=>Specialization process using interfaces is not available.
(Compilation Error)
===========================================================
PAGE:216
faq:
define Abstract Class?
=>The classes which are declared with 'abstract' keyword are
known as Abstract Classes.
=>Abstract Classes can hold Variables,abstract methods,
concrete methods,blocks,Constructors and features.
ii
=>The abstract methods in abstract classes must be declared with
ath
abstarct keyword,which means 'abstract' keyword is manditory.
=>These abstract classes cannot be instantiated,which means we
ip
cannot create object for abstract classes directly.
Ma
=>These abstarct classes are extended to classes using 'extends'
keyword and the classes are known as Extended classes or
implemented classes,because these extended classes will

sh
construct body for abstract methods.
=>we can also perform Generalization process using the following

ate
syntax:
AClass ob = (AClass)new EClass();

nk
=>we cannot perform Specialization process using AbstractClasses.
(Compilation Error)
Ve
Ex:
AClass.java
package test;
public abstract class AClass {
PAGE:217
}
}
EClass.java
package test;
public class EClass extends AClass{
}
ii
ath
System.out.println("===m3(z)===");
}
}
ip
DemoAbstractClass1.java(MainClass) Ma
package maccess;
import test.*;
public class DemoAbstractClass1 {
System.out.println("====Normal Inheritance====");
sh
EClass ob1 = new EClass();
ob1.m1(12);
ob1.m2(13);
ate
ob1.m3(14);
System.out.println("====Generalization=====");
AClass ob2 = (AClass)new EClass();
ob2.m1(22);
nk
ob2.m2(23);
//ob2.m3(23);//Compilation error
System.out.println("====Specialization====");
//EClass ob3 = (EClass)new AClass();//Compilation error
Ve
o/p:
====Normal Inheritance====
===m1(x)===
PAGE:218
x:12
====m2(y)====
y:13
===m3(z)===
z:14
====Generalization=====
ii
===m1(x)===
ath
x:22
====m2(y)====
ip
y:23
====Specialization====
Ma
=======================================================
*imp
sh
Single Inheritance using AbstractClasses:
ate
Diagrams:
nk
Ve
PAGE:219
ii
ip ath
Ma
======================================================
sh
faq:
wt is the diff b/w

ate
(i)Class
(ii)Abstract Class
nk
=>Class can hold only Concrete methods,but Abstract Class can
hold both Concrete methods and abstract methods.

Ve
=>Class can be Instantiated,but Abstract class cannot be
Instantiated.
faq:
wt is the diff b/w
PAGE:220
(i)Interface
(ii)Abstract Class
=>Interface cannot hold blocks and constructors,but Abstract
class can hold blocks and constructors.
=>Variables in Interface are automatically static and final,
ii
but variables in abstract classes are user choice.
ath
=>The programming components in Interface are automatically
public,but Programming Components in AbstractClasses are
ip
automatically default.
Ma
===========================================================
Comparision diagram:
sh
ate
nk
Ve
============================================================
PAGE:221
Dt : 28/7/2022
faq:
define Abstraction process?
=>The process in which we show essential things to the enduser
by hiding Non-Essential things is known as 'Abstraction process'
=>we use 'Interfaces' and 'AbstractClasses' in Java to perform
ii
Abstraction process
ath
============================================================
*imp
ip
InnerClasses in Java:
Ma
=>The process of declaring class inside the class is known as
InnerClass or Nested Class.
=>These InnerClasses are categorized into two types:

sh
1.Member InnerClasses
2.Anonymous InnerClasses
ate
1.Member InnerClasses:
nk
=>The classes which are declared as members of class are
known as Member InnerClasses.

Ve
=>These Member InnerClasses are categorized into two types:
(a)Static Member InnerClasses
(b)NonStatic Member InnerClasses
*imp
PAGE:222
(a)Static Member InnerClasses:
=>The member InnerClasses which are declared outside the
methods of OuterClass are known as Static Member InnerClasses
or Class Member InnerClasses.
Coding rules:
ii
(i)Static member InnerClasses can be declared with both static
ath
members and NonStatic members.
(ii)The methods of Static member InnerClasses can access only
ip
Static members of OuterClass directly,which means they
Ma
cannot access Instance variables of OuterClass directly.
(iii)The Instance methods which are declared inside the Static
member InnerClasses will have behaviour like static methods.

sh
syntax of creating object for Static member InnerClass:

ate
OuterClass_name.InnerClass_name obj =
new OuterClass_name.InnerClass_name();
nk
Ex:
Ve
SubClass1.SubClass2 ob2 = new SubClass1.SubClass2();
Ex:
SubClass1.java
package test;
public class SubClass1 {
PAGE:223
public int a=10;
public void m1() {
System.out.println("****OuterClass m1()****");
}//end of OuterClass method
public static class SubClass2{
public void m2() {
System.out.println("****InnerClass Instance
m2()****");
ii
ath
}
System.out.println("****InnerClass static m22()****");
ip
}
}//Static Member InnerClass Ma
}//OuterClass
DemoInnerClass1.java(MainClass)
package maccess;
sh
import test.*;
public class DemoInnerClass1 {
ate
SubClass1 ob1 = new SubClass1();//OuterClass object

ob1.m1();//OuterClass method_Call
SubClass1.SubClass2 ob2 = new SubClass1.SubClass2();
//Static member InnerClass object
nk
ob2.m2();//InnerClass_Instance_method_call
SubClass1.SubClass2.m22();//InnerClass_Static_method_call
}
}
Ve
o/p:
****OuterClass m1()****
The value a:10
The value b:20
PAGE:224
****InnerClass Instance m2()****
The value b:20
****InnerClass static m22()****
The value b:20
---------------------------------------------------------
ii
ClassFiles:
ath
SubClass1.class
DemoInnerClass1.class(MainClass)
ip
SubClass1$SubClass2.class
Ma
sh
ate
nk
Ve
===========================================================
(b)NonStatic Member InnerClasses:
=>The member InnerClasses which are declared without static
keyword are known as NonStatic Member InnerClasses.
=>These NonStatic member InnerClasses are categorized into
PAGE:225
two types:
(i)Instance Member InnerClasses
(ii)Local Member InnerClasses
(i)Instance Member InnerClasses:
=>The NonStatic Member InnerClasses which are declared
ii
outside the methods of OuterClass are known as Instance Member
ath
InnerClasses or Object Member InnerClasses
ip
Coding Rules:
Ma
(i)Instance Member InnerClasses can be declared with both
Static and NonStatic members.
(ii)Instance methods of Instance Member InnerClasses can access

sh
static and NonStatic members of OuterClass directly.
(iii)Static methods of Instance Member InnerClasses can access

ate
only Static members of OuterClass directly.

nk
Syntax of Object creation for Instance Member InnerClass:

Ve
OuterClass_name.InnerClass_name obj =
OuterClass_Obj_name.new InnerClass_name();
Ex:
SubClass1.java
PAGE:226
package test;
public int a=10;
public void m1() {
System.out.println("****OuterClass m1()****");
}//OuterClass method
public class SubClass2{
public void m2() {
ii
System.out.println("****InnerClass Instance
m2()****");
ath
}
System.out.println("****InnerClass static
ip
mm22()****");
Ma
}
}//Instance Member InnerClass
}//OuterClass
sh
package maccess;
ate
import test.*;
nk
ob1.m1();//OuterClass method_call
SubClass1.SubClass2 ob2 = ob1.new SubClass2();
//Instance member InnerClass object
ob2.m2();//InnerClass Instance method_call
Ve
SubClass1.SubClass2.m22();//InnerClass Static method_call

}
}
o/p:
****OuterClass m1()****
The value a:10
PAGE:227
The value b:20
****InnerClass Instance m2()****
The value a:10
The value b:20
****InnerClass static mm22()****
The value b:20
ii
-------------------------------------------------------
ath
ip
Ma
sh
ate
nk
Ve
PAGE:228
Dt : 29/7/2022
ClassFiles:
SubClass1.class
SubClass1$SubClass2.class
ii
ip ath
Ma
sh
ate
=========================================================
nk
Summary:
=>In Static member InnerClasses the OuterClass will have the

Ve
memory for Static member InnerClass
=>In Instance member InnerClasses the InnerClass object will
hold the reference of OuterClass object.
======================================================
*imp
PAGE:229
(ii)Local Member InnerClasses:
=>The NonStatic member InnerClass which is declared inside
the method of OuterClass is known as Local member InnerClass.
=>These Local member InnerClasses can be declared part of
Static methods and NonStatic methods.
ii
Coding Rules:
ath
(i)The Local InnerClass which is declared in Instance method
of OuterClass will have behaviour like
ip
'Instance member InnerClass'
Ma
(ii)The Local InnerClass which is declared in Static method
of OuterClass will have behaviour like 'Static member InnerClass'
(iii)The Local member InnerClass objects are created inside

sh
the methods where classes are declared.
ate
Ex:
SubClass1.java
nk
package test;
public int a=10;
Ve

public void m1() {
//behaviour_like_Instance_member_InnerClass
class SubClass2{
public void m2() {
System.out.println("****Instance m2()*****");
System.out.println("a:"+a);
System.out.println("b:"+b);
}
System.out.println("****Static m22()****");
PAGE:230
//System.out.println("a:"+a);
}
}//Local member InnerClass
SubClass2 ob2 = new SubClass2();
//Local member InnerClass object
ob2.m2();
SubClass2.m22();
}//end of m1()
//behaviour_like_Static_member_InnerClass
ii
class SubClass22{
public void m3() {
ath
System.out.println("***Instance m3()****");
}
ip
System.out.println("***static m33()****");
Ma
}
SubClass22 ob22 = new SubClass22();
ob22.m3();
SubClass22.m33();
sh
}//end of m2()
}//OuterClass
ate
package maccess;
nk
import test.*;
Ve
ob1.m1();//OuterClass_Instance_method
SubClass1.m2();//OuterClass_Static_method
}
}
o/p:
****Instance m2()*****
PAGE:231
a:10
b:20
****Static m22()****
b:20
***Instance m3()****
b:20
ii
***static m33()****
ath
b:20
----------------------------------------------------
ip
ClassFiles:
SubClass1.class
Ma
SubClass1$1SubClass2.class
sh
SubClass1&1SubClass22.class
============================================================
ate
Ex:
nk
ITest.java
package test;
Ve

public abstract void m(int x);
}
Generate.java
package test;
public class Generate {
public static ITest getRef() {
class IClass implements ITest{
PAGE:232
public void m(int x) {
System.out.println("====m(x)====");
}
return ob;
}//OuterClass
ii
DemoDesign1.java(MainClass)
ath
package maccess;
import test.*;
public class DemoDesign1 {
ITest ob = Generate.getRef();
ip
//Implementation class as Local InnerClass
ob.m(123); Ma
}
}
Diagram:
sh
ate
nk
Ve
============================================================
PAGE:233
Dt : 30/7/2022
*imp
2.Anonymous InnerClasses:
=>The InnerClasses which are declared without name are known as
Anonymous InnerClasses.
=>These Anonymous InnerClasses are categorized into two types:
ii
(a)Anonymous InnerClass as Class extention
ath
(b)Anonymous InnerClass as Implementation class
ip
Ma
sh
ate
nk
Ve
PAGE:234
(a)Anonymous InnerClass as Class extention:
=>The process of declaring ChildClass without name is known
as 'Anonymous InnerClass as Class Extention'.
syntax:
ii
class PClass
ath
{
//PClass_body
ip
}
PClass ob = new PClass()

Ma
{
sh
//CClass_body
};
ate
Ex:
PClass.java
nk
package test;
Ve
System.out.println("====PClass m1(x)====");
}
System.out.println("====PClass m2(y)====");
}
}
DemoAnonymous1.java(MainClass)
PAGE:235
package maccess;
import test.PClass;
public class DemoAnonymous1 {
//Anonymous InnerClass as Class_extention
PClass ob = new PClass()
{
public void m1(int x)//Overriding method
{
System.out.println("====CClass m1(x)====");
ii
}
public void m3(int z)//Non-Overriding method
ath
{
System.out.println("====CClacc m3(z)====");
}
};
ip
ob.m1(12);
ob.m2(13); Ma
//ob.m3(14);//Compilation error
}
}
sh
o/p:
====CClass m1(x)====
ate
The value x:12
====PClass m2(y)====
nk
The value y:13
------------------------------------------------------
Ve
Note:
=>Generalization process using classes modified as 'Anonymous
InnerClass as Class extention'.
ClassFiles:
PAGE:236
PClass.class
DemoAnonymous1.class(MainClass)
DemoAnonymous1$1.class
=> All Anonymous InnerClasses are Local member InnerClasses
=============================================================
ii
*imp
ath
(b)Anonymous InnerClass as Implementation class:
=>The process of declaring implementation class without name
ip
is known as 'Anonymous InnerClass as Implementation class'.
syntax:
Ma
interface ITest
sh
{
//Interface_body
ate
ITest ob = new ITest()

nk
//IClass_body
Ve
};
Ex:
ITest.java
package test;
PAGE:237
System.out.println("====default m2(y)====");
}
}
package maccess;
import test.ITest;
ii
ath
//Anonymous InnerClass as implementation class
ITest ob = new ITest()
{
public void m1(int x)//Implemented method
ip
{
System.out.println("====m1(x)===="); Ma
}
public void m3(int z)//Non-Implemented method
{
System.out.println("====m3(z)====");
sh
}
};
ob.m1(12);
ate
ob.m2(13);
//ob.m3(14);
}
}
nk
o/p:
Ve
====m1(x)====
The value x:12
====default m2(y)====
The value y:13
---------------------------------------------------------
PAGE:238
Note:
=>Generalization process using Interfaces model is modified as
'Anonymous InnerClass as implementation class'.
ClassFiles:
ITest.class
ii
ath
===========================================================
ip
Ex : Application_Design_2
ITest.java
package test;
Ma
}
sh
Generate.java
ate
package test;
public class Generate {
public static ITest getRef() {
//Anonymous InnerClass as Implementation class
nk
return new ITest()

{
public void m(int x) {
Ve
System.out.println("====m(x)====");
}
};
}//OuterClass
DemoDesign2.java(MainClass)
package maccess;
PAGE:239
import test.*;
public class DemoDesign2 {
ITest ob = Generate.getRef();
//Implementation class as Local InnerClass
ob.m(123);
}
}
=========================================================
Ex : Convert IComparable program into Anonymous InnerClass as
ii
implementation class.
ath
Ex:
IComparable.java
ip
package test;
public interface IComparable { Ma
}
sh
package maccess;
import java.util.*;
ate
import test.*;

nk

Ve
PAGE:240
case 1:
ii
ath
IComparable ob1 = new IComparable()
ip
Ma
else return z;
sh
}
};
ate
System.out.println("Greater value:"+ob1.compareTo(v1,v2,v3));
break;
nk
case 2:

Ve
IComparable ob2 = new IComparable()
PAGE:241
else return z;
};
System.out.println("Smaller value:"+ob2.compareTo(v1, v2, v3));
break;
default:
ii
ath
}//end of switch
s.close();
ip
}
o/p:
Ma
Enter the value1:
sh
12
Enter the value2:

ate
13
Enter the value3:

nk
14
====Choice====
Ve
1.Greater
2.Smaller
Enter the choice:
Greater value:14
PAGE:242
-----------------------------------------------------
ClassFiles:
IComparable.class
ii
============================================================
ath
Assignment-1:
Convert IArithmetic application into 'Anonymous InnerClass as
ip
implementation class'.
Assignment-2:
Ma
Convert BankTransaction application into 'Anonymous InnerClass as
implementation class'
sh
===========================================================
ate
nk
Ve
PAGE:243
Dt : 1/8/2022
Convert IArithmetic application into 'Anonymous InnerClass as
implementation class'.
IArithmetic.java
ii
package test;
ath
}
ip
package maccess;
import test.*;
Ma
import java.util.*;
sh

ate

nk

Ve
PAGE:244
case 1:
IArithmetic ad = new IArithmetic()
return x+y;
ii
};
ath
System.out.println
("sum:"+ ad.calculate(v1, v2));
ip
break;
case 2:
IArithmetic sb = new IArithmetic()

Ma
{
sh
return x-y;
ate
};
nk
System.out.println
("Sub:"+sb.calculate(v1, v2));
Ve
break;
case 3:
IArithmetic ml = new IArithmetic()
PAGE:245
return x*y;
};
System.out.println
("Mul:"+ml.calculate(v1, v2));
ii
break;
ath
case 4:
IArithmetic dv = new IArithmetic()
ip
{
Ma
return (double)x/y;
}
sh
};
System.out.println
ate
("Div:"+dv.calculate(v1, v2));
break;
nk
case 5:
IArithmetic md = new IArithmetic()

Ve
return x%y;
};
PAGE:246
System.out.println
("ModDiv:"+md.calculate(v1, v2));
break;
default:
}//end of switch
ii
s.close();
ath
}
ip
ClassFiles:
IArithmetic.class
Ma
sh
ate
nk
===========================================================
Ve
Convert BankTransaction application into 'Anonymous InnerClass as
implementation class'
Balance.java
package test;
PAGE:247
}
}
CheckPinNo.java
package test;
ii
ath
};
ip
}
} Ma
Transaction.java
package test;
sh
}
ate
nk
package maccess;
import java.util.*;
Ve
import test.*;
int count=0;
PAGE:248
xyz:
while(true) {
if(k)
ii
{
ath
ip
case 1:
Ma
sh
if(a1>0 && a1%100==0)

ate
Transaction wd = new Transaction()

nk

Ve
if(amt<=b.bal)
System.out.println("Amt
withDrawn:"+amt);
b.bal=b.bal-amt;
PAGE:249
b.getBalance();
System.out.println("Transaction
Completed...");
}//end of if
else
ii
ath
}
ip
};
wd.process(a1); Ma
}//end of if
else
{
sh
ate
break xyz;
nk
case 2:

Ve
if(a2>0 && a2%100==0)
Transaction dp = new Transaction()
PAGE:250
b.bal=b.bal+amt;
b.getBalance();
ii
};
ath
dp.process(a2);
}//end of if
ip
else
{
Ma
}
sh
break xyz;
default:
ate
break xyz;
nk
}//end of switch
}//end of if
Ve
else
count++;
PAGE:251
if(count==3)
}//end of loop
ii
}
ath
}
ClassFiles:
ip
Balance.class
CheckPinNo.class
Transaction.class
Ma
BankMainClass.class(MainClass)
sh
BankMainClass$1.class
BankMainClass$2.class
ate
===========================================================
Note:
nk
=>This 'Anonymous InnerClass as implementation class' model
is modified as 'LambdaExpression' from Java8 version on wards.

Ve
============================================================
*imp
define LambdaExpression?(Java8 - new feature)
=>The process of declaring method without method_name is known
as LambdaExpression or Anonymous method.
PAGE:252
structure of LambdaExpression:
(para_list)->
//method_body
ii
ath
Note:
=>The abstract method of interface is attached with the
ip
LambdaExpression and the LambdaExpression is executed by calling
abstarct_method_name.
Ma
syntax:
sh
Interface_name ob = (para_list)->
{
ate
//method_body
};
nk
Ve
Ex:
ITest.java
package test;
public static final int z=20;
public default void dis(int k) {
System.out.println("====default dis(k)====");
PAGE:253
}
}
DemoLambdaExpression1.java(MainClass)
package maccess;
import test.*;
public class DemoLambdaExpression1 {
ii
// int x=20;
ath
ITest ob = (int x)->
{
System.out.println("====m(x)===");
System.out.println("The value z:"+ITest.z);
ip
};
int x=20; Ma
ob.m(123);
ob.dis(124);
}
}
sh
o/P:
====m(x)===
ate
The value x:123
====default dis(k)====
nk
The value k:124

Ve
ClassFiles:
ITest.class
DemoLambdaExpression1.class(MainClass)
PAGE:254
ii
ip ath
=======================================================
Advantage of LambdaExpression:
Ma
=>when we use LambdaExpression,then separate class file is
not generated,and in this process Loading time of execution

sh
process is decreased and HighPerformance application is
generated.
ate
=========================================================
Coding Rules of LambdaExpression:

nk
Rule-1 : The target interface which is providing abstract method
to hold LambdaExpression must be declared with only one abstract

Ve
method.
Rule-2 : LambdaExpression will access the variables of target
interface using Interface_name.
Rule-3 :The parameters names which are used in LambdaExpression
and the variables with same names must not be declared in the
PAGE:255
same method scope.
==========================================================
faq:
wt is the diff b/w
(i)Normal Interface
(ii)Functional Interface
ii
ath
(i)Normal Interface:
=>The interface can be declared with any number of abstract
ip
methods is known as Normal Interface.
(ii)Functional Interface:
Ma
=>The Interface which is declared with only one abstract
sh
method is known as Functional Interface or Target Interface.
=========================================================
ate
Assignment:
Convert IComparable,IArithmetic and BankTransaction into

nk
LambdaExpression.
===========================================================
Ve
PAGE:256
Dt : 2/8/2022
Ex:
IComparable Application Using LambdaExpressions:
IComparable.java
package test;
public interface IComparable {
ii
ath
}
ip
package maccess;
import java.util.*;
import test.*;
Ma
sh

ate
nk
Ve
PAGE:257
case 1:
//LambdaExpression
IComparable ob1 = (int x,int y,int z)->
ii
ath
else return z;
};
ip
System.out.println("Greater value:"+ob1.compareTo(v1,v2,v3));
break;
case 2:
Ma
//LambdaExpression
sh
IComparable ob2 = (int x,int y,int z)->
{
ate

nk
else return z;
};
Ve
System.out.println("Smaller value:"+ob2.compareTo(v1, v2, v3));
break;
default:
}//end of switch
PAGE:258
s.close();
========================================================
Ex:
IArithmetic Application Using LambdaExpression:
ii
ath
IArithmetic.java
package test;
ip
} Ma
package maccess;
sh
import test.*;
import java.util.*;
ate

nk

Ve
PAGE:259
case 1:
IArithmetic ad = (int x,int y)-> x+y;
System.out.println
("sum:"+ ad.calculate(v1, v2));
ii
break;
ath
case 2:
IArithmetic sb =(int x,int y)-> x-y;
ip
System.out.println
("Sub:"+sb.calculate(v1, v2));
break;
Ma
case 3:
sh
IArithmetic ml = (int x,int y)-> x*y;
System.out.println
ate
("Mul:"+ml.calculate(v1, v2));
break;
nk
case 4:
IArithmetic dv = (int x,int y)-> (double)x/y;

Ve
System.out.println ("Div:"+dv.calculate(v1, v2));
break;
case 5: IArithmetic md = (int x,int y)-> x%y;
System.out.println
("ModDiv:"+md.calculate(v1, v2));
PAGE:260
break;
default:
}//end of switch
s.close();
ii
}
ath
===================================================
Ex:
ip
Bank Transaction Application using LambdaExpression:
Balance.java
Ma
package test;
sh
ate
}
}
nk
CheckPinNo.java
package test;
Ve

};
}
}
PAGE:261
Transaction.java
package test;
}
ii
package maccess;
ath
import java.util.*;
import test.*;
ip
Ma
int count=0;
xyz:
sh
while(true) {
ate

nk
if(k)
Ve
case 1:
PAGE:262
if(a1>0 && a1%100==0)
Transaction wd = (int amt)->
ii
if(amt<=Transaction.b.bal)
ath
{
System.out.println("Amt
ip
withDrawn:"+amt);
Ma Transaction.b.bal=Transaction.b.bal-amt;
Transaction.b.getBalance();
System.out.println("Transaction
Completed...");
sh
}//end of if
ate
else
nk
}
Ve
};
wd.process(a1);
}//end of if
else
PAGE:263
}
break xyz;
case 2:
if(a2>0 && a2%100==0)
ii
{
ath
Transaction dp = (int amt)->
ip
MaTransaction.b.bal=Transaction.b.bal+amt;
Transaction.b.getBalance();
sh
};
dp.process(a2);
ate
}//end of if
else
nk
Ve
break xyz;
default:
break xyz;
PAGE:264
}//end of switch
}//end of if
else
count++;
ii
}
ath
if(count==3)
ip
}
Ma
}//end of loop
sh
}
}
ate
====================================================
*imp
nk
Method References in Java:(Java8 - new feature)
=>The process of binding method_body of a class to a abstract

Ve
method of Functional interface,where the class is not related
to Interface is known as 'Method reference concept'
=>These Method references are categorized into three types:
(a)reference to Constructor
(b)reference to Instance method
PAGE:265
(c)reference to Static method
(a)reference to Constructor:
=>The process in which abstract method of functional interface
is attached with the body of Constructor is known as reference
to Constructor.
ii
ath
syntax:
Func_Interface ob = Class_name :: new;
ip
Ex:
ITest ob1 = Display :: new;

Ma
(b)reference to Instance method:
sh
is attached with the body of Instance method is known as

ate
reference to Instance method.
syntax:
nk
Func_Interface ob = Object_name :: method_name;
Ex:
Ve
Display d = new Display(100);
ITest ob2 = d :: m1;
(c)reference to Static method :
PAGE:266
is attached with the body of Static method is known as reference
to Static method.
syntax:
Func_Interface ob = Class_name :: method_name;
Ex:
ITest ob3 = Display :: m2;
ii
ath
Diagram:
ip
Ma
sh
ate
nk
Ve
Ex:
ITest.java
package test;
public abstract void dis(int k);
}
PAGE:267
Display.java
package test;
public Display(int x) {
System.out.println("***Constructor body***");
}
System.out.println("***Instance method body***");
}
ii
public static void m2(int z) {
ath
System.out.println("***Static method body***");
}
}
ip
DemoMethodReferences.java(MainClass)
Ma
package maccess;
import test.*;
public class DemoMethodReferences {
ITest ob1 = Display :: new; //reference to Constructor
sh
ob1.dis(123);//Constructor_body_call
Display d = new Display(100);//Con_Call

ate
ITest ob2 = d :: m1; //reference to Instance method

ob2.dis(124);//Instance_method_body_call
ITest ob3 = Display :: m2; //reference to Static method

nk
ob3.dis(125);
}
}
Ve
o/p:
***Constructor body***
The value x:123
***Constructor body***
The value x:100
PAGE:268
***Instance method body***
The value y:124
***Static method body***
The value z:125
=================================================
ii
ip ath
Ma
sh
ate
nk
Ve
PAGE:269
Dt : 3/8/2022
*imp
InnerClasses in Interfaces:
=>We can also declare InnerClasses inside the Interfaces and
which are automatically 'Static member InnerClasses'
ii
*imp
ath
InnerClasses in AbstractClasses:
=>we can also declare InnerClasses in AbstractClasses and
ip
which can be Static member InnerClass or NonStatic member
InnerClass.
Ma
Ex:
sh
ITest.java
package test;
ate

System.out.println("****m2(x)****");
nk
}
System.out.println("****m22(y)****");
Ve

}
}//Static member InnerClass
}//OuterInterface
AClass.java
package test;
public class SubClass22{
PAGE:270
public void m22(int p) {
System.out.println("****m22(p)****");
}
}//Instance member InnerClass
public void m222(int q) {
System.out.println("****m222(q)****");
System.out.println("The value q:"+q);
}
}//Static member InnerClass
ii
}//OuterClass
ath
package maccess;
import test.*;
ip
Ma
System.out.println("-----InnerClass in Interface-----");
ITest.SubClass2 ob1 = new ITest.SubClass2();
ob1.m2(12);
ITest.SubClass2.m22(23);
System.out.println("----Instance Class in AbstractClass-
---");
sh
AClass ob = new AClass() {};
//Object for anonymous extended class
AClass.SubClass22 ob2 = ob.new SubClass22();
ate
ob2.m22(123);
System.out.println("----Static class in AbstractClass---
-");
AClass.SubClass222 ob3 = new AClass.SubClass222();
nk
ob3.m222(234);
}
}
Ve
o/p:
-----InnerClass in Interface-----
****m2(x)****
The value x:12
PAGE:271
****m22(y)****
The value y:23
----Instance Class in AbstractClass----
****m22(p)****
The value p:123
----Static class in AbstractClass----
ii
****m222(q)****
ath
The value q:234
====================================================
ip
*imp
InnerInterfaces in Java:
Ma
(i)Interfaces in Classes:
sh
=>We can also declare InnerInterfaces in Class and which can
be 'Static member InnerInterfaces' or 'NonStatic member

ate
InnerInterfaces'.
nk
(ii)Interface in Interface:(Nested Interfaces)
=>we can also declare InnerInterfaces in Interfaces and

Ve
which are automatically 'Static member InnerInterfaces'.
(iii)Interfaces in AbstractClasses:
=>we can also declare InnerInterfaces in AbstractClasses and
which can be 'Static member InnerInterface' or 'NonStatic member
PAGE:272
InnerInterface'.
Ex:
SubClass.java
package test;
public class SubClass {
public interface ITest2{
ii
}//Instance member InnerInterface
ath
public static interface ITest22{
}//Static member InnerInterface
}//OuterClass
ip
ITest.java Ma
package test;
public void m222(int p);
sh
}//OuterInterface
ate
AClass.java
package test;
public interface ITest3{
nk
public abstract void m3(int a);

}//Instance member InnerInterface
Ve
public abstract void m33(int b);

}//OuterClass
DemoInnerInterface1.java(MainClass)
package maccess;
import test.*;
public class DemoInnerInterface1 {
PAGE:273
System.out.println("----Instance Interface in Class---
");
SubClass.ITest2 ob1 = (int x)->
{
System.out.println("****m1(x)****");
};
ob1.m2(12);
System.out.println("---Static Interface in class----");
SubClass.ITest22 ob2 = (int y)->
ii
{
System.out.println("****m2(y)****");
ath
};
ob2.m22(13);
System.out.println("----Static Interface in Interface---
-");
ip
ITest.ITest222 ob3 = (int p)->
{ Ma
System.out.println("****m222(p)****");
};
ob3.m222(234);
System.out.println("----Instance Interface in AClass----
");
sh
AClass.ITest3 ob4 = (int a)->
{
System.out.println("****m3(a)****");
ate

};
ob4.m3(23);
System.out.println("----Static Interface in AClass-----
nk
");
AClass.ITest33 ob5 = (int b)->
{
System.out.println("****m33(b)****");
Ve

};
ob5.m33(34);
}
}
o/p:
----Instance Interface in Class---
PAGE:274
****m1(x)****
The value x:12
---Static Interface in class----
****m2(y)****
The value y:13
----Static Interface in Interface----
ii
****m222(p)****
ath
The value p:234
----Instance Interface in AClass----
ip
****m3(a)****
The value a:23
----Static Interface in AClass-----

Ma
****m33(b)****
sh
The value b:34
================================================
ate
*imp
InnerAbstractClasses in Java:
nk
(i)InnerAbstractClasses in Classes:
Ve
=>we can also declare InnerAbstractClasses in Classes and
which can be 'Static member InnerAbstractClasses' or 'NonStatic
member InnerAbstractClasses'.
(ii)InnerAbstractClasses in Interfaces:
PAGE:275
=>we can also declare InnerAbstractClasses in Interfaces and
which are automatically 'Static member InnerAbstractClasses'.
(iii)InnerAbstractClasses in AbstractClasses:
(Nested Abstract classes)
=>we can also declare InnerAbstractClasses in AbstractClasses
ii
and which can be 'Static member InnerAbstractClass' or 'NonStatic
ath
member InnerAbstractClass'.
ip
Ex:(Assignment)
Ma
======================================================
Comparision Diagram:
sh
ate
nk
Ve
================================================
PAGE:276
Dt : 4/8/2022
define 'Object' class?
=>'Object' class is from java.lang package and which is default
parent class of all the classes declared in the application.
=>The following are some important methods from
'java.lang.Object' class:
ii
1.hashCode()
ath
2.toString()
3.clone()
ip
4.equals()
5.wait()
6.notify()
Ma
7.notifyAll()
sh
8.finalize()
9.getClass()
ate
Diagram:
nk
Ve
PAGE:277
ii
ip ath
Ma
=============================================================
*imp
sh
Arrays in Java:
=>Array is a Sequenced collection of elements of Same datatype.

ate
(or)
=>Array in Java is a Sequenced Collection of Similer Objects.

nk
(Objects generated from Same class)
=>Arrays are categorized into two types:

Ve
1.Single Dimensional Arrays
2.Multi-Dimensional Arrays
1.Single Dimensional Arrays:
=>The Arrays which are declared with one dimension are known
PAGE:278
as Single Dimensional Arrays or 1-D Arrays.
syntax:
Class_name arr_var[] = new Class_name[size];
Ex-1 : wap to read and display Integer WrapperClass objects?
ii
DemoArray1.java
ath
package maccess;
import java.util.*;
public class DemoArray1 {
ip
System.out.println("Enter the size of Array:");
Ma
int n = s.nextInt();
Integer a[] = new Integer[n];//Integer Array of Size-n
System.out.println("Enter "+n+" Integer Elements:");
for(int i=0;i<a.length;i++)
{
a[i] = new Integer(s.nextInt());
sh
}//end of loop
System.out.println("===Display Using Old loop====");
for(int i=0;i<a.length;i++)
ate
{
System.out.print(a[i].toString()+" ");
}//end of loop
System.out.println("\n====Using Extended
for(Java5)====");
nk
for(Integer k : a)
{
System.out.print(k.toString()+" ");
Ve
}//end of loop
System.out.println("\n===Using
Spliterator<T>(Java8)====");
Spliterator<Integer> sp = Arrays.spliterator(a);
sp.forEachRemaining((k)->
{
System.out.print(k.toString()+" ");
});
s.close();
}
PAGE:279
}
o/p:
Enter the size of Array:
Enter 5 Integer Elements:
ii
12
ath
23
11
ip
2
===Display Using Old loop====

Ma
12 23 11 2 5
sh
====Using Extended for(Java5)====
12 23 11 2 5
ate
===Using Spliterator<T>(Java8)====
12 23 11 2 5
nk
Ve
PAGE:280
ii
ip ath
Ma
======================================================
sh
ate
nk
Ve
PAGE:281
Dt : 5/8/2022
faq:
define 'Extended for' or 'Enhanced for'?
=>'Extended for' introduced by Java5 version and which is used
to retrieve elements from Array objects.
syntax:
ii
for(Class_name var : Container_name)
ath
{
//loop_body
ip
}
Advantage:
Ma
=>In 'Extented for' there is no specification of initialization,
sh
Condition and Incre/Decre.
=>This 'Extended for' is executed automatically based on

ate
Container_name or Array_name.
==========================================================
nk
faq:
define Spliterator<T>?
Ve
=>Spliterator<T> is an interface introduced by Java8 version
and which is used to retrieve elements from Array Objects and
Collection objects.
=>The following is one important method from Spliterator<T>:
public default void forEachRemaining
PAGE:282
(java.util.function.Consumer<? super T>);
=>we use spliterator() method from java.util.Arrays class to
create the implementation object of 'Spliterator<T>' interface.
Method Signature:
public static <T> java.util.Spliterator<T> spliterator(T[]);
syntax:
ii
Spliterator<T> sp = Arrays.spliterator(a);
ath
Ex:
ip
Spliterator<Integer> sp = Arrays.spliterator(a);
Behaviour of spliterator() method?

Ma
=>spliterator() method will create the implementation object of
sh
Spliterator<T> interface.
=>while object creation Spliterator<T> object is binded with

ate
the reference of Array-Object.
=>This spliterator() method also generate cursor pointing

nk
before the first element of Array-object.

Ve
faq:
define Consumer<T>?
=>Consumer<T> is a functional interface from java.util.function
package introduced by Java8 version and which provide abstract
method 'accept()' to hold LambdaExpression passed as parameter
PAGE:283
to forEachRemaining() method.
structure of Consumer<T>:
public interface java.util.function.Consumer<T>
public abstract void accept(T);
ii
}
ip ath
Ma
sh
ate
nk
Ve
PAGE:284
ii
ip ath
Ma
sh
ate
nk
=======================================================
Ve
faq:
define Generic Programming Components?
=>The components which are ready to accept any type of data
are known as Generic Programming Components.
=>The following are the list of Generic Programming Components:
PAGE:285
(a)Generic Types
(b)Generic Methods
(c)Generic Classes
(d)Generic Interfaces
(a)Generic Types:
ii
=>The types which are ready to accept any type of data value
ath
are known as Generic Types.
T - Type
ip
E - Element
K - Key
V - Value
Ma
sh
(b)Generic Methods:
=>The methods which are ready to accept any type of data as

ate
parameters are known as Generic Methods.
Structure:
nk
<T> return_type method_name(T)
{
Ve
//method_body
(c)Generic Classes:
=>The Class object reference which is ready to hold any type
PAGE:286
of object reference is known as generic Class.
Structure:
class Class_name<T>
//class_body
ii
ath
(d)Generic Interfaces:
=>The Interfaces which are implemented to Generic Classes
ip
are knoen as Generic Interfaces.
Structure:
interface Interface_name<T>
Ma
{
sh
//Interface_body
}
ate
============================================================
Assignment:
nk
wap to read and display multiple ProductDetails
(code,name,price,qty) using Array?

Ve
=============================================================
PAGE:287
Dt : 6/8/2022
wap to read and display multiple ProductDetails
(code,name,price,qty) using Array?
ProductDetails.java
ii
package test;
ath
public class ProductDetails extends Object
{
public String code,name;
public float price;
public int qty;
ip
public ProductDetails(String code,String name,float price,int
qty) { Ma
this.code=code;
this.name=name;
this.price=price;
this.qty=qty;
}
public String toString() {
sh
return code+"\t"+name+"\t"+price+"\t"+qty;
}
}
ate
DemoArray2.java(MainClass)
nk
package maccess;
import java.util.*;
Ve
import test.ProductDetails;
System.out.println("Enter the number of ProductDetails:");
PAGE:288
int n = Integer.parseInt(s.nextLine());
ProductDetails pd[] = new ProductDetails[n];
System.out.println("Enter "+n+" ProductDetails:");
for(int i=0;i<pd.length;i++)
System.out.println("Enter the code-"+(i+1));
ii
String code = s.nextLine();
ath
System.out.println("Enter the name-"+(i+1));
ip
System.out.println("Enter the price-"+(i+1));
Ma
float price = Float.parseFloat(s.nextLine());
System.out.println("Enter the qty-"+(i+1));
int qty = Integer.parseInt(s.nextLine());

sh
pd[i] = new ProductDetails(code,name,price,qty);
}//end of loop
ate
System.out.println("====Display ProductDetails=====");
Spliterator<ProductDetails> sp=Arrays.spliterator(pd);
nk
{
Ve
System.out.println(k.toString());
});
s.close();
PAGE:289
o/p:
Enter the number of ProductDetails:
Enter 3 ProductDetails:
Enter the code-1
A121
ii
Enter the name-1
ath
Mouse
Enter the price-1
ip
123.45
Enter the qty-1
12
Ma
Enter the code-2
sh
A111
Enter the name-2

ate
KBBB
Enter the price-2

nk
234.56
Enter the qty-2

Ve
12
Enter the code-3
A131
Enter the name-3
CDRRR
PAGE:290
Enter the price-3
456.78
Enter the qty-3
13
====Display ProductDetails=====
A121 Mouse 123.45 12
ii
A111 KBBB 234.56 12
ath
A131 CDRRR 456.78 13
====================================================
ip
Diagram:
Ma
sh
ate
nk
Ve
======================================================
Assignment:
wap to read and display Multiple Student Details using Array?
o/P:
PAGE:291
rollNo name branch hNO sName city pinCode maildId phno
totMraks per result
===========================================================
faq:
define 'Object' Array?
=>The Array which is declared using 'java.lang.Object' class is
ii
known as 'Object' Array.
ath
syntax:
Object o[] = new Object[size];
ip
Note:
Ma
=>Object Array can hold Dis-Similer objects,which means objects
of different classes.
sh
Ex:
ate
DemoArray3.java
package maccess;
nk
import java.util.*;
import test.ProductDetails;
Ve
Object o[] = new Object[3];
o[0] = new Integer(122);//Integer WrapperClass Object
o[1] = new String("NITHYD");//String Object
PAGE:292
o[2] = new ProductDetails("A202","CDR",12.34F,12);
//User defined ProductDetals class object
System.out.println("====Display Object Array====");
Spliterator<Object> sp = Arrays.spliterator(o);
ii
System.out.println(k.toString());
ath
});
ip
}
o/p:
====Display Object Array====

Ma
122
sh
NITHYD
A202 CDR 12.34 12

ate
=====================================================
2.Multi-Dimensional Arrays:
nk
=>The Arrays which are declared with multiple dimensions are
known as Multi-D Ararys

Ve
Ex:
2-D Arrays
3-D Arrays
4-D Arrays
...
PAGE:293
Note:
=>In realtime Multi-D Arrays are less used when compared to
1-D Arrays,but 2-D Arrays are used to construct 'Jagged Arrays'.
syntax of 2-D Arrays:
ii
Class_name arr_var[][] = new Class_name[size][size];
ath
faq:
ip
define Jagged Array?
Ma
=>The Array which can hold Array objects is known as Jagged
Array.(Array holding Arrays is known as Jagged Array)

sh
Ex:
ate
DemoArray4.java
package maccess;
import java.util.*;
nk

Integer a1[] = {11,12,13};//S-D Array
Ve
Integer a2[] = {21,22,23,24};//S-D Array

Integer a3[] = {11,12,13,14,15};//S-D Array
Integer a4[] = {21,22,23,24,25,26};//S-D Array
Integer a[][] = {a1,a2,a3,a4};//JaggedArray

System.out.println("====Display JaggedARRAY====");
Spliterator<Integer[]> sp1 = Arrays.spliterator(a);
sp1.forEachRemaining((k)->
{
System.out.print("Array : ");
Spliterator<Integer> sp2 = Arrays.spliterator(k);
PAGE:294
sp2.forEachRemaining((z)->
{
System.out.print(z.toString()+" ");
});
System.out.println();
});
}
}
o/p:
ii
====Display JaggedARRAY====
ath
Array : 11 12 13
Array : 21 22 23 24
ip
Array : 11 12 13 14 15
Array : 21 22 23 24 25 26
Ma
======================================================
sh
ate
nk
Ve
PAGE:295
Dt : 8/8/2022
Diagram of Jagged Array:
ii
ip ath
Ma
sh
ate
==================================================
nk
=>In realtime Arrays are categorized into the following:

Ve
(i)Array holding WrapperClass objects
(ii)Array holding String Objects
(iii)Array holding User defined Class objects
(iv)Object Array
(v)Array holding Array objects(Jagged Array)
=========================================================
PAGE:296
Dis-Advantage of Arrays:
=>The Array size once defined cannot be modified at runtime or
executiontime,because of this reason Arrays are not preferable
to hold runtime data or dynamic data.
Note:
ii
=>In realtime Arrays are replaced by Collection<E>
ath
===========================================================
*imp
ip
Java Collection<E> Framework(JCF):
defien Collection<E>?
Ma
=>Collection<E> is an interface from java.util package and
sh
which is root of Java Collection Framework.
=>This Collection<E> interface in extented into the following

ate
Sub-Interfaces:
1.Set<E>
nk
2.List<E>
3.Queue<E>
Ve
Hierarchy of Collection<E>:
PAGE:297
ii
ath
==================================================
faq:
ip
define Framework? Ma
=>The structure which is ready constructed and available for
application development is known as Framework.
Diagram:
sh
ate
nk
Ve
===================================================
PAGE:298
Dt : 9/8/2022
*imp
Complete Structure of JCF:
ii
ip ath
Ma
==================================================
sh
1.Set<E>:
ate
=>Set<E> organizes elements without index values and which
cannot hold duplicate elements.
=>The following are the implementation classes of Set<E>:

nk
(a)HashSet<E>
Ve
(b)LinkedHashSet<E>
(c)TreeSet<E>
(a)HashSet<E>:
=>HashSet<E> organizes elements without any order.
PAGE:299
(b)LinkedHashSet<E>:
=>LinkedHashSet<E> organizes elements in Insertion order.
(c)TreeSet<E>:
=>TreeSet<E> organizes elements automatically in Ascending
order.
ii
ath
Ex_Program : DemoSet1.java
package test;
import java.util.*;
ip
public class DemoSet1 {
Ma
Set<Integer> ob = null;
System.out.println("1.HashSet\n2.LinkedHashSet\n3.TreeSet");
sh
case 1:
ob = new HashSet<Integer>();
break;
ate
case 2:
ob = new LinkedHashSet<Integer>();
break;
case 3:
ob = new TreeSet<Integer>();
nk
break;
default:
System.out.println("Invalid Choice");
Ve
System.exit(0);//stop the program

}//end of switch
System.out.println("Enter number of Integer elements:");
System.out.println("Enter "+n+" Integer Objects:");
for(int i=1;i<=n;i++)
{
ob.add(new Integer(s.nextInt()));
//adding element to Set object
}//end of loop
PAGE:300
System.out.println("====toString()====");
System.out.println(ob.toString());
s.close();
}
}
o/p:
====Choice====
ii
1.HashSet
ath
2.LinkedHashSet
3.TreeSet
Enter the choice:
ip
3 Ma
Enter number of Integer elements:
Enter 5 Integer Objects:

sh
11
ate
10
9
nk
8
Ve
====toString()====
[7, 8, 9, 10, 11]
============================================================
2.List<E>:
=>List<E> organizes elements based on index values and which
can hold duplicate elements.
PAGE:301
=>The following are the implementation classes of List<E>:
(a)ArrayList<E>
(b)LinkedList<E>
(c)Vector<E>
(a)ArrayList<E>:
ii
=>ArrayList<E> organizes elements in Sequence and which is
ath
NonSynchronized class.
ip
(b)LinkedList<E>:
Ma
=>LinkedList<E> organizes elements in NonSequence and which
is also NonSynchronized class.

sh
*imp
(c)Vector<E>:
ate
=>Vector<E> organizes elements in Sequence and which is
Synchronized class.
nk
Ve
PAGE:302
Dt :10/8/2022
(a)ArrayList<E>:
syntax:
ArrayList<Class_name> al = new ArrayList<Class_name>();
ArrayList<Integer> al = new ArrayList<Integer>();
ii
ath
Ex : DemoList1.java
package test;
import java.util.*;
ip
public class DemoList1 {
Ma
ArrayList<Integer> al = new ArrayList<Integer>();
System.out.println("Enter the number of elements to be
added:");
System.out.println("Enter "+n+" Integer elements:");
sh
{
al.add(new Integer(s.nextInt()));//Adding to ArrayList
ate
}//end of loop
System.out.println("====Display ArrayList=====");
System.out.println(al.toString());
System.out.println("====After Sorting====");
Collections.sort(al);//Sorting process
nk
System.out.println("=====Some methods()=====");
System.out.println("size:"+al.size());
Ve
System.out.println("Ele at index 2:"+al.get(2));

al.set(2, new Integer(500));
al.add(1, new Integer(700));
al.remove(1);//delete element by index
int k = al.indexOf(new Integer(12));
int z = al.lastIndexOf(new Integer(12));
System.out.println("index value of ele 12 is : "+k);
PAGE:303
System.out.println("last index value of ele 12 is :
"+z);
System.out.println("===List<E> into Array====");
Object o[] = al.toArray();//Object Array
for(Object p : o)
{
System.out.print(p.toString()+" ");
}//end of loop
System.out.println("\n=====Sorted Array====");
Arrays.sort(o);//Sorting process
for(Object p : o)
ii
{
System.out.print(p.toString()+" ");
ath
}//end of loop
}
}
ip
o/p: Ma
Enter the number of elements to be added:
Enter 6 Integer elements:

sh
11
ate
10
8
nk
5
Ve
19
====Display ArrayList=====
[11, 10, 8, 4, 5, 19]
====After Sorting====
[4, 5, 8, 10, 11, 19]
PAGE:304
=====Some methods()=====
size:6
Ele at index 2:8
[4, 5, 500, 10, 11, 19]
[4, 700, 5, 500, 10, 11, 19]
[4, 5, 500, 10, 11, 19]
ii
index value of ele 12 is : -1
ath
last index value of ele 12 is : -1
===List<E> into Array====
ip
4 5 500 10 11 19
=====Sorted Array====
4 5 10 11 19 500
Ma
sh
ate
nk
Ve
=====================================================
faq:
DisAdvantage of ArrayList<E>:
PAGE:305
=>In ArrayList<E>,when the element is inserted the existing
elements are moved backward and when we perform delete operation
existing elements are moved forward,in this process the execution
time is wasted in moving the elements 'backward and forward' and
which also degrades the performance of an application.
Note:
ii
=>In realtime ArrayList<E> is not preferable in applications
ath
having more number of add and remove operations.
=>DisAdvantage of ArrayList<E> can be overcomed using
ip
LinkedList<E>.
Ma
==========================================================
(b)LinkedList<E>:
=>LinkedList<E> organizes elements in NonSequence and which

sh
is NonSynchronized class.
syntax:
ate
LinkedList<Class_name> ll = new LinkedList<Class_name>();
=>In LinkedList<E> the elements are available in the form of

nk
'nodes'.
=>LinkedList<E> node is divided into the following three

Ve
partitions:
(i)Previous node address
(ii)data
(iii)Next node address
Diagram:
PAGE:306
ii
ip ath
Ex : DemoList2.java
Ma
package test;
import java.util.*;
sh
ate
LinkedList<Integer> ob1 = new LinkedList<Integer>();

//All numbers from 1 to n
//Prime numbers
nk
//Non-Prime numbers
System.out.println("Enter the number of elements to be
added:");
Ve
//adding 1 to n numbers
{
ob1.add(new Integer(i));
}//end of loop
System.out.println("====List<E>===");
System.out.println(ob1.toString());
s.close();
}
PAGE:307
}
o/p:
Enter the number of elements to be added:
10
====List<E>===
ii
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
ath
==============================================================
Dt : 11/8/2022
*imp
ip
(c)Vector<E>: Ma
=>Vector<E> organizes elements in sequence and which is
Synchronized class,which means thread-safe class.
=>Vector<E> is also known as Legacy class,which means very

sh
populer in usage and no replacement from many versions.
ate
=>The following are some important methods from Vector<E>:
public synchronized int capacity();
public synchronized int size();

nk
Ve
public synchronized E elementAt(int);
public synchronized E firstElement();
public synchronized E lastElement();
public synchronized void setElementAt(E, int);
public synchronized void removeElementAt(int);
public synchronized void insertElementAt(E, int);
PAGE:308
public synchronized void addElement(E);
public synchronized boolean removeElement(java.lang.Object);
public synchronized void removeAllElements();
public java.util.Enumeration<E> elements();
ii
ip ath
Ma
sh
ate
nk
Ex : DemoList3.java
Ve
package test;
import java.util.*;
Vector<Integer> v = new Vector<Integer>();
System.out.println("default capacity:"+v.capacity());
System.out.println("Size:"+v.size());
//Adding elements to Vector Object
for(int i=1;i<=10;i++) {
v.addElement(new Integer(i));
PAGE:309
}//end of loop
System.out.println(v.toString());
System.out.println("capacity:"+v.capacity());
v.addElement(new Integer(200));
for(int i=11;i<=19;i++) {
v.addElement(new Integer(i));
}//end of loop
ii
ath
v.addElement(new Integer(700));
ip
System.out.println("FirstElements:"+v.firstElement());
System.out.println("LastElement:"+v.lastElement());
Ma
v.setElementAt(new Integer(800),19 );
s.close();
}
}
sh
o/P:
ate
default capacity:10
Size:0
nk
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
capacity:10
Ve
Size:10
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 200]
capacity:20
Size:11
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 200, 11, 12, 13, 14, 15, 16, 17, 18, 19]
PAGE:310
capacity:20
Size:20
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 200, 11, 12, 13, 14, 15, 16, 17, 18, 19, 700]
capacity:40
Size:21
FirstElements:1
ii
LastElement:700
ath
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 200, 11, 12, 13, 14, 15, 16, 17, 18, 800, 700]
=============================================================
ip
Note:
Ma
=>The default capacity of Vector<E> is 10 elements and when the
length crossed the capacity then the capacity increases
automatically by doubling the capacity.

sh
10==>20==>40...
===========================================================
ate
Note:
=>The following are the constructor from Vector<E>:

nk
public java.util.Vector();
public java.util.Vector(int);
Ve
public java.util.Vector(int,int);
public java.util.Vector(java.util.Collection<? extends E>);
===============================================================
Note:
=>In realtime Vector<E> is used in Connection pooling process.
PAGE:311
faq:
define Connection Pooling Process?
=>The process of organizing multiple pre-initialized DataBase
connections among multiple users is known as Connection Pooling
process.
ii
==========================================================
ath
faq:
define Stack<E>?
ip
=>Stack<E> is a ChildClass of Vector<E> and organizes elements
Ma
based on the algorithm First-in-last-out or Last-in-first-out
=>The following are some important methods of Stack<E>:
public E push(E);
sh
public synchronized E pop();
public synchronized E peek();

ate
public boolean empty();
public synchronized int search(java.lang.Object);

nk
Ex-program : DemoStack.java
Ve
package test;
import java.util.*;
public class DemoStack {
Stack<Integer> ob = new Stack<Integer>();
while(true) {
System.out.println
("1.push()\n2.pop()\n3.peek()\n4.search()\n5.exit");
PAGE:312
case 1:
System.out.println("Enter the element:");
ob.push(new Integer(s.nextInt()));
break;
case 2:
if(ob.empty()) {
System.out.println("Stack is empty....");
}else {
ii
ob.pop();
ath
}
break;
case 3:
if(ob.empty()) {
System.out.println("Stack is empty...");
ip
}else {
Ma
System.out.println("peek element:"+ob.peek());
}
break;
case 4:
if(ob.empty()) {
System.out.println("Stack is empty...");
sh
}else {
System.out.println("Enter the element to
Searched:");
ate
Integer ele = new Integer(s.nextInt());

int pos = ob.search(ele);
if(pos>0) {
System.out.println("ele found at pos
nk
"+pos);
}else {
System.out.println("Ele not found...");
}
Ve
}
break;
case 5:
System.out.println("Stack Operation Stopped...");
System.exit(0);
default:
}//end of switch
}//end of loop
}
PAGE:313
}
=====================================================
Note:
=>search() method searches element from top-of-stack to
Bottom-of-stack and display position of an element.
ii
=============================================================
ip ath
Ma
sh
ate
nk
Ve
PAGE:314
Dt : 12/8/2022
Note:
=>we use Stack<E> and Queue<E> in algorithmic design part of
Vedor enginering.(Product based developments)
==========================================================
*imp
ii
3.Queue<E>:
ath
=>Queue<E> organizes elements based on the algorithm
First-in-First-Out or Last-In-Last-Out.
ip
=>The following are some important methods of Queue<E>:
public abstract boolean add(E);

Ma
public abstract boolean offer(E);
sh
public abstract E remove();
public abstract E poll();

ate
public abstract E element();
public abstract E peek();

nk
=>PriorityQueue<E> is the implementation of Queue<E> through
AbstractQueue<E> and which organizes elements based on elements

Ve
priorities.
PAGE:315
ii
ip ath
Ex : DemoQueue1.java
package test; Ma
import java.util.*;
public class DemoQueue1 {
PriorityQueue<Integer> pq = new
PriorityQueue<Integer>();
sh
for(int i=11;i<=15;i++) {
pq.add(new Integer(i));
}
System.out.println("====Queue<E>====");
ate
System.out.println(pq.toString());
System.out.println("size:"+pq.size());
System.out.println("element:"+pq.element());
System.out.println("peek element:"+pq.peek());
nk
System.out.println("====before poll()====");
Ve
System.out.println("poll element:"+pq.poll());
System.out.println("====After poll()====");
System.out.println("====After remove()====");
pq.remove();
}
}
PAGE:316
o/p:
====Queue<E>====
[11, 12, 13, 14, 15]
size:5
element:11
peek element:11
ii
size:5
ath
====before poll()====
[11, 12, 13, 14, 15]
ip
poll element:11
====After poll()====
[12, 14, 13, 15]

Ma
size:4
sh
====After remove()====
[13, 14, 15]

ate
size:3
==================================================
nk
Note:
=>In realtime PriorityQueue<E> is used in Server designs to

Ve
hold multiple users based on Priorities.
====================================================
faq:
define Deque<E>?
=>Deque<E> means double-ended-queue,in which the elements are
PAGE:317
organized on both ends.
=>In Deque<E> we can add elements on both ends and we can
delete elements on both ends.
ii
ip ath
Ma
Ex : DemoQueue2.java
sh
package test;
import java.util.*;
ate
public class DemoQueue2 {

ArrayDeque<Integer> ad = new ArrayDeque<Integer>();
for(int i=11;i<=15;i++) {
ad.add(new Integer(i));
nk
}
System.out.println(ad.toString());
ad.addFirst(new Integer(500));
Ve
ad.addLast(new Integer(700));
ad.removeFirst();
ad.removeLast();
}
}
PAGE:318
o/p:
[11, 12, 13, 14, 15]
[500, 11, 12, 13, 14, 15, 700]
[11, 12, 13, 14, 15]
==================================================
ii
ip ath
Ma
sh
ate
nk
Ve
PAGE:319
Dt : 18/8/2022
Limitation of Collection<E>:
=>when we use Collection<E> to hold data from DB-Table,it
cannot differentiate Primary Key and Non-Primary Values.
=>This Limitation of Collection<E> can be overcomed using
Map<K,V>.
ii
================================================
ath
*imp
Map<K,V> in Java:
ip
=>Map<K,V> is an interface from java.util package and which
Ma
organizes elements in the form of Key-Value pairs
K - Key(Primary Key)
V - Values(Non-Primary Key values)

sh
=>The following are some important methods of Map<K,V>:
public abstract int size();

ate
public abstract boolean isEmpty();
public abstract boolean containsKey(java.lang.Object);

nk
public abstract boolean containsValue(java.lang.Object);
public abstract V get(java.lang.Object);

Ve
public abstract V put(K, V);
public abstract V remove(java.lang.Object);
public abstract void clear();
public abstract java.util.Set<K> keySet();
public abstract java.util.Collection<V> values();
PAGE:320
public default void forEach
(java.util.function.BiConsumer<? super K, ? super V>);
=>The following are the implementation classes of Map<K,V>:
(a)HashMap<K,V>
(b)LinkedHashMap<K,V>
ii
(c)TreeMap<K,V>
ath
(d)Hashtable<K,V>
Note:
ip
(i)Hashtable<K,V> is synchronized class and remaining classes
are Non-Synchronized classes.

Ma
(ii)HashMap<K,V> and Hashtable<K,V> organize elements without
any order.
sh
(iii)LinkedHashMap<K,V> organizes elements in insertion order.
(iv)TreeMap<K,V> organizes elements automatically in Ascending

ate
order based on Key.(Primary Key)
Hierarchy of Map<K,V>:
nk
Ve
PAGE:321
ii
ip ath
===========================================================
Ma
Ex-Program : Demonstrating Map<K,V> organizing Product Objects
K - code =======> String Object

sh
V - name,price,qty =======>ProductValues Object
ate
syntax:
Map<String,ProductValues>
nk
ProductValues.java
Ve
package test;
public class ProductValues {
public String name;
public float price;
public int qty;
public ProductValues(String name,float price,int qty)
{
this.name=name;
this.price=price;
this.qty=qty;
PAGE:322
}
public String toString() {
return name+"\t"+price+"\t"+qty;
}
}
DemoMap1.java(MainClass)
package test;
import java.util.*;
public class DemoMap1 {
ii
Map<String,ProductValues> m=null;
ath
System.out.println("====Choice=====");
System.out.println
("1.HashMap\n2.LinkedHashMap\n3.Hashtable\n4.TreeMap");
switch(Integer.parseInt(s.nextLine())) {
ip
case 1:
m = new HashMap<String,ProductValues>();
Ma
break;
case 2:
m = new LinkedHashMap<String,ProductValues>();
break;
case 3:
m = new Hashtable<String,ProductValues>();
sh
break;
case 4:
m = new TreeMap<String,ProductValues>();
ate
break;
default:
System.out.println("Invalid Choice...");
System.exit(0);
nk
}//end of switch
System.out.println("Enter the number of Products:");
int n = Integer.parseInt(s.nextLine());
System.out.println("Enter "+n+" Product details:");
Ve
for(int i=1;i<=n;i++) {
System.out.println("Enter the ProductCode"+i);
String code = s.nextLine();
System.out.println("Enter the ProductName"+i);
System.out.println("Enter the ProductPrice"+i);
float price = Float.parseFloat(s.nextLine());
System.out.println("Enter the ProductQty"+i);
int qty = Integer.parseInt(s.nextLine());
PAGE:323
m.put(new String(code),new
ProductValues(name,price,qty));
}//end of loop
System.out.println("===Product Details====");
m.forEach((p,q)->
{
System.out.println(p+"\t"+q);
});
System.out.println("====Product Keys====");
Set<String> st = m.keySet();
st.forEach((k)->
ii
{
System.out.println(k);
ath
});
System.out.println("====Product Values====");
Collection<ProductValues> c = m.values();
c.forEach((z)->
{
ip
System.out.println(z);
}); Ma
s.close();
}
}
sh
o/p:
ate
====Choice=====
1.HashMap
nk
2.LinkedHashMap
3.Hashtable
Ve
4.TreeMap
Enter the Choice:
Enter the number of Products:
PAGE:324
Enter 3 Product details:
Enter the ProductCode1
A121
Enter the ProductName1
Mouse
Enter the ProductPrice1
ii
1200
ath
Enter the ProductQty1
12
ip
A111

Ma
KBBB
sh
1300
ate
13
nk
A101
Ve
CDRRR
1400
PAGE:325
14
===Product Details====
A121 Mouse 1200.0 12
A111 KBBB 1300.0 13
A101 CDRRR 1400.0 14
====Product Keys====
ii
A121
ath
A111
A101
ip
====Product Values====
Mouse 1200.0 12
KBBB 1300.0 13
Ma
CDRRR 1400.0 14
sh
=============================================================
ate
nk
Ve
PAGE:326
Dt : 19/8/2022
Diagram:
ii
ip ath
Ma
sh
ate
nk
Ve
===========================================================
faq:
define forEach() method?
=>forEach() method introduced by Java8 version and which is
PAGE:327
used to retrieve elements from Collection<E> objects and Map<K,V>
objects.
Method Signature of forEach() on Collection<E>:
(java.util.function.Consumer<? super T>);
ii
ath
Method Signature of forEach() on Map<K,V>:
ip
(java.util.function.BiConsumer<? super K, ? super V>);
faq:
Ma
define Consumer<T>?
sh
=>Consumer<E> is a functional interface from java.util.function
package introduced by Java8 version and which provide abstract

ate
method to hold LambdaExpression passed as passed as parameter
to forEach() method on Collection<E> objects.

nk
structure of Consumer<T>:
Ve
public interface java.util.function.Consumer<T>
public abstract void accept(T);
PAGE:328
faq:
define BiConsumer<T,U>?
=>BiConsumer<T,U> is a functional interface from
java.util.function package introduced by Java8 version and which
provide abstract method to hold LambdaExpression passed as passed
as parameter to forEach() method on Map<K,V> objects.
ii
ath
structure of BiConsumer<T,U>:
public interface java.util.function.BiConsumer<T, U>
ip
{
}
public abstract void accept(T, U);
Ma
sh
=======================================================
faq:
ate
define keySet() method?
=>keySet() method is used to retrieve all keys from the Map<K,V>

nk
object.
Ve
syntax:
Set<String> st = m.keySet();
faq:
define values() method?
PAGE:329
=>values() method is used to retrieve all Non-Primary key values
from Map<K,V> object.
syntax:
Collection<ProductValues> c = m.values();
===========================================================
ii
Assignment:
ath
Construct Application to read and display Complete Student
details using Map<K,V>
ip
========================================================
*imp
Ma
Cursor Statements in Java Collection Framework(JCF):
=>The following are some important Cursor Statements in JCF:

sh
1.Iterator<E>
2.ListIterator<E>
ate
3.Enumeration<E>
4.Spliterator<T>
nk
Ex : CursorStatements.java
Ve
package test;
import java.util.*;
public class CursorStatements {
Vector<Integer> v = new Vector<Integer>();
for(int i=1;i<=10;i++)
{
v.add(new Integer(i));
}//end of loop
System.out.println("====Iterator<E>====");
PAGE:330
Iterator<Integer> it1 = v.iterator();
while(it1.hasNext()) {
System.out.print(it1.next()+" ");
}//end of loop
System.out.println("\n====Iterator<E> Java8====");
it2.forEachRemaining((k)->
{
System.out.print(k+" ");
});
System.out.println("\n====ListIterator<E>====");
ii
ListIterator<Integer> li = v.listIterator();
System.out.print("Forward : ");
ath
while(li.hasNext()) {
System.out.print(li.next()+" ");
}//end of loop
System.out.print("\nBackward : ");
while(li.hasPrevious()) {
ip
System.out.print(li.previous()+" ");
}//end of loop Ma
System.out.println("\n====Enumeration<E>====");
Enumeration<Integer> e = v.elements();
while(e.hasMoreElements()) {
System.out.print(e.nextElement()+" ");
}//end of loop
System.out.println("\n====Spliterator<T>=====");
sh
Spliterator<Integer> sp = v.spliterator();
sp.forEachRemaining((z)->
{
ate
System.out.print(z+" ");
});
}
}
nk
o/p:
Ve
====Iterator<E>====
1 2 3 4 5 6 7 8 9 10
====Iterator<E> Java8====
1 2 3 4 5 6 7 8 9 10
====ListIterator<E>====
PAGE:331
Forward : 1 2 3 4 5 6 7 8 9 10
Backward : 10 9 8 7 6 5 4 3 2 1
====Enumeration<E>====
1 2 3 4 5 6 7 8 9 10
====Spliterator<T>=====
1 2 3 4 5 6 7 8 9 10
ii
===========================================================
ip ath
Ma
sh
ate
nk
Ve
PAGE:332
Dt : 20/8/2022
1.Iterator<E>:
=>Iterator<E> is an interface from java.util package and
which is used to retrieve elements from Collection<E> objects
in forward direction.
=>The following are some important methods of Iterator<E>:
ii
ath
public abstract boolean hasNext();
public abstract E next();
ip
public default void remove();
public default void forEachRemaining

Ma
(java.util.function.Consumer<? super E>);
sh
=>we use 'iterator()' method to create the implementation
object for Iterator<E> interface and the object will hold the
ate
reference of Collection<E> object,in this process one cursor
generated poiting before the first element of Collection<E>

nk
objects.
Ve
===================================================
Note:
=>By Java8 version Iterator<E> is added with remove() and
forEachRemaining() methods.
PAGE:333
=====================================================
2.ListIterator<E>:
=>ListIterator<E> is an interface from java.util package and
which is used to retrieve elements from List<E> objects in both
directions forward and backward.
=>ListIterator<E> is a Child Interface of Iterator<E>
ii
=>The following are some important methods of ListIterator<E>:
ath
public abstract boolean hasNext();
public abstract E next();
ip
public abstract boolean hasPrevious();
public abstract E previous();
public abstract int nextIndex();

Ma
public abstract int previousIndex();
sh
public abstract void remove();
public abstract void set(E);

ate
public abstract void add(E);
=>we use listIterator() method to create the implementation

nk
object of ListIterator<E> interface and the object will hold
the reference of Collection<E> object,in this process one

Ve
cursor generated pointing before the first element.
syntax:
ListIterator<Integer> li = v.listIterator();
===========================================================
PAGE:334
faq:
wt is the diff b/w
(i)Iterator<E>
(ii)ListIterator<E>
=>Iterator<E> is used to retrieve elements from Collection<E>
ii
objects in forward dirtection,but ListIterator<E> is used to
ath
retrieve elements only from List<E> objects in two directions.
=>Iterator<E> is a Parent Interface of ListIterator<E>
ip
=========================================================
*imp
3.Enumeration<E>:
Ma
=>Enumeration<E> is an interface from java.util package and
sh
which is used to retrieve elements from Vector<E> objects in
forward direction.
ate
=>The following are some important methods of Enumeration<E>:
public abstract boolean hasMoreElements();

nk
public abstract E nextElement();
public default java.util.Iterator<E> asIterator();

Ve
=>we use 'elements()' method to create the implementation
object for Enumeration<E> interface and the object will hold
the reference of Vector<E> object,in this process one cursor
generated pointing before the first element.
PAGE:335
syntax
Enumeration<Integer> e = v.elements();
4.Spliterator<T>:(Java8)
=>Spliterator<T> is an interface from java.util package and
which is used to retrieve elements from both Collection<E>
ii
objects and Array Objects.
ath
syntax:
ip
Spliterator<Integer> sp = v.spliterator();
Ma
=========================================================
sh
ate
nk
Ve
PAGE:336
Dt : 22/8/2022
*imp
define Enum<E>?
=>Enum<E> is an abstract class from java.lang package and
which is also known as Enumerated datatype.
=>To create implemented objects or extended objects for Enum<E>
ii
we use 'enum' keyword as follows:
ath
enum Enum_name
ip
{
//elements
//variables
Ma
//methods
sh
}
ate
=>enum is a collection of Elements,Variables and Methods.
=>Each element in enum internally generated as one enum-object

nk
and all enum-objects are organized based on Array object.
=>The constructors which are declared in enum are automatically

Ve
private constructors.
Diagram:
PAGE:337
ii
ath
Ex:
ip
Cars.java
package test;
public enum Cars {
Ma
figo(900),alto(500),dezire(700);
public int price;
private Cars(int price) {
sh
this.price=price;
}
public int getPrice() {
return price;
ate
}
}
nk
DemoMailClass.java(MainClass)
package test;
Ve
import java.util.*;
public class DemoMainClass {
Cars c[] = Cars.values();
System.out.println("====Display Enum<E> elements=====");
Spliterator<Cars> sp = Arrays.spliterator(c);
{
System.out.println(k.toString()+" Costs
"+k.getPrice()+
" thousand Dollars");
PAGE:338
});
}
}
o/p:
====Display Enum<E> elements=====
figo Costs 900 thousand Dollars
ii
alto Costs 500 thousand Dollars
ath
dezire Costs 700 thousand Dollars
=========================================================
Note:
ip
=>In realtime,Enum<E> is less used when compared to Classes
Ma
and Interfaces.
=========================================================
*imp
sh
Summary of Objects created from CoreJava:
ate
1.User defined Class objects
2.String Objects
3.WrapperClass Objects
nk
4.Array Objects
Ve
5.Collection<E> Objects
6.Map<K,V> Objects
7.Enum<E> Objects
Complete List of Objects:
1.User defined Class objects
PAGE:339
2.String Objects
(a)String objects
(b)StringBuffer Objects
(c)StringBuilder Objects
3.WrapperClass Objects
(a)Byte Objects
ii
(b)Short Objects
ath
(c)Integer Objects
(d)Long Objects
ip
(e)Float Objects
(f)Double Objects
(g)Character Objects
Ma
(h)Boolean Objects
sh
4.Array Objects
(a)Array holding User defined class objects

ate
(b)Array holding String Objects
(c)Array holding WrapperClass Objects

nk
(d)Array holding Array Objects(Jagged Array)
(e)Array holding Dis-Similer Objects(Object Array)

Ve
5.Collection<E> Objects
(a)Set<E> Objects
(i)HashSet<E> objects
(ii)LinkedHashSet<E> objects
(iii)TreeSet<E> Objects
PAGE:340
(b)List<E> Objects
(i)ArrayList<E> Objects
(ii)LinkedList<E> Objects
(iii)Vector<E> Objects
=>Stack<E> Objects
(c)Queue<E> Objects
ii
(i)PriorityQueue<E> Objects
ath
=>Deque<E> Objects
(ii)ArrayDeque<E> Objects
ip
(iii)LinkedList<E> Objects
6.Map<K,V> Objects
(a)HashMap<K,V> Objects
Ma
(b)LinkedHashMap<K,V> Objects
sh
(c)TreeMap<K,V> Objects
(d)Hashtable<K,V> Objects
ate
7.Enum<E> Objects
=======================================================
nk
faq:
wt is the diff b/w

Ve
(i)Container Objects
(ii)Utility Objects
(iii)Cursor Objects
(i)Container Objects:
PAGE:341
=>The objects which hold data elements are known as Container
Objects.
(ii)Utility Objects:
=>The objects which perform operations on other objects are
known as Utility Objects.
ii
Ex:
ath
Scanner
StringTokenizer
ip
StringJoiner
Collections
Arrays
Ma
sh
(iii)Cursor Objects:
=>The objects which are used to retrieve elements from other

ate
objects like Arrays,Collection and Map are known as Cursor Objects.
Ex:
nk
Iterator
ListIterator
Ve
Enumeration
Spliterator
==========================================================
PAGE:342
Dt : 23/8/2022
*imp
Exception Handling Process:
define Exception?
=>The distrubance which is occured from the application is
known as Exception.
ii
ath
define Exception Handling Process?
=>The process which is used to handle the exception is known
ip
as Exception handling process.
Ma
=>we use the following blocks in Exception handling process:
1.try block
2.catch block
sh
3.finally block
=>These blocks are executed automatically when the exception is

ate
raised.
nk
1.try block:
=>try block will hold the statements which are going to raise
Ve
the exception.
syntax:
try
//statements;
PAGE:343
}
Execution behaviour:
=>when exception raised in try-block then automatically one
object is created for Exception-type-class and the object
reference is throwm onto catch block.
ii
ath
2.catch block:
=>catch block will hold the object reference thrown from the
ip
try block and the required message is generated from catch block
syntax:
Ma
catch(Exception_Type_Class ref_var)
sh
{
//msg
ate
3.finally block:
nk
=>finally block is part of exception handling process but
executed independently without depending on exception.

Ve
=>In realtine finally block will hold resource closing
operations like IO close,file close,DB Close,...
syntax:
finally
PAGE:344
//set-of-statement(resource closing operations)
Diagram:
ii
ip ath
Ma
sh
Ex:
Average.java
ate
package test;
public class Average {
public float avg(int x,int y,int z) {
return (float)(x+y+z)/3;
nk
}
}
Ve
DemoException1.java
package maccess;
import test.Average;
import java.util.*;
public class DemoException1 {
PAGE:345
try
System.out.println("Enter the Value-1:");
ii
ath
ip
Ma
float result = new Average().avg(v1, v2, v3);
System.out.println("Average:"+result);
sh
}//end of try
catch(InputMismatchException ob)
ate
System.out.println("Enter Only Integer Values....");

nk
finally
Ve
s.close();
PAGE:346
}
o/p:
Enter the Value-1:
Enter the Value-2:
ii
Enter the Value-3:
ath
3
Average:2.0
ip
===================================================
faq:
define try-with-resource statement?

Ma
=>The process of declaring resources with try is known as
sh
try-with-resource statement introduced by Java7 version.
syntax:
ate
try(resource1;resource2;...)
{
nk
//statements
}
Ve
Ex:
try(Scanner s = new Scanner(System.in);)
//statements
PAGE:347
}
Advantage:
=>In try-with-resource statement the resources are closed
automatically,which means 'finally' block is not needed.
=>In try-with-resource statement catch block is an optional
ii
block.
ath
Ex : DemoException2.java(MainClass)
ip
package maccess;
import java.util.*;
Ma
sh
ate
try(Scanner s = new Scanner(System.in);)//Java7
{
nk
try
{
Ve
PAGE:348
}//end of try
ii
{
ath
ip
}//end of try with resource
}
}
Ma
====================================================
sh
faq:
define Enhanced try-with-resource statement?

ate
=>In Enhanced try-with-resource statement the resources are
declared outside the try block and the resource_ref_variables

nk
are declared with try and which is introduced by Java9 version.

Ve
syntax:
resource1;resource2;...
try(res1_var;res2_var;...)
//statements
PAGE:349
}
Ex:
try(s;)
ii
//statements
ath
}
ip
Ex : DemoException3.java(MainClass)
package maccess;
Ma
import java.util.*;
sh

ate
try(s;)//Java9
nk
try
Ve
PAGE:350
}//end of try
ii
ath
{
ip
}
}
Ma
}
sh
========================================================
Coding Rule:
ate
=>The resources which are used in try-with-resource statement
must be implementations of 'java.lang.AutoCloseable' interface.

nk
=======================================================
Ve
PAGE:351
Dt : 24/8/2022
faq:
define 'Throwable'?
=>'Throwable' is a class from java.lang package and which is
root of Exception Handling process.
=>The following are some important constructors and methods of
ii
Throwable:
ip ath
public java.lang.Throwable();
Ma
public java.lang.Throwable(java.lang.String);
public java.lang.Throwable
(java.lang.String, java.lang.Throwable);
sh
public java.lang.Throwable(java.lang.Throwable);
protected java.lang.Throwable
ate
(java.lang.String, java.lang.Throwable, boolean,boolean);

nk
public java.lang.String getMessage();
public java.lang.String toString();

Ve
public void printStackTrace();
=>This 'Throwable' class is extended into the following
SubClasses:
(a)Error class
PAGE:352
(b)Exception class
Hierarchy of Throwable:
ii
ip ath
===================================================
Ma
(a)Error class:
=>The distrubance which is occured from the environment(JDK)

sh
is known as error
=>java.lang.Error class is the SuperClass or ParentClass of

ate
all the errors raised from the environment.
=>There is no separate process to handle the error.

nk
*imp
Ve
(b)Exception class:
=>java.lang.Exception class is the SuperClass or ParentClass
of all the exceptions raised from the application.
=>All exceptions raised from the application are categorized
into two types:
PAGE:353
1.UnChecked Exceptions
2.Checked Exceptions
1.UnChecked Exceptions:
=>The exceptions which are not identified by the compiler
at compilation stage will be raised at execution stage are known
ii
as UnChecked Exceptions or Runtime Exceptions.
ath
2.Checked Exceptions:
ip
=>The Exceptions which are identified by the compiler and raised
Ma
at compilation stage are known as Checked Exceptions or
CompileTime Exceptions.
sh
Diagram:
ate
nk
Ve
PAGE:354
==========================================================
*imp
Types of UnChecked Exceptions:
=>UnChecked Exceptions are categorized into two types:
(i)Pre-defined UnChecked Exceptions
(ii)User defined UnChecked Exceptions
ii
ath
(i)Pre-defined UnChecked Exceptions:
=>The UnChecked Exceptions which are already defined and
ip
available from JavaLib are known as Pre-defined UnChecked
Exceptions or Built-in UnChecked Exceptions.
Ex:
Ma
java.util.InputMismatchException
sh
java.lang.NumberFormatException
...
ate
Note:
=>In pre-defined UnChecked Exceptions the objects are created

nk
automatically and the object reference is thrown onto catch
block automatically.
Ve
--------------------------------------------------------
*imp
(ii)User defined UnChecked Exceptions:
=>The UnChecked Exceptions which are defined and raised by the
programmer are known as user defined UnChecked Exceptions.
PAGE:355
=>Use the following process to define and raise User defined
UnChecked Exceptions:
step-1 : The user defined class must be extended from
java.lang.Exception class
ii
step-2 : The user defined class must be declared with String
ath
parameterized constructor and which pass the msg to the
parent class(Exception).
ip
step-3 : use try-catch blocks
Ma
step-4 : define the condition to raise the Exception.
sh
step-5 : If the Exception-condition is true,then raise the

ate
Exception which means create object for user defined
class and pass Exception-msg as parameter while object

nk
creation
step-6 : we use 'throw' keyword to throw the object reference

Ve
on to catch block
step-7 : Display the msg from catch block
Ex :
PAGE:356
EmployeeSalary.java
package test;
public class EmployeeSalary {
public float calculate(int bSal) {
return bSal+(0.93F*bSal)+(0.63F*bSal);
}
}
DemoException4.java
ii
package maccess;
ath
import java.util.*;
ip
public class DemoException4 extends Exception
public DemoException4(String msg)

Ma
{
sh
super(msg);
}
ate
{
nk
try(s;){
Ve
try
System.out.println("Enter the bSal:");
int bSal = s.nextInt();
if(bSal<12000)//Exception-Condition
PAGE:357
{
DemoException4 ob = new DemoException4
("Invalid bSal...");
throw ob;//throwing the reference onto catch block
float totSal = new EmployeeSalary().calculate(bSal);
ii
System.out.println("Bsal:"+bSal);
ath
System.out.println("TotSal:"+totSal);
}//end of try
ip
catch(DemoException4 ob)
{
Ma
//System.out.println(ob.getMessage());
// System.out.println(ob.toString());
sh
ob.printStackTrace();
}
ate
{
nk
System.out.println("Enter only Integer value...");
}
Ve
}//end of try-with-resource
===========================================================
Dt : 25/8/2022
PAGE:358
ii
ip ath
Note:
=>getMessage() method will display only exception message.

Ma
=>toString() method will display Class_name and message.
=>printStackTrace() method will display Class_name,method_name,

sh
Line_no and msg
==========================================================
ate
faq:
define "throw" keyword?

nk
=>In the process of handling exception we use 'throw' keyword
to throw the object reference onto catch block.

Ve
========================================================
*imp
Types of Checked Exceptions:
=>Checked Exceptions are categorized into two types:
(i)Pre-defined CheckedExceptions
PAGE:359
(ii)User defined CheckedExceptions
(i)Pre-defined CheckedExceptions:
=>The CheckedExceptions which are defined and available from
JavaLib are known as Pre-defined CheckedExceptions or Built-in
CheckedExceptions.
ii
Ex:
ath
java.lang.InterruptedException
java.lang.CloneNotSupportedException
ip
java.lang.ClassNotFoundException
java.io.IOException
...
Ma
sh
define sleep() method?
=>sleep() method is a Pre-defined static method from

ate
java.lang.Thread class and which is used to stop the execution
temporarly on some time.

nk
Method Signature:
public static native void sleep(long)

Ve
throws java.lang.InterruptedException;
Diagram:
PAGE:360
ii
ath
ip
syntax:
Thread.sleep(time);
-------------------------------------------------------
Ma
Note:
sh
=>'throws' keyword specify to ignore the exception in current
method and raise at method call.

ate
=>If the exception raised at method_call then the compiler will
identify the exception and the exception comes under Compiletime

nk
exception or CheckedException.
=================================================
Ve
Ex-program:
package maccess;
{
{
System.out.println("Value : "+i);
try
PAGE:361
{
Thread.sleep(5000);
//Execution Stopped for 50000
milliSecons
}//end of try
catch(InterruptedException ie)
{
ie.printStackTrace();
}
}//end of loop
}
ii
}
ath
o/p:
Value : 1
ip
Value : 2
Value : 3
Value : 4
Ma
Value : 5
sh
Value : 6
Value : 7
ate
Value : 8
Value : 9
nk
Value : 10
====================================================
Ve
PAGE:362
Dt : 26/8/2022
*imp
(ii)User defined CheckedExceptions:
=>The CheckedExceptions which are defined and raised by the
programmer are known as User defined CheckedExceptions
=>we use the following two steps to define and raise User
ii
defined CheckedExceptions:
ath
Step-1 : Add 'throws' keyword to the method Signature and ignore
ip
the exception in Current method and raise at methodCall
Ma
Step-2 :Declare 'throw' keyword in catch block to perform
re-throwing process
sh
Ex-Program:
CheckPinNo.java
ate
package test;
@SuppressWarnings("serial")
public class CheckPinNo extends Exception
{
nk
public CheckPinNo() {}
public CheckPinNo(String msg)
{
Ve
super(msg);
}
public void verify(int pinNo)throws CheckPinNo
{
try
{
if(!(pinNo==1111 || pinNo==2222 ||
pinNo==3333))//Exception_Condition
{
CheckPinNo cpn=new CheckPinNo("Invalid PinNo");
//Con_Call
PAGE:363
throw cpn;//reference thrown to catch block
}
}//end of try
catch(CheckPinNo cpn)
{
throw cpn;//re-throwing process
}
}
}
ii
DemoException6.java(MainClass)
ath
package maccess;
import test.*;
import java.util.*;
@SuppressWarnings("serial")
ip
public class DemoException6 extends Exception
{ Ma
public DemoException6(String msg)
{
super(msg);
}
sh
try(s;)
{
try
ate
{
System.out.println("Enter the PinNo:");
CheckPinNo ob = new CheckPinNo();//Con_Call
nk
ob.verify(pinNo);//Method Call
System.out.println("Enter the amt:(withDraw)");
int amt = s.nextInt();
if(!(amt>0 && amt%100==0))//Exception-Condition
Ve
{
DemoException6 de = new DemoException6
("Invalid Amt..");
throw de;
}
if(amt>2000)//Exception-Condition
{
DemoException6 de = new DemoException6
("Insufficient Fund...");
throw de;
PAGE:364
}
System.out.println("Amt WithDrawn:"+amt);
System.out.println("Balancd Amt:"+(2000-amt));
}//end of try
catch(CheckPinNo cpn)
{
System.out.println(cpn.getMessage());
}
catch(DemoException6 de)
{
ii
System.out.println(de.getMessage());
}
ath
}
}
ip
Dt : 29/8/2022
Diagram:
Ma
sh
ate
nk
Ve
PAGE:365
ii
ip ath
Ma
sh
ate
============================================================
faq:
nk
define Exception re-throwing process?
=>The process of declaring 'throw' keyword in catch block and

Ve
throwing the exception is known as Exception re-throwing process.
Note:
=>In exception re-throwing process the exception is moved to
the catch block of try block where the method call is declared.
PAGE:366
faq:
define Exception Propagation?
=>In Exception re-throwing process the exception is moved from
one method to another method known as Exception Propagation.
===========================================================
ii
faq:
ath
wt is the diff b/w
(i)throw
ip
(ii)throws
(i)throw:
Ma
=>In the process of handling exception we use 'throw' keyword
sh
to move the object reference on to catch block.
ate
(ii)throws:
=>'throws' keyword is added with method signature and ignores

nk
the exception in current method and raise at method_call.
('throws' keyword is available in CheckExceptions)

Ve
========================================================
*imp
Handling Multiple exceptions:
=>we use the following two ways to handle multiple exceptions:
(a)Using multiple catch blocks
PAGE:367
(b)Using Single catch block
(a)Using multiple catch blocks:
=>we use multiple catch blocks to a try block to handle
Multiple exceptions.
ii
syntax:
ath
try
ip
//Exception1
}
//Exception2
Ma
catch(Exception1 ob1)
sh
{
//msg
ate
catch(Exception2 ob2)
nk
//msg
Ve
(b)Using Single catch block:
=>From Java7 version onwards we can use single catch block
to hold multiple exceptions.
PAGE:368
syntax:
try
//Exception1
//Exception2
ii
}
ath
catch(Exception1 | Exception2 | ... ob)
ip
//msg
}
Ma
======================================================
faq:
sh
define 'java.lang.NullPointerException'?
=>This 'java.lang.NullPointerException' is raised when we

ate
use Non-Primitive datatype variables assigned with 'null' values.
=======================================================
nk
faq:
define Encapsulation process?

Ve
=>The process of binding all the programming components into a
single unit 'class' is known as Encapsulation process.
Comparision diagram:
PAGE:369
ii
ip ath
Ma
sh
==================================================
Assignment:
ate
Convert BankTransaction process into Exception Handling process.
Note:
nk
=>Convert else block messages into catch block messages
=====================================================
Ve
PAGE:370
Ve
nk
ate
sh
PAGE:371
Ma
ip ath
ii
Dt : 30/8/2022
*imp
Multi-Threading in Java:
define Program?
=>Program is a set-of-Instructions.
ii
define Application?
ath
=>Set-of-programs collected together to perform
defined action is known as application.
ip
*imp
define process?
Ma
=>According to Java developer,Application under
sh
execution is a process.
ate
Ex:
https://www.irctc.co.in
nk
http://www.UserApp.com
Ve
PAGE:372
ii
ip ath
define Task? Ma
=>The part of process is known as Task
Note:
sh
=>Each program in application is a Task,which
means each server program or Servlet program is a

ate
Task.
nk
define Multi-Tasking?
=>Executing multiple tasks Simultaneously is known

Ve
as Multi-Tasking.
Note:
=>Simultaneously means at-a-time but not parallel
define Thread based Multi-Tasking?
PAGE:373
=>Executing multiple tasks from the same
application is known as Thread based Multi-Tasking.
*imp
define Thread?
=>part of task is known as Thread.
ii
ath
Note:
=>Thread is a BackGround and Light Weight process.
ip
backGround process - no separate identification
Ma
LightWeight process - Consume less execution
time
=>Thread is also known as Child Process.

sh
define Multi-Threading?
ate
=>Executing Multiple threads Simultaneously is
known as Multi-Threading.
nk
==========================================
Ve
PAGE:374
Dt : 2/9/2022
*imp
Creating and Executing Thread:
step-1 : The user defined classes must be implemented
from java.lang.Runnable interface.
ii
ath
structure of Runnable:
public interface java.lang.Runnable
ip
{
}
public abstract void run();
Ma
sh
step-2 : The User defined implementation classes must
Construct body for run() method.

ate
step-3 :Create objects for User defined implementation

nk
classes.
Ve
step-4 : Create object for 'java.lang.Thread' class
and while object creation pass User defined
implementation class object reference as
parameter.
PAGE:375
step-5 : Call run() method for execution using start()
method.
Ex :
Display1.java
package test;
public class Display1 implements Runnable{
ii
public void run()
ath
{
{
System.out.println("Task-1 : "+i);
try {
ip
Thread.sleep(2000);
}catch(InterruptedException ie) {}
Ma
}//end of loop
}
}
Display2.java
sh
package test;
public class Display2 implements Runnable{
ate
public void run()

{
for(int i=101;i<=105;i++)
{
nk
try {
Thread.sleep(2000);
Ve
}//end of loop
}
}
DemoThread1.java(MainClass)
package maccess;
import test.*;
public class DemoThread1 {
PAGE:376
Display1 d1 = new Display1();
Display2 d2 = new Display2();
Thread t1 = new Thread(d1);

t1.start();//call run() from d1

ii
}
ath
o/p:
Task-1 : 1
ip
Task-2 : 101
Task-1 : 2
Task-2 : 102
Ma
Task-1 : 3
sh
Task-2 : 103
Task-1 : 4
ate
Task-2 : 104
Task-1 : 5
nk
Task-2 : 105
-----------------------------------------
Ve
PAGE:377
ii
ip ath
Ma
sh
ate
nk
Ve
====================================================
*imp
Creating threads using 'Anonymous InnerClass as
implementation classes'
=>In this model we declare user defined implementation
classes without name.
PAGE:378
Ex:
package maccess;
Runnable d1 = new Runnable()

{
ii
public void run()
ath
{
{
try {
ip
Thread.sleep(2000);
Ma
}//end of loop
}
};
Runnable d2 = new Runnable()

{
sh
public void run()
{
for(int i=101;i<=105;i++)
ate
{
try {
Thread.sleep(2000);
nk
}//end of loop
}
};
Ve


}
}
PAGE:379
=====================================================
*imp
Creating thread using 'LambdaExpressions'.
=>In this model run() method declared without name,
which means run() method as LambdaExpression.
ii
Ex:
ath
package maccess;
ip
Runnable d1 = ()->
{
Ma
{
try {
sh
Thread.sleep(2000);
}//end of loop
ate
};
Runnable d2 = ()->
{
for(int i=101;i<=105;i++)
nk
{
try {
Ve
Thread.sleep(2000);
}//end of loop
};


PAGE:380
}
}
===================================================
*imp
Creating thread using "Method References".
ii
=>In this model run() method is attached with the
ath
body of method from User defined class and which is
not related to 'Runnable' interface.
ip
Ex: Ma
Display1.java
package test;
public class Display1
{
sh
public static void dis1()
{
ate
{
try {
Thread.sleep(2000);
nk
}//end of loop
}
}
Ve
Display2.java
package test;
public class Display2
{
public static void dis2()
{
for(int i=101;i<=105;i++)
PAGE:381
{
try {
Thread.sleep(2000);
}//end of loop
}
}
ii
package maccess;
ath
import test.*;
new Thread(Display1 :: dis1).start();
new Thread(Display2 :: dis2).start();
ip
}
} Ma
===============================================
Dt : 3/9/2022
sh
faq:
define UnSafe state of an application?

ate
=>If more than one user requested same resource
(Class,Object,method)of an application then the

nk
application is executing in UnSafe state.
=>These UnSafe state applications will generate

Ve
deadlocks or Wrong results.
Note:
=>we can use 'Thread Synchronization' process to
convert UnSafe state application into Safe State
PAGE:382
application.
=============================================
*imp
define Thread Synchronization?
=>The process of ordering multiple threads for
execution is known as Thread Synchronization process.
ii
=>Thread Synchronization process can be done in two
ath
ways:
1.Mutual Exclusion process
ip
2.Thread Communication
1.Mutual Exclusion process:

Ma
=>The process of locking the programming resources
sh
and ordering the threads for execution is known as
Mutual Exclusion process.

ate
=>Mutual Exclusion can be done in three ways:
(a)synchronized block - Object locking

nk
(b)synchronized method - Instance method lock
(c)Static synchronization - Class lock

Ve
(a)synchronized block - Object locking:
=>The set-of-statements which are declared with
synchronized keyword is known as 'synchronized block'
=>synchronized block is used to lock objects.
PAGE:383
syntax:
synchronized(obj_ref_var)
//statements
ii
ath
Diagram:
ip
Ma
sh
ate
nk
Ve
Ex:
Printer.java
package test;
public class Printer {
public void print(int n,String name) {
System.out.println(i+" print for User "+name);
try {
PAGE:384
Thread.sleep(2000);
}//end of loop
}
}
User1.java
package test;
public class User1 implements Runnable{
public Printer p;
ii
public User1(Printer p) {
ath
this.p=p;
}
public void run()
{
synchronized(p)//Locking object
ip
{
p.print(5, "Raj"); Ma
}
}
}
User2.java
sh
package test;
ate
public Printer p;
this.p=p;
}
nk
public void run()

{
synchronized(p)//Locking Object
{
Ve
p.print(5,"Ram");
}
}
}
package maccess;
import test.*;
PAGE:385
Printer p = new Printer();
User1 ob1 = new User1(p);

Thread t1 = new Thread(ob1);

t1.start();
ii
t2.start();
}
ath
}
o/p:
ip
1 print for User Raj

Ma
sh
1 print for User Ram

ate

nk

Ve
================================================
Assignment:
Convert above application into lambdaExpression.
=============================================
PAGE:386
Dt : 5/9/2022
(b)synchronized method - Instance method lock
=>The process of declaring instance methods with
'synchronized' keyword is known as 'synchronized
method'.
=>In this process the lock is applied on the
ii
individual instance method and the method is available
ath
to one user at-a-time.
=>The class which is holding synchronized methods
ip
is known as Synchronized class.
Ex:
Ma
Printer.java
sh
package test;
public synchronized void print(int n,String name) {
ate
try {
Thread.sleep(2000);
nk
}//end of loop
}
}
Ve
User1.java
package test;
public Printer p;
this.p=p;
}
public void run()
PAGE:387
{
p.print(5, "Raj");
}
}
User2.java
package test;
public Printer p;
ii
this.p=p;
ath
}
public void run()
{
p.print(5,"Ram");
}
ip
}
Ma
package maccess;
import test.*;
sh
Printer p = new Printer();
ate


nk
t1.start();
t2.start();
Ve
}
}
=================================================
(c)Static synchronization - Class lock
=>The process of declaring static methods with
PAGE:388
synchronized keyword is known as
'Static synchronization process'
=>In static synchroniozation process the lock is
applied on the class known as Class locking process.
Ex:
ii
Printer.java
ath
package test;
public synchronized static void print(int n,String name) {
ip
try { Ma
Thread.sleep(2000);
}//end of loop
}
}
sh
User1.java
ate
package test;
public void run()
{
Printer.print(5, "Raj");
nk
}
}
Ve
User2.java
package test;
public void run()
{
Printer.print(5,"Ram");
}
}
PAGE:389
package maccess;
import test.*;
User1 ob1 = new User1();

User2 ob2 = new User2();
ii
ath
t1.start();
t2.start();
}
ip
}
Ma
================================================
*imp
2.Thread Communication:
sh
=>The process of establishing communication b/w
ate
threads using the following methods from
java.lang.Object class is known as

nk
'Thread Communication process'.
(a)wait()
Ve
(b)notify()
(c)notifyAll()
(a)wait():
=>wait() method will make thread to wait until it
PAGE:390
receives msg in the form of notify() or notifyAll().
(b)notify():
=>notify() method will release the locked resource
and send msg to the next waiting thread.
ii
(c)notifyAll():
ath
=>notifyAll() method also release the locked resource
and send the msg to all multiple waiting threads.
ip
Ex:
Producer.java
Ma
package test;
public class Producer implements Runnable{
sh
public StringBuffer sb=null;
public Producer()
{
ate
sb = new StringBuffer();//Buffer Object

}
public void run() {
try {
synchronized(sb)//Buffer Lock
nk
{
{
Ve
sb.append(i+":");
System.out.println("Appending
buffer.....");
Thread.sleep(2000);
}//end of loop
sb.notify();
//release the lock and send_msg_to_next_thread
}//end of lock
}catch(Exception e) {e.printStackTrace();};
}
PAGE:391
}
Consumer.java
package test;
public class Consumer implements Runnable{
public Producer prod=null;
public Consumer(Producer prod)
{
ii
this.prod=prod;
ath
}
public void run() {
try {
synchronized(prod.sb)//locking buffer
{
ip
System.out.println
("Control with Consumer...but Blocked...");
Ma
prod.sb.wait();//Consumer blocked
System.out.println("===Display using
Consumer===");
System.out.println(prod.sb.toString());
}//end of synchronized lock
}catch(Exception e) {e.printStackTrace();}
sh
}
}
ate
package maccess;
nk
import test.*;
Producer p = new Producer();//Con_Call
Ve
Consumer c = new Consumer(p);//Con_Call
Thread t1 = new Thread(p);

Thread t2 = new Thread(c);
t2.start();//Consumer started first

t1.start();
}
}
PAGE:392
o/p:
Control with Consumer...but Blocked...
Appending buffer.....
ii
ath
ip
Ma
===Display using Consumer===
sh
1:2:3:4:5:6:7:8:9:10:
ate
Diagram:
nk
Ve
PAGE:393
ii
ip ath
Ma
sh
ate
============================================
nk
Ve
PAGE:394
============================================
Dt : 6/9/2022
ClassFiles:
Producer.class
Consumer.class
ii
DemoThread8.class(MainClass)
ip ath
Ma
sh
ate
nk
=============================================
Note:
Ve
=>In the above program Consumer will wait until the
Producer produces the data to the buffer.
=================================================
faq:
define Thread-Life Cycle?
PAGE:395
=>Thread-Life Cycle demonstrates diff states of
thread from Thread creation to thread completion or
Thread creation to Thread termination.
=>The following are the states of Thread Life-Cycle:
1.Thread Creation(New Thread)
2.Ready-to-run
ii
3.Running
ath
(i)Thread Completion
(ii)Thread Blocked State
ip
=>Thread DeadLock
Diagram:
Ma
sh
ate
nk
Ve
====================================================
faq:
define Thread Scheduler?
=>Thread Scheduler is an internal algorithm of
PAGE:396
Execution process to control and manage threads.
=>This Thread Scheduler is also known as Thread
manager.
=>This Thread Scheduler internally uses the following
two algorithms:
(i)Time Slicing Algorithm
ii
(ii)Priority based Algorithm
ath
(i)Time Slicing Algorithm:
ip
=>In Time Slicing Algorithm all the multiple threads
are executed based on defined time slice.

Ma
(ii)Priority based Algorithm:
sh
=>In Priority based Algorithm the threads are
executed based on thread priorities.

ate
--------------------------------------------
note:
nk
=>we use setPriority() method to set the priorities
for threads.
Ve
Ex:
t1.setPriority(8);
=>The thread priorities must be taken from 1 to 10
1 - Least Priority
PAGE:397
10 - Highest Priority
5 - Normal Priority(default priority)
=>we use following fields from java.lang.Thread class
to represent Thread Priorities:
ii
public static final int MIN_PRIORITY;
ath
public static final int NORM_PRIORITY;
public static final int MAX_PRIORITY;
ip
syntax:
t1.setPriority(Thread.MIN_PRIORITY + 2)
Ma
sh
=>we use getPriority() method to display the priority
of a thread.
ate
syntax:
nk
int p = t1.getPriority();
=================================================
Ve
faq:
define LiveLock?
=>The temporary blockage of thread is known as
LiveLock.
(Blocked state of thread is known as LiveLock)
PAGE:398
faq:
define DeadLock?
=>The permanent blockage of thread is known as
DeadLock.
ii
Note:
ath
=>The raised events occurs permanently then thread
is under deadlock.
ip
================================================
Dt : 7/9/2022
faq:
Ma
How can we know the thread is under DeadLock or
sh
LiveLock?
=>we use isAlive() method to check the thread is

ate
under deadlock or livelock

nk
syntax:
boolean k = t1.isAlive();
Ve
if(k)
t1.resume();
PAGE:399
else
t1.suspend();
================================================
faq:
ii
define daemon thread?
ath
=>The thread which executes contineously is known
as daemon thread.
ip
=>Server service threads are daemon threads.
Note:
Ma
=>we use setDaemon() method to make the thread as
sh
daemon thread.
syntax:
ate
t1.setDaemon(true);
=>we use isDaemon() method to check the thread is

nk
daemon thread or not.
syntax:
Ve
boolean z = t1.isDaemon();
==================================================
faq:
define join() method?
=>join() method specify to complete the current
PAGE:400
running thread and start the next thread.
Ex:
t1.start();
t1.join();
t2.start();
Note:
ii
=>Complete the thread t1 and then start t2.
ath
===============================================
faq:
ip
define yield() method?
Ma
=>yield() method specify to stop the current running
thread and complete the next thread.

sh
Ex:
t1.start();
ate
t1.yield();
t2.start();
nk
==============================================
faq:
Ve
define start() method?
=>start() method internally holding thread algorithms
and specify to start the thread.
=>start() method specify to create separate thread
stack.
PAGE:401
=>start() method activates Thread-Scheduler.
=>start() method will call run() method and loads the
run() method onto separate thread-stack.
===============================================
faq:
define ThreadGroup?
ii
=>ThreadGroup is a class from java.lang package and
ath
which is used collect multiple threads as a group.
(ThreadGroup will organize threads in group)
ip
==============================================
Application of threads:
Ma
(i)Threads are used in Gaming applications.
(ii)Threads are used in Server Applications

sh
(iii)Threads are used in Server developments.
=============================================
ate
faq:
define Abstraction?
nk
=>The process of hiding the background implementation
which is not needed by the endUser or user is known as

Ve
abstraction process.
Ex:
=>strat() method calling run() method to strat the
thread,in this process the background process is
hided to the EndUser is known as abstraction.
PAGE:402
===================================================
*imp
PolyMorphism in Java:
=>The process in which the programming component
having more than one form is known as PolyMorphism.
Poly - Many
ii
Morphsim - Forms
ath
=>PolyMorphism is categorized into two types:
ip
1.Dynamic PolyMorphism
2.Static PolyMorphism
Ma
1.Dynamic PolyMorphism:
sh
=>PolyMorphism at execution stage is known as
Dynamic PolyMorphism or Runtime PolyMorphism.

ate
Ex:
Method Overriding process.

nk
2.Static PolyMorphism:
Ve
=>PolyMorphism at compilation stage is known as
Static PolyMorphism or CompileTime PolyMorphism.
Ex:
Method Overloading process
PAGE:403
void add(int,int)
void add(int,int,int)
===========================================
Note:
=>Compiler at compilation stage will control the
following keywords:
ii
1.static
ath
2.private
3.final
ip
1.static:
Ma
=>The following are the static programming
components:
sh
(a)static variables
(b)static methods
ate
(c)static blocks
(d)static classes
nk
(e)static Interfaces
(f)static AbstractClasses
Ve
=>There is no concept of static constructors in Java.
2.private:
=>The following are the private programming
components:
PAGE:404
(a)private variables
(b)private methods
(c)private Constructors
(d)private Classes
=>There is no concept of private blocks,private
Interfaces and private AbstractClasses.
ii
ath
(a)private variables:
ip
=>The variables which are declared with 'private'
keyword are known as private variables.

Ma
Coding rule:
sh
=>private variables are accessed only inside the
class,which means canbe accessed by the methods of

ate
same class.
nk
(b)private methods:
=>The methods which are declared with private

Ve
keyword are known as private methods.
Coding Rule:
=>private methods are accessed only inside the class,
which means accessed by the Non-Private methods of
PAGE:405
same class.
Dt : 8/9/2022
*imp
(c)private Constructors:
=>The constructors which are declared with private
ii
keyword are known as private Constructors.
ath
Behaviour:
ip
=>Priviate constructors will restrict the object
creation outside the class,which means when private
constructor is available we have to create object

Ma
inside the class.
sh
--------------------------------------------
Note:
ate
=>Using private constructor we can contruct
'SingleTon Classes'.
nk
-----------------------------------------------
faq:
Ve
define SingleTon class?
=>The class which generate only one object is known
as SingleTon class.
faq:
PAGE:406
define SingleTon class design pattern?
=>The pattern or structure which is used to
construct SingleTon class is known as 'SingleTon
class design pattern'
=>The following components are used in contructing
'SingleTon class design pattern':
ii
(a)private static reference variable
ath
(b)private constructor
(c)static method
ip
(a)private static reference variable:
Ma
=>This private static reference variable will hold
the reference of object created inside the class.

sh
(b)private constructor:
ate
=>private constructor will make the object created
inside the same class.

nk
(c)static method:
Ve
=>static method is used to access the object
reference outside the class.
============================================
=>SingleTon class design pattern categorized into
two types based on object creation process:
PAGE:407
(i)Early Instantiation process
(ii)Late Instantiation process
(i)Early Instantiation process:
=>In Early Instantiation process the object is
created inside the static block.
ii
ath
Ex:
PTest.java
ip
package p1;
public class PTest {
private PTest() {}
private static PTest ob = null;
static
Ma
{
ob = new PTest();
}
sh
public static PTest getRef()
{
return ob;
ate
}
public void access() {
System.out.println("====access()====");
}
nk
}
Ve
DemoPoly1.java(MainClass)
package p2;
import p1.PTest;
public class DemoPoly1 {
// PTest ob = new PTest();//Error
PTest ob = PTest.getRef();//Accessing_ref
ob.access();
}
PAGE:408
}
(ii)Late Instantiation process:
=>In Late Instantiation process the object is
created inside the method.
ii
Ex:
ath
PTest2.java
package p1;
public class PTest2 {
private PTest2() {}
ip
private static PTest2 ob = null;
public static PTest2 getRef() Ma
{
if(ob==null)
{
ob = new PTest2();
}
return ob;
sh
}
public void access() {
System.out.println("====access()====");
ate
}
nk
DemoPoly2.java(MainClass)
package p2;
Ve
import p1.PTest2;
public class DemoPoly2 {
// PTest ob = new PTest();//Error
PTest2 ob = PTest2.getRef();//Accessing_ref
ob.access();
}
}
PAGE:409
=======================================
(d)private Classes:
=>The classes which are declared with private
keyword are known as private classes.
Note:
=>Private classes can be declared as only InnerClasses,
ii
which means OuterClasses cannot be declared as
ath
private.
ip
Ma
sh
ate
=============================================
nk
Assignment:
Ve
Construct application to demonstrate Private
InnerClasses
===========================================
*imp
3.final:
=>The following are the final programming components:
PAGE:410
(a)final variables
(b)final methods
(c)final classes
=>There is no concept of final blocks,final
constructors,final Interfaces and final abstract
classes
ii
ath
(a)final variables:
=>The variables which are declared with final keyword
ip
in classes are known as final variables.
Ma
=>These final variables must be initialized with values
and once initialized cannot be modified.
=>These final variables are also known as secured

sh
variables or Constant variables.
=>The final variables in classes can be initialized

ate
using Constructor.
nk
(b)final methods:
Ve
=>The methods which are declared with final keyword
are known as final methods.
=>final methods cannot be Overrided,which means
cannot be replaced.
PAGE:411
(c)final classes:
=>The classes which are declared with final keyword
are known as final classes.
=>final classes cannot be extended,which means
cannot be inherited.
-----------------------------------------------
ii
Note:
ath
=>we use final programming components to construct
"Immutable classes".
ip
------------------------------------------------
faq:
define "Immutable Classes"?

Ma
=>The classes which are declared with the following
sh
rules are known as "Immutable Classes":
ate
Rule-1 : The class must be 'final class'.
Rule-2 : The variables in class must be private and

nk
final variables'
Rule-3 : The class must be declared with only "Getter

Ve
methods"
Rule-4 : These Getter methods must be final methods
Note:
=>These Immutable classes will generate "Immutable
PAGE:412
Objects".
faq:
wt is the diff b/w
(i)Setter methods
(ii)Getter methods
ii
ath
(i)Setter methods:
=>Setter methods are used to set the data to the
ip
objects.
(ii)Getter methods:
Ma
=>Getter methods are used to get the data from the
sh
objects.
ate
Coding Rule:
=>Every variable in class will have its own Setter

nk
and Getter method.
================================================
Ve
PAGE:413

Maipathi Sir Core and Adv Java and JDBC

Uploaded by

Maipathi Sir Core and Adv Java and JDBC

Uploaded by

Dt : 16/6/2022(Day-1)

1.Programming Components(Java Alphabets)

2.NonPrimitive DataType Variables(will object references)

2.NonStatic methods(Instance Methods)

(b)Exception handling process

(d)Java Collection Framework(JCF)

3.Object Oriented Programming features.

=>Using CoreJava components and concepts we can develop StandAlone Applications.

define StandAlone Application?

in the same computer are known as StandAlone Applications or DeskTop applications

=>According to developer StandAlone applications means,

=>The process used to construct program is known as Programming.

=>The person who writes the programs is known as Programmer o developer.

=>After writing the program,save the program with language extention.

=>The process of checking the program constructed according to the rules of

language or not,is known as Compilation process.

=>C,c++ and Java Languages will use Compiler in Compilation process.

=>After Compilation process is successfull,then Compiled Codes are generated.

=>The process of running CompiledCodes and checking the required output is

generated or not,is known as Execution process.

and generate result.

=>In Java Language,the ByteCode is executed on JVM(Java Virtual Machine).

wt is the diff b/w

=>while Objective Code generation,OperatingSystem is participated because of

=>The ObjectiveCode which is generated from one Platform cannot be executed on

=>while ByteCode generation,OperatingSystem is not participated because of this

=>Java Language which is generating ByteCode is Platform independent language.

1995 - Java Alpha&Beta

1996 - JDK 1.0

1997 - JDK 1.1

1998 - JDK 1.2

2000 - JDK 1.3

2002 - JDK 1.4

2019 - Java12 & Java13

2021 - Java16 & Java17

wt is the diff b/w

JavaLibrary and JVM.

=>JavaCompiler is used to compile the Source Code and generate ByteCode.

=>JavaLib will provide pre-defined components which are used in application

=>JavaLib is represented with the word 'java'.

=>JavaLib is collection of 'packages'.

java.lang - Language package(default package)

java.util - Utility package

java.io - IO Streams and files package

java.net - Networking package

java.sql - DataBase Connection package

javax.servlet - Servlet Programming package

javax.servlet.jsp - JSP Programming package

=>JVM internally having the following partitions:

(i)Class Loader SubSystem

(ii)Runtime Data Area

define Virtual Machine?

=>JRE is internal partition of JDK.

Installing Java S/w and Setting path:

step-2 : Install JDK(Java s/w)

=>After Installation process is successfull,then we can find the folder with

name 'java' in program files.

step-3 : Set JavaPath in 'Environment variables'

Environment Variables->click 'new' from 'System Variables'

Variable name : path

=>'class' is a Structured Layout generating objects.

=>'class' in Java can hold Variables,methods(functions) and main()

Variables - data holders

main() - Starting point of program execution

=>we use 'class' keyword in Java to declare classes

structure of 'class' in Java:

public static void main(String[] args)

public static void main(String[] args)

step-1 : create one folder in any drive

step-2 : Open notepad and type the program

step-3 : Save the program in folder(Destination folder)

step-5 : Execute the program as follows

JVM Architecture with Internals:

(ii)Runtime Data Area

(i)Class Loader SubSystem:

(ii)Runtime Data Area: