Teaching Guidelines for

Object Oriented Programming with Java

PG-DAC September2023

Duration: 112 hours (50 theory hours + 50 lab hours + 12 revision/practice hours)

Objective: To reinforce knowledge of Object Oriented Programming concepts using Core Java.

Prerequisites: Basic knowledge of computer programming

Evaluation: Total 100 marks

Weightage: CCEE – 40%, Lab exam – 40%, Internals – 20%

Text Book:
 Core and Advanced Java Black Book / Dreamtech Press

References:
 Java 8 Programming Black Book / Dreamtech Press
 Core Java : Volume 1 - Fundamentals by Cay S. Horstmann / Prentice Hall
 Core Java : Volume 2 - Advanced Features by Cay S. Horstmann / Prentice Hall
 Programming in Java by Sachin Malhotra, Saurabh Choudhary / Oxford University Press
 Java The Complete Reference by Herbert Schildt / McGraw Hill
 Core Java 8 for Beginners by Sharanam Shah, Vaishali Shah / Shroff Publishers
 Murach’s Java Programming by Joel Murach / Mike Murach
 Object-Oriented Analysis and Design with applications by Grady Booch / Pearson

(Note: Each Session is of 2 hours)

Session 1: Introduction to Java
Lecture:
 Introduction to java
 Features of java
 JVM Architecture
 JDK and its usage
 Structure of java class
 Working with data types: Primitive data types

Session 2: Basic programming concepts

Lecture:
 Java Tokens
 Declaring variables and methods
 Data type compatibility
 Operators
 Control statements
 Arrays 1-D and multidimensional array
Lab 1 & 2:
 Get yourself acquainted with java environment.
 Print different patterns of asterisk (*) using loops (e.g. triangle of *).
Tutorial:
 Compare syntactical similarities and dissimilarities between Java and C++.

Object Oriented Programming Concepts

Session 3: Object Oriented Programming Concepts
Lecture:
 Introduction to OOP
 Classes and Objects
 OOP principles
 Encapsulation, Abstraction, Inheritance and Polymorphism

Session 4:
Lecture:
 Static variables and methods
 Accessing static variables and methods of different class
 Introduction to reference data types
 Reference variables and methods
 Difference between reference data types and primitive data types
 Difference between reference variable and static variable

Session 5:
Lecture:
 Constructors, initializing reference variables using constructors.
 Pass by value v/s pass by reference.
 Re-assigning a reference variable.
 Passing reference variable to method
 Initializing reference variable of different class
 Heap memory and stack memory
Lab 3 & 4:
 Print default values of static & instance variables for different data types.
 Build a class Employee which contains details about the employee and compile and run its
instance.
 Build a class which has references to other classes. Instantiate these reference variables and
invoke instance methods.
Tutorial:

 Understand role of stack and heap memory in method invocation and object creation.

Session 6:
Lecture:
 Inheritance: single & multilevel
 Inheritance: Hierarchical
 Association, Aggregation and Composition
  Polymorphism: Compile time and runtime polymorphism
 Rules of overriding and overloading of methods
 super and this keyword
Lab 5 & 6:
 Create a class Employee and encapsulate the data members.
 Create demo applications to illustrate different types of inheritance.

Session 7:
Lecture:
 Upcasting &down casting of a reference variable
 Abstract class and abstract methods
 Interface (implementing multiple interfaces)

Session 8:
Lecture:
 Final variables, final methods and final class
 Functional interface
 New interface features (Java 8 & 11)
 Lambda Expression
 Inner Class (Regular, Method local, Anonymous & static inner class)
 Enum
Lab 7 & 8:
 Create an Array of Employee class and initialize array elements with different employee objects.
 Try to understand the no of objects on heap memory when any array is created.

Session 9:
Lecture:
 Access modifiers (public, private, protected and default)
 Packages and import statements.
 Static imports
 Constructor chaining (with and without packages)
 Accessing protected variables and methods outside the package

Session 10:
Lecture:
 Garbage collection in java
 Requesting JVM to run garbage collection.
 Different ways to make object eligible for garbage collection: (Nulling a reference variable, Re-
assigning a reference variable & island of isolation)
 Finalize method.
Lab 9 & 10:
 Create a demo application to understand the role of access modifiers.
 Implement multilevel inheritance using different packages.
 Access/invoke protected members/methods of a class outside the package.
 Override finalize method to understand the behavior of JVM garbage collector.
Sessions 11 & 12:
Wrapper Classes and String Class
Lecture:
 Wrapper classes and constant pools
 String class, StringBuffer& StringBuilder class
 String pool
Lab 11 & 12:
 Create sample classes to understand boxing & unboxing.
 Use different methods of java defined wrapper classes.
 Create StringDemo class and perform different string manipulation methods.
Tutorial:

 Understand the difference between String / StringBuffer / StringBuilder.

Sessions 13 & 14:

Exception Handling
Lecture:
 Exception hierarchy, Errors, Checked and un-checked exceptions.
 Exception propagation
 try-catch-finally block, throws clause and throw keyword.
 Multi catch block.
 Creating user defined checked and unchecked exceptions.
Lab 13 & 14:
 Create user defined checked and unchecked exceptions.

Session 15:
[Link] & [Link] Package
Lecture:
 Brief introduction to InputStream, OutputStream, Reader and Writer interfaces
 NIO package
 Serialization and de-serialization
 Shallow copy and deep copy

Session 16:
Lecture:
Object Class & [Link] Package
 Date, DateTime, Calendar class
 Converting Date to String and String to Date using SimpleDateFormat class
 Object Class: Overriding to String, equals &hashcodemethod
Lab 15 & 16:
 Create a Demo class to Read & write image/text files.
 Create SerializationDemo class to illustrate serialization and de-serialization process.
 Create a demo class for Date, Time and Calendar
Collections
Sessions 17, 18 & 19:
Lecture:
 Introduction to collections: Collection hierarchy
 List, Queue, Set and Map Collections
 List Collection:
o ArrayList, LinkedList
o Vector (insert, delete, search, sort, iterate, replace operations)
 Collections class
 Comparable and Comparator interfaces
 Queue collection
Labs 17, 18 & 19:
 Create DateManipulator class to convert String to date, date to String and to find out number of
days between two dates.
 Create a list of java defined wrapper classes and perform insert/delete/search/iterate/sort
operations.
 Create a collection of Employee class and sort objects using comparable and comparator
interfaces.
 Implement Queue data structure using LinkedList and Queue collection.

Sessions 20 & 21:

Lecture:
 Set Collection:
o HashSet, LinkedHashSet&TreeSet collection
o Backed set collections.
 Map Collection:
o HashTable, HashMap, LinkedHashMap&TreeMap classes
o Backed Map collections.
 Concurrent collections
Labs 20 & 21:
 Create an Employee HashSet collection and override equals &hashCode methods to understand
how the set maintains uniqueness using these methods.
 Create a Sample class to understand generic assignments using “? extends SomeClass” , “? super
someclass ” and “?”.

Session 22:
Lecture:
 MultiThreading : Thread class and Runnable Interface
 sleep, join, yield, setPriority, getPrioritymethods.
 ThreadGroup class
Lab 22:
 Create multiple threads using Thread class and Runnable interfaces.
 Assign same task and different task to multiple threads.
 Understand sleep, join, yield methods.
Sessions 23 & 24:
Lecture:
 Synchronization
 Deadlock
 Wait, notify and notifyAllmethods.
 Producer & Consumer problem
Lab 23 & 24:
 Create a Deadlock class to demonstrate deadlock in multithreading environment.
 Implement wait, notify and notifyAll methods.
 Demonstrate how to share threadlocal data between multiple threads.

Session 25 : Generics and Reflection API

Lecture:
 Introduction to generics
 Generic classes
 Generic methods
 Wild cards (upper and lower)
 Reflection
Lab 25:
 Invoke private methods of some other class using reflection.
 Create multiple threads using anonymous inner classes.
 Create multiple threads using lambda expressions.
Object Oriented Programming with Java
sandeepkulange@[Link]
 Evaluation Strategy

• Duration : 104 Hours( 48 Theory + 48 Lab + 8 Revision Hours )

• Evaluation : Total 100 marks
• Theory Exam : 40%
• Lab Exam : 40%
• Internals : 20%
• Reference Books :
1. Java, The Complete Reference – Herbert Schildt
2. Core Java Volume I and II – Cay S. Horstmann
3. Java 8 Programming Black Book – D.T. Editorial Services
4. Object Oriented Analysis and Design with Applications – Grady Booch
• Reference links :
1. [Link]
2. [Link]
3. [Link]
 Agenda
• Language, Technology and Platform
• History of Java programming language
• Java version history
• Java Software Development Kit
• Simple ”Hello World!!” application
• Exploring bytecode using javap
• Java comments
• Java entry point
• Primitive & non primitive types,
• Wrapper classes
• Command line arguments
 Classification of Programming Languages
• Machine level programming language
• Binary language
• Low level programming language
• Assembly programming language
• High level programming language
• Procedure oriented programming languages
• Algol, Fortran, COBOL, Pascal, C etc.
• Object oriented programming languages
• Simula, Smalltalk, C++, Java, C#, Go, Python etc.
• Object based programming languages
• Ada, Java Script, Action Script, VB Script, Visual Basic etc.
• Functional programming languages
• Haskell, Lisp, F#, Scala, Clojure, Ocaml, Python, C#, C++, Java
 “Hello World” Application using Machine Language
• Here is the “Hello World!!” program in binary:
01001000 01100101 01101100 01101100
01101111 00100000 01010111 01101111
01110010 01101100 01100100 00100001
00100001
• Advantages of machine-level language:
1. Very fast execution times
2. Complete control over the computer's hardware
3. No need for a compiler or interpreter

• Limitations of machine-level language

1. Very difficult to read and write
2. Specific to a particular computer architecture, making it non-portable
3. Requires a deep understanding of the underlying hardware
 “Hello World” Application using Low Level Language
• Here is the "Hello World!!" program in x86 assembly language:

section .data
msg db 'Hello World!!',0

section .text
global _start

_start:
; Write the string to stdout
mov eax, 4 ; System call for "write"
mov ebx, 1 ; File descriptor for stdout
mov ecx, msg ; Pointer to the message
mov edx, 13 ; Length of the message
int 0x80 ; Call the kernel

; Exit the program with a status of 0

mov eax, 1 ; System call for "exit"
xor ebx, ebx ; Status code (0 = success)
int 0x80 ; Call the kernel
 Advantages and Limitations of Low Level Language
• Advantages of low-level languages include:
1. Faster execution times than high-level languages
2. Direct access to the computer's hardware
3. More portable than machine-level language

• Limitations of low-level languages include:

1. Still difficult to read and write compared to high-level languages
2. Can be error-prone due to the need for manual memory management
3. Not as user-friendly as high-level languages
 “Hello World” Application using High Level Language
• Here is the “Hello World!!” program in Python:
print("Hello, world!")

• Advantages of high-level language:

1. Easy to read and write
2. Less error-prone due to built-in error checking and automatic memory management
3. More portable than machine-level and low-level languages

• Limitations of high-level language

1. Slower execution times than low-level languages
2. Less control over the computer's hardware than low-level languages
3. More memory-intensive than low-level languages
 What is Language?
• Language is a system of communication that allows humans to convey meaning to each other
through the use of symbols, such as words, gestures, and facial expressions.
• In the context of computer science, programming languages are used to write software programs
that can be executed by computers.
• In General programming languages contains:
• Syntax and Semantics
• Tokens(Identifier, Keyword, Constant, operator, Separator)
• Data Types
• Comments
• Built in unique features
• Even though languages are used to implement business logic, they can be used to create
applications too:
• Console User Interface(CUI) / Command Line Interface(CLI) Application
• Graphical User Interface(GUI) application
• Library Application(.lib/.dll/.jar)
• Example of Languages:
• C, C++, Java, C#, Python, GO etc.
 What is Technology?
• Technology refers to the tools and techniques used to create and manipulate information. In
Simple words, we can develop application using technology.
• Example:
• Java
• Artificial Intelligence (AI)
• Blockchain
• Augmented Reality (AR)
• Internet of Things (IoT)
• Cloud Computing
• Note: Every language can be considered as technology but every technology can not be
considered as language.
 What is Platform?
• A platform is the hardware or software environment in which a program runs.
• Most platforms can be described as a combination of the operating system and underlying
hardware:
• Microsoft Windows
• Linux
• Mac OS
• Android
• Software-only platforms are the applications that runs on top of other hardware-based
platforms:
• Java
• Microsoft .NET
 History of Java Programming Language
• Java is high-level, statically type checked, Object-oriented as well as Functional
programming language.
• Java language is both technology as well as platform.
• Code name of the Java was “Green” Project.
• Java was developed by (“Green Team”) James Gosling, Patrick Naughton, Chris Warth, Ed Frank,
and Mike Sheridan at Sun Microsystems, which was later acquired by Oracle Corporation(2010).
• The name "Green" was chosen because the team wanted to emphasize that their goal was to
create an environmentally-friendly language that would allow programs to run efficiently on a
variety of devices, including small handheld devices and large servers.
• Green Team started working on “Green Project” in 1991 and first public version released in
1996.
• In fact, the original name for Java was "Oak", but it was changed to "Java" because another
company had already registered the name "Oak" for their product.
• Java's slogan is "Write Once, Run Anywhere" (sometimes abbreviated as "WORA").
• The standardization of the Java language is overseen by the Java Community Process (JCP).
• “*7” is the first project delivered by Green Team.
• An extremely intelligent TV remote control.
• Reference to read a short history of Java: Core Java Volume I
 Java Version History
([Link]
 Java Code Names
• Code names are used by developers and companies to refer to different versions of Java during
the development process.
1. JDK 1.1: Sparkler
2. J2SE 1.2: Playground
3. J2SE 1.3: Kestrel
4. J2SE 1.4: Merlin
5. J2SE 5.0: Tiger
6. Java SE 6: Mustang
7. Java SE 7: Dolphin
8. Java SE 8: Spider
9. Java SE 9: Project Jigsaw
10. Java SE 10: Project Valhalla
11. Java SE 11: Project Amber
12. Java SE 12: Project Skara
13. Java SE 13: Project ZGC
14. Java SE 14: Project Panama
15. Java SE 15: Project Loom
16. Java SE 16: Project Metropolis
17. Java SE 17: Project Panama 2.0
 JLS and JSR
• JLS stands for Java Language Specification.
• It is a document that defines the syntax, semantics, and behavior of the Java programming
language.
• Reference: [Link]
• JSR stands for Java Specification Request.
• It is a formal proposal for adding new features or making changes to the Java platform.
• JSRs are submitted by individuals, organizations, or companies to the Java Community Process
(JCP) for review and approval.
• Reference: [Link]
 Editions of Java Platform
1. Java SE
• Java Standard Edition( also called as Core Java)
• It is designed for developing and running desktop, server, and standalone applications.
• It includes the core Java API and provides a foundation for building Java applications.
2. Java EE
• Java Enterprise Edition( also called as Web / Advanced / Enterprise Java )
• It is designed for building web applications and web services.
• It includes the Java Servlet API, Java Server Pages (JSP), and Enterprise JavaBeans (EJB).
3. Java ME
• Java Micro Edition.
• It is designed for developing applications for resource-constrained devices such as mobile phones,
PDAs, and other embedded systems.
• It includes a subset of the Java SE APIs and provides a smaller footprint than Java SE.
4. Java Card
• It is designed for building smart card applications.
• It includes a subset of the Java ME APIs and provides security and cryptographic features for smart
card applications.
 Software Development Kit
• SDK = Development Tools + Documentation + Supporting Libraries + Execution Environment.
• JDK = Java Development Tools + Java Docs + [Link] + Java Virtual Machine.
• Java Development Tools: javac, java, javap, javadoc, etc.
• Java Docs: HTML pages, which contains help of Core Java API
• [Link]: It contains core Java API
• Java Virtual Machine: It is abstract computer which manages execution of bytecode.
• JDK is a platform dependent software that we can download from oracle site.
• Developer must install JDK to develop Java application.
• JRE = [Link] + Java Virtual Machine.
• JRE is platform dependent software that we can download from oracle site.
• To run Java application on Client’s machine we must install/deploy JRE.
• JVM = Java Virtual Machine
• The JVM is responsible for interpreting the bytecode and translating it into machine code
that can be executed by the underlying operating system. It also provides memory management,
security, and other runtime services necessary for executing Java applications.
• Reference: [Link]
 Components of Java Platform
• The Java platform has two components:
1. The Java Virtual Machine
2. The Java Application Programming Interface (API)

• Reference: [Link]
Application Programming Interface
Day 2
Java Documentation

Contents of package
Sub package
Interface
Nested Type
Constant Fields
Abstract Methods
Default Methods
Static Interface Methods
Class
Nested Types( Interface / Class / Enum )
Fields
Constructor
Method
Enum
Exception
 Error
Annotation Type
Modifiers in Java
PUBLIC
PRIVATE
PROTECTED
STATIC
FINAL
SYNCHRONIZED
VOLATILE
TRANSIENT
NATIVE
INTERFACE
ABSTRACT
STRICT
Reference: [Link]
Access Modifiers
Modifiers which are used to control visibility of members of the class is called access modifier.
Access modifiers
private
Package level private( also called as default )
protected
public
More about main method
In java, main method is considered as entry point method.
With the help of main thread, JVM invoke main method.
Syntax:
public static void main(String args[] )
public static void main(String[] args )
public static void main(String... args )
We can define main method inside class as well as interface.

class Program{
public static void main(String[] args ) {
[Link]("Hello World!!!");
}
}

interface Program{
public static void main(String[] args ) {
 [Link]("Hello World!!!");
}
}

Reference: [Link]
Java Comments
To maintain documentation of source code we should use comments:
Types of comments:
Implementation Comments
Block comments / multiline comments

class Program{
/* public static void main(String args[] ) {
[Link]("Hello World!!!");
} */
public static void main(String[] args ) {
[Link]("Hello World!!!");
}
}

Single line comments

class Program{
public static void main(String[] args ) {
//[Link]("Hello World!!!");
[Link]("Good Morning");
}
}

Documentation comment / doc comments

/**
Author is Sandeep Kulange
*/
class Program{
/**
Entry point method of class Program
*/
public static void main(String[] args ) {
[Link]("Hello World!!!");
}
}

Reference: [Link]
Java OOPS concepts
Consider following code:

class Test{
//Fields
private int num1; //Instance variable
private static int num2; //Class level variable
//Methods
public void setNum1( int num1 ){ //Instance method
this.num1 = num1;
}
public static void setNum2( int num2 ){ //Class level method
this.num2 = num2;
}
}

In Java, to access static members ( class level members ) of the class, we must use class name and
dot operator.

public static void main(String[] args) {

Test.setNum2( 123 );
}

To access non static members( instance members ) of the class, we must use instance of the class.

Test t; //Object reference / reference

new Test; //Not OK
new Test(); //OK: Instance
Test t = new Test( ); //Instantiation

public static void main(String[] args) {

//Test.setNum1( 100 ); //Not OK
Test t = new Test( );
t.setNum1( 100 ); //OK
}
A class from which we can not create instance( In C/C++ it is called as object ) is called abstract
class.
In simple words, we can not instantiate abstract class.
Example:
[Link]
[Link]
A class from which we can create instance is called concrete class.
In simple words, we can instantiate concrete class.
Example:
[Link]
[Link]
A method of class which is having body is called as concrete method.
main method is concrete method.
Example:

class Program{
public static void main(String[] args) {
[Link]("Hello World!!");
}
}

A method of class which do not have body is called as abstract method.

 Example:

abstract class Shape{

public abstract void calculateArea( );
}

A class from which we can not create child / sub class is called as final class.
We can instantiate final class.
Example:
[Link]
[Link]
If method in parent /super class is final then we can not redefine / override that method in child / sub
class.
What is [Link]?
package [Link];
public final class System {
//Fields
public final static InputStream in = null;

public final static PrintStream out = null;

public final static PrintStream err = null;

System is a final class declared in [Link] package.

out is a reference of [Link] class. It is declared as public static final field inside System
class.

//How will you access in

[Link] //It reprsents keyboard
//How will you access out
[Link] //It represents Monitor
//How will you access err
[Link] //It represents Monitor for errors

PrintStream is a class declared in [Link] package.

package [Link];
public class PrintStream extends FilterOutputStream implements
Appendable, Closeable{

public void print(boolean);

public void print(char);
 public void print(int);
public void print(long);
public void print(float);
public void print(double);
public void print(char[]);
public void print(String);
public void print(Object);

public void println();

public void println(boolean);
public void println(char);
public void println(int);
public void println(long);
public void println(float);
public void println(double);
public void println(char[]);
public void println(String);
public void println(Object);

public PrintStream printf(String, Object...);

public PrintStream printf(Locale, String, Object...);
}

println is a non static method of [Link] class.

print, println and printf
[Link] method print output on console but it keeps cursor on same line.

class Program{
public static void main1(String[] args ) {
[Link]("Hello ");
[Link](" World");
[Link]("!!");
}
}

[Link] method print output on console but it moves cursor to the next line.

class Program{
public static void main(String[] args ) {
[Link]("Hello ");
[Link](" World");
[Link]("!!");
}
}

To print formatted output on console / terminal, we should use printf method.

 public static void main(String[] args) {
String name1 = "Sandeep Kulange";
int empid1 = 10003778;
float salary1 = 45000.50f;

String name2 = "Mahesh Koli";

int empid2 = 3779;
float salary2 = 125000.50f;

[Link]("%-20s%-10d%-10.2f\n", name1, empid1,

salary1);
[Link]("%-20s%-10d%-10.2f\n", name2, empid2,
salary2);
}

Data Types
Data type of any variable describe following things:
( Memory ) How much memory is required to store the data.
( Nature ) Which type of data is allowed to store inside allocated memory.
( Range ) How much data is allowed to store inside allocated memory.
( Operation ) Which operations are allowed to perform / execute on the data stored inside
memory.
Types of data type
Primitive data type
Variable of primitive data type contains value. Hence primitive type is also called as value
type.
There are 8 primitive / value types in Java:
boolean
byte
char
short
int
float
double
long
Non Primitive data type
Variable of non primitive data type contains reference of the instance. Hence non
primitive type is also called as reference type.
There are 4 non primitive / reference types in Java
Interface
Class
Enum
Array
If we declare variable inside method then it is called as method local variable.
In Java, we can not declare method local variable static.

class Program {
public static void main(String[] args) {
int number; //Non Static Method Local Variable //OK
}
}

class Program {
public static void main(String[] args) {
int number; //Non Static Method Local Variable
[Link]( number ); //error: variable number might not
have been initialized
}
}

If we want to use any method local variable( primitive / non primive ) then we must store some value
inside it.

class Program {
public static void main(String[] args) {
int number = 10; //Initialization
[Link]( number ); //OK
}
}

class Program {
public static void main(String[] args) {
int number;
number = 10; //Assignment
[Link]( number ); //OK
}
}
 Reference: [Link]
Wrapper classes
In Java, primitive types are not classes. But Sun/Oracle developers has written classes for it. Such
classes are called as Wrapper classes.
All the Wrapper classes are final and declared in [Link] package.
Class Hierarchy
[Link]
[Link]
[Link]
[Link]
[Link]
[Link]
[Link]
[Link]
[Link]
[Link]
Initialization
Process of storing value inside variable during its declaration is called initialization.

int number = 10; //Initialization

int num1 = 10; //Initialization

int num2 = num1; //Initialization

int num1 = 10; //Initialization

int num2 = num1; //Initialization
 //int num2 = 20; //error: variable num2 is already defined in method
main(String[])

We can initialize variable only once.

Process of storing value inside variable after its declaration is called as assignment.

public static void main(String[] args) {

int num1 = 10; //Initialization
int num2 = num1; //Initialization
num2 = 20; //Assignment : OK
num2 = 30; //Assignment : OK
}

We can do assignment multiple times.

Narrowing & Widening
Process of converting, value of variable of narrower type into wider type is called as widening.

public static void main(String[] args) {

int num1 = 10;
double num2 = ( double )num1; //Widening
[Link]("Num2 : "+num2); //OK: Num2 : 10.0
}

In case of widening conversion, explicit typecasting is optional.

public static void main(String[] args) {

int num1 = 10;
//double num2 = ( double )num1; //Widening
double num2 = num1; //Widening
[Link]("Num2 : "+num2); //OK: Num2 : 10.0
}
Process of converting value of variable of wider type into narrower type is called as narrowing.

public static void main(String[] args) {

double num1 = 10.5d;
int num2 = (int)num1; //Narrowing
[Link]("Num2 : "+num2);
}

In case of narrowing, explicit type casting is mandatory.

public static void main(String[] args) {

double num1 = 10.5d;
int num2 = (int)num1; //Narrowing
//int num2 = num1; //error: incompatible types: possible lossy
conversion from double to int
[Link]("Num2 : "+num2);
}
Boxing & Unboxing
Process of converting value of variable of primitive type into non primitive type is called as boxing.

public static void main(String[] args) {

int number = 123;
//String str = ( String)number; //error: incompatible types: int
cannot be converted to String
String strNumber = [Link]( number ); //Boxing
[Link]("Number : "+strNumber);
}

public static void main(String[] args) {

int number = 123;
String strNumber = [Link]( number ); //Boxing
[Link]("Number : "+strNumber);
}
Process of converting value of variable of non primitive type into primitive type is called as unboxing.

public static void main(String[] args) {

String strNumber = new String( "123" );
//int number = ( int ) strNumber; //error: incompatible types:
String cannot be converted to int
int number = [Link](strNumber); //UnBoxing
[Link]("Number : "+number);
}
NumberFormatException
public static void main(String[] args) {
String strNumber = new String( "1A2B3C" );
int number = [Link](strNumber);
//[Link]
[Link]("Number : "+number);
}

If the string does not contain a parsable numeric value then parseXXX() method throws
NumberFormatException. Reference:
[Link]
Commandline arguments
Consider code in C language

int sum( int num1, int num2 ){ //num1, num2 <= Function parameters
int result = num1 + num2;
return result;
}
int main( void ){
int result = sum( 10, 20 ); //10, 20 <= Function arguments
return 0;
}

How to pass argument from command line?

sandeep@Sandeeps-MacBook-Air Day_2.6 % java Program Sandeep

class Program {
//args is a method parameter
public static void main(String[] args) {
[Link]("Hello,"+args[ 0 ]);
}
}

sandeep@Sandeeps-MacBook-Air Day_2.6 % java Program "Sandeep Kulange"

class Program {
public static void main(String[] args) {
 int num1 = [Link](args[ 0 ]);
float num2 = [Link](args[ 1 ]) ;
double num3 = [Link](args[ 2 ]) ;
double result = num1 + num2 + num3;
[Link]("Result : "+result);
}
public static void main1(String[] args) {
int num1 = [Link](args[ 0 ]);
int num2 = [Link](args[ 1 ]) ;
int result = num1 + num2;
[Link]("Result : "+result);
}
}
Day 3

Stream
It is an abstraction( object /instance ) which is used to produce( write ) or consume( read )
information from source to destination.
Console = Keyboard + Monitor
Keyboard => Console Input
Monitor => Console Output

Standard stream objects of Java associated with Console

[Link]( [Link] )
It represents keyboard
 [Link]( [Link] )
It represents monitor
[Link]("Good Morning");
[Link]( [Link] )
It represents monitor but generally designed to display errors on screen
[Link]("Divide by zero exception");
User input using Scanner class
We can access user input from terminal using:
Console class
BufferedReader
Scanner class
JOptionPane class
Scanner is a final class which is declared in [Link] package.
We can use it to read data from console as well as file.
Instantiation:

class Program{
public static void main( String[] args ){
[Link] sc = null; //reference
sc = new [Link]( [Link] ); //Instance
}
}

class Program{
public static void main( String[] args ){
[Link] sc = new [Link]( [Link] );
//Instance
}
}

import [Link];
class Program{
public static void main( String[] args ){
Scanner sc = new Scanner( [Link] ); //Instance
}
}

Methods of [Link] class

public boolean nextBoolean()
 public byte nextByte()
public short nextShort()
public int nextInt()
public long nextLong()
public float nextFloat()
public double nextDouble()
public String nextLine()

import [Link];
class Program {
public static void main(String[] args) {
Scanner sc = new Scanner( [Link] );

[Link]("Name : ");
String name = [Link]();
[Link]("Empid : ");
int empid = [Link]();
[Link]("Salary : ");
float salary = [Link]();

[Link](name+" "+empid+" "+salary);

}
}

Reference: [Link]
Java language Features / buzzwords / ( Sun Microsystems Marketing Keywords )
Simple
Object oriented
Architecture neutral
Portable
Robust
Multithreaded
Dynamic
Secure
High Performance
Distributed
What is the meaning of Deprecated?
In Java, the term "Deprecated" is used to indicate that a particular method, class, or interface should
no longer be used because it is either obsolete, flawed, or has been replaced by a better alternative.
Instance creation in Java
In Java, we can create instance using 3 ways:
Using new operator
 Using factory method
Using reflection
Manipulating system date and time using Date, Calendar, LocalDate, LocalTime, LocalDateTime
System Date using [Link] class

import [Link];
class Program {
public static void main(String[] args) {
Date date = new Date();
int day = [Link]();
int month = [Link]() + 1;
int year = [Link]() + 1900;
[Link](day+" / "+month+" / "+year);
}
}

The Calendar class should be used to convert between dates and time fields and the DateFormat
class should be used to format and parse date strings. The corresponding methods in Date are
deprecated.
Calendar is abstract class declared in [Link] package.

Calendar c = new Calendar(); //Not OK; Because Calendar is abstract

class

To create instance of Calendar class we should use factory method( getInstance()).

Calendar c = [Link](); //OK

Fields of Calendar class

public static final int DAY_OF_MONTH
public static final int DATE
public static final int MONTH
public static final int YEAR
"public int get(int field)" is non static / instance method of Calendar class.

int day = [Link]( Calendar.DAY_OF_MONTH );

//or
int day = [Link]( [Link] );
int month = [Link]( [Link] ) + 1;
int year = [Link]( [Link] );
 import [Link];
class Program {
public static void main(String[] args) {
Calendar c = [Link]();
//int day = [Link]( Calendar.DAY_OF_MONTH );
//or
int day = [Link]( [Link] );
int month = [Link]( [Link] ) + 1;
int year = [Link]( [Link] );

[Link]( day +" / " + month+" / "+year);

}
}

System Date using [Link] class.

"public static LocalDate now()" is a factory method of LocalDate class

LocalDate ld = [Link]();

Methods of LocalDate class:

public int getDayOfMonth()
public int getMonthValue()
public int getYear()

import [Link];
class Program {
public static void main(String[] args) {
LocalDate ld = [Link]();
int day = [Link]();
int month = [Link]();
int year = [Link]();
[Link](day+" / "+month+" / "+year);
}
}

System Time using [Link] class.

"public static LocalTime now()" is a factory method of LocalTime class.

LocalTime lt = [Link]();

Methods of LocalTime class:

 public int getHour()
public int getMinute()
public int getSecond()
public int getNano()

Formatting date and time using SimpleDateFormat

If we want to parse or format date the we should use [Link] class.

import [Link];
import [Link];

class Program {
public static void main(String[] args)throws Exception {
String pattern = "dd/MM/yyyy";
SimpleDateFormat sdf = new SimpleDateFormat( pattern);
String source = "23/07/1983";
Date date = [Link]( source );

int day = [Link]();

int month = [Link]() + 1;
int year = [Link]() + 1900;
[Link](day+" / "+month+" / "+year);
}
}

import [Link];
import [Link];

class Program {
public static void main(String[] args) {
Date date = new Date( );
//SimpleDateFormat sdf = new SimpleDateFormat( "dd-MM-yyyy");
//SimpleDateFormat sdf = new SimpleDateFormat( "dd/MMM/yyyy");
SimpleDateFormat sdf = new SimpleDateFormat( "dd/MMMM/yyyy");
String strDate = [Link](date);
[Link]( strDate );
}
}

Reference: [Link]
Phases of software development life cycle
 Requirement
Analysis
Design
Coding / implementation
Testing
Deployment / installation
mentainance
Procedure orineted programming language
Write a program to accept, strore and print information of employeee
name : char[ 30 ]
empid : int
salary : float

//File Name: Main.c

#include<stdio.h>
struct Employee{
char name[ 30 ];
int empid;
float salary;
};
void acceept_record( struct Employee *ptr ){
printf("Name : ");
scanf("%s", ptr->name);
printf("Empid : ");
scanf("%d", &ptr->empid);
printf("Salary : ");
scanf("%f", &ptr->salary);
}
void print_record( struct Employee *ptr ){
printf("%-30s%-5d%-10.2f\n", ptr->name, ptr->empid, ptr->salary);
}
int main( void ){
struct Employee emp;
accept_record( &emp );
print_record( &emp );
}

A programming methodology in which we can solve real world problems using structure and global
function.
Object oriented programming in C++
//File Name: [Link]
#include<stdio.h>
class Employee{
private:
char name[ 30 ];
 int empid;
float salary;
public:
void acceept_record( /* struct Employee *this */ ){
printf("Name : ");
scanf("%s", this->name);
printf("Empid : ");
scanf("%d", &this->empid);
printf("Salary : ");
scanf("%f", &this->salary);
}
void print_record( /* struct Employee *this */ ){
printf("%-30s%-5d%-10.2f\n", this->name, this->empid, this->salary);
}
};
int main( void ){
Employee emp;
emp.accept_record( ); //emp.accept_record( &emp );
emp.print_record( ); //emp.print_record( &emp );
return 0;
}

A programming methodology, in which we can solve real world problem using class and object is
called object oriented programming.
Object oriented programming in Java
Write a program to strore and print date information.
day : int
month : int
year : int
Analyze problem statement and define the class.

class Date{
//TODO
}

Analyze the problem statement, decide and declare field inside class.
Variable declare inside class / class scope is called as field.
Variable declare inside method / method scope is called as method local variable.

class Date{
//Fields
int day;
int month;
int year;
}
To store values, create instance of the class.
Process of creating instance of a class is called as instantiation.
A class from which we can create instance is called as concrete class. In other words, we can
instantiate concrete class.
In Java, to create instance, we should use new operator.
If we use new operator to allocate memory then it gets space of heap memory area.

new Date(); //Anonymous instance of Date class

If we create instance without reference then it is called as anonymous instance.

Following entities do not get space inside instance:
Method parameter
Method local variable
Method
Nested Type / class
Static field
Only non static field / instance variable get space inside instance.
Non static field get space once per instance according to their order of declaration inside
class.

new Date();
new Date();
new Date();

After instantiation, if we want to perform operations on instance then we require object

reference / reference of the class.

Date birthDate; //reference / object reference

Date joinDate; //reference / object reference
Date leaveDate; //reference / object reference

Date dt; //reference

dt = new Date(); //instance with reference

Date dt = new Date(); //instance with reference

Test your understanding

 Date dt1 = new Date();
Date dt2 = dt1;
Date dt3 = new Date();

After instantiation, if we want to process( accept/print/get/set) state of the instance then we should
call method on instance.

Date dt = new Date();

[Link](); //Message Passing

Here, acceptRecord() method is called on dt instance.

function defined inside class / class scope is called as method.
method is also called as operation/behavior/message
Process of calling method on instance is called as message passing.
Object Oriented Programming with Java
Sandeep Kulange
 Java Buzzwords
1. Simple
2. Object Oriented
3. Architecture neutral
4. Portable
5. Robust
6. Multithreaded
7. Secure
8. Dynamic
9. High performance
10. Distributed
 Simple
• The C language is procedure oriented programming language which is developed by Dennis Ritchie.
• It is neither low level nor high level programming language.
• It is statically-typed check programming language.
• Following are the C language features:
1. Preprocessor directives
2. Function
3. Array
4. Pointer
5. Structure
6. Union
7. Enum
8. Bitfield
 Simple
• The C++ language is procedure oriented as well as object oriented programming language.
• It is also called as hybrid programming language which is developed by Bjarne Stroustrup.
• It is statically-typed check programming language.
• Following are the C++ language features:
1. Constructor member initializer list, default arguments
2. New & delete operator, destructor
3. Copy constructor and operator overloading
4. Friend function and friend class
5. Constant data member & constant member function and reference
6. Mode of inheritance and multiple inheritance
7. Diamond problem, Virtual Base class
8. Virtual and pure virtual function
9. RTTI and advanced type casting operators.
10. Template
 Simple
• Syntax of Java is simpler than syntax of C/C++:
1. No typedefs, no #define/preprocessor directives or inline function. Hence no longer any need for header files.
2. No more garbage value. We must store value inside local variable before use.
3. No goto statement, global variable and global function.
4. No more automatic coercions.
5. No more unsigned type specifier in Java.
6. No more structures and unions.
7. No more copy constructor, constructor member initializer list and default arguments.
8. No more delete operator and destructor.
9. No more constant data member, constant member function and C++ style reference.
10. No more friend function, friend class and operator overloading.
11. No more private & protected mode of inheritance.
12. No more multiple class inheritance i.e. multiple implementation inheritance.
13. No more diamond problem and virtual base class.
14. No more virtual keyword. Hence no pure virtual function in Java.
15. No more RTTI and advanced type casting operators.
16. No more class declaration and class definition.
17. No more pointers. Hence no more dangling pointer and memory leakage in Java.
18. No more storage classes. Now it is modifier in Java.
19. No more call by address and call by reference. In Java, we can pass arguments by value only.
 Simple
• Primary characteristics of the Java programming language include a simple language that can be
programmed without extensive programmer training. The fundamental concepts of the Java
technology are grasped quickly; Programmers can be productive from the very beginning.
• Another aspect of being simple is being small. One of the goals of Java is to enable the construction
of software that can run stand-alone on small machines. The size of the basic interpreter and class
support is about 40K; the basic standard libraries and thread support add another 175K.
 Object Oriented
• Dr. Alan Kay is inventor of object oriented programming system/structure(oops).
• OOP to Dr Alan Kay means only messaging, local retention and protection and
hiding of state-process, and extreme late-binding of all things.
• Reference: [Link]
Object Oriented
 Object Oriented
• According to Grady Booch, there are 4 major and 3 minor elements of oops.
• Major elements of the oops are:
1. Abstraction
2. Encapsulation
3. Modularity
4. Hierarchy
• By major, we mean that a model without any one of these elements is not object oriented.
• Minor elements of the oops are
1. Typing (also known as polymorphism)
2. Concurrency
3. Persistence
• By minor, we mean that each of these elements is a useful, but not essential, part of the object
model.
 Object Oriented
• To be truly considered "object oriented", a programming language should support at a minimum four
characteristics:
1. Encapsulation: To implement data hiding.
2. Polymorphism: To reduce maintenance of the system.
3. Inheritance: To achieve code reusability
4. Dynamic binding: To provide maximum flexibility while a program is executing
• Java meets these requirements nicely, and adds considerable run-time support to make out software
development job easier. Hence Java is object oriented programming language.
 Architecture neutral
• The solution that the Java system adopts to solve the binary-distribution problem is a "binary code
format" that's independent of hardware architectures, operating system. The format of this system-
independent binary code is architecture neutral. If the Java run-time platform is made available for a
given hardware and software environment, an application written in Java can then execute in that
environment without the need to perform any special porting work for that application.
• The Java compiler doesn't generate "machine code" in the sense of native hardware instructions--
rather, it generates bytecodes: a high-level, machine-independent code for a virtual machine.
• Java bytecodes are designed to be easy to interpret on any machine, or to dynamically translate into
native machine code if required by performance demands.
• The architecture neutral approach is useful not only for network-based applications, but also for
single-system software distribution. In today's software market, application developers have to
produce versions of their applications that are compatible with the IBM PC, Apple Macintosh, and
fifty-seven flavors of workstation and operating system architectures in the UNIX marketplace.
Architecture neutral
 Portable
• The architecture-neutral aspect discussed in previous slide is one major step towards being portable.
 Portable
• C and C++ both suffer from the defect of designating many fundamental data types as
"implementation dependent". Programmers labour to ensure that programs are portable across
architectures by programming to a lowest common denominator.
• Java eliminates this issue by defining standard behavior that will apply to the data types across all
platforms. Java specifies the sizes of all its primitive data types and the behavior of arithmetic on
them.
• Note:
1. The Java compiler is written in Java.
2. The Java run-time system is written in ANSI C with a clean portability boundary which is essentially POSIX-compliant.
There are no "implementation-dependent" notes in the Java language specification.
• Reference:
1. [Link]
2. [Link]
 Portable

• Since Java is portable, sizeof operator is not available in Java.

 Robust
• The Java programming language is designed for creating highly reliable software.
• Following features of Java make it Robust:
1. Architecture neutral
2. Object oriented
3. Memory management
4. Exception Handling
 Robust
• Architecture neutral
Ø ”Write Once Run Anywhere” ( WORA) is a slogan of Java. It means, by installing JRE, we can execute same java
application on any platform.
Ø Due to this feature, It is easier for application developer to develop application without thinking about hardware and
operating system.

• Object oriented
Ø This feature helps to break complex code into easy to understand classes.
Ø It also helps to manage high complexity programs in distributed team environment.
• Memory management
Ø In traditional programming language like C, C++ user has to manage memory by allocating and deallocating memory
which leads to memory leaks in the program.
Ø In Java, memory management is taken care by the Java Virtual Machine and safe from memory crashes. All the
allocation and deallocation of the memory is done automatically.
• Exception Handling
Ø In Java, developers are forced to handle the exception during the development time. All the possible exception are
errored out during the compilation of the program. This way when the exception occurs during runtime, there is proper
exception handling mechanism already coded in the program.
 Multithreaded
• If we start execution of Java application then Java Virtual Machine start execution of main thread and
garbage collector.
• Main Thread
1. It is a user thread( also called as non daemon thread ).
2. It is responsible for invoking main method.
3. Its priority in Java is 5( It means Thread.NORM_PRIORITY )
• Garbage Collector( Also called as finalizer )
1. It is a daemon thread( also called as background thread )
2. It is responsible for deallocating memory of unused objects.
3. Its priority in Java is 8( It means Thread.NORM_PRIORITY + 3 )
• Due to main thread and garbage collector, every Java application is multithreaded.
 Multithreaded
• The Java platform supports multithreading at the language level.
 Multithreaded
• If we want to utilize hardware resources concurrently and efficiently then we should use thread.
• Thread is non Java resource. In other words it is operating system resource.
• Java Native Interface( JNI ) is a Java language feature, which allows us to use operating system
thread into Java program.
• Sun/Oracle came with Thread class and other frameworks, which implicitly use JNI and reduces
developers effort. Now Instead of thinking about OS thread ,JNI and multitasking solution, Java
application developer can think about logic only.
• Java’s libraries are also thread safe.
 Secure
• Java technology is designed to operate in distributed environments, which means that security is of
paramount importance.
• When Java applications are executed they don’t instruct commands to the machine directly. Instead
Java Virtual machine reads the program and convert it into the machine instructions. This way any
program tries to get illegal access to the system will not be allowed by the JVM.
• Allowing Java application to be executed by the JVM makes Java application fully secured.
• Java security technology includes a large set of APIs, tools, and implementations of commonly used
security algorithms, mechanisms, and protocols. The Java security APIs span a wide range of areas,
including cryptography, public key infrastructure, secure communication, authentication, and access
control.
 Dynamic
• In java, except constructor and non static method, all the methods are by default virtual.
• It was designed to adapt to an evolving environment( Operating System and Hardware).
• While the Java Compiler is strict in its compile-time static checking, the language and run-time
system are dynamic in their linking stages. Classes are linked only as needed.
• Libraries can freely add new methods and instance variables without any effect on their clients.
• In Java, finding out runtime type information is straightforward.
 High Performance
• Performance of Java application is slower then C/C++ application.
• The Java platform achieves superior performance by adopting a scheme by which the interpreter can
run at full speed without needing to check the run-time environment. The automatic garbage
collector runs as a low-priority background thread, ensuring a high probability that memory is
available when required, leading to better performance.
• Applications requiring large amounts of compute power can be designed such that compute-
intensive sections can be rewritten in native machine code as required and interfaced with the Java
platform.
• In general, users perceive that interactive applications respond quickly even though they're
interpreted.
Distributed
 Distributed
• A distributed application consists of one or more local or remote clients that communicate with one or
more servers on several machines linked through a network. With this type of application, business
operations can be conducted from any geographical location.
• Remote Method Invocation (RMI) is a Java language feature.
• RMI system allows an object running in one Java virtual machine to invoke methods on an object
running in another Java virtual machine.
• Due to RMI Java is considered as distributed.
Questions?
Day 4
How to find size of instance in Java?
Reference: [Link]
Object oriented programming in Java
Write a program to strore and print date information.
day : int
month : int
year : int
Analyze problem statement and define the class.

class Date{
//TODO
}

Analyze the problem statement, decide and declare field inside class.
Variable declare inside class / class scope is called as field.
Variable declare inside method / method scope is called as method local variable.

class Date{
//Fields
int day;
int month;
int year;
}

To store values, create instance of the class.

Process of creating instance of a class is called as instantiation.
A class from which we can create instance is called as concrete class. In other words, we can
instantiate concrete class.
In Java, to create instance, we should use new operator.
If we use new operator to allocate memory then it gets space of heap memory area.

new Date(); //Anonymous instance of Date class

If we create instance without reference then it is called as anonymous instance.

Following entities do not get space inside instance:
Method parameter
Method local variable
Method
 Nested Type / class
Static field
Only non static field / instance variable get space inside instance.
Non static field get space once per instance according to their order of declaration inside
class.

new Date();
new Date();
new Date();

After instantiation, if we want to perform operations on instance then we require object

reference / reference of the class.

Date birthDate; //In C++, It is object

Date birthDate; //In Java, It is reference / object reference

Date dt; //reference

dt = new Date(); //instance with reference

Date dt = new Date(); //instance with reference

After instantiation, if we want to process( accept/print/get/set) state of the instance then we should
call method on instance.

Date dt = new Date();

[Link](); //Message Passing

Here, acceptRecord() method is called on dt instance.

function defined inside class / class scope is called as method.
method is also called as operation/behavior/message
Process of calling method on instance is called as message passing.
Short introduction of String
Non primitive types / reference types
Interface
Class
Enum
Array
String is a final class declared in [Link] package.
Instantiation with new operator:

String s1 = new String();

String s2 = new String("Sandeep Kulange");
//new String("Sandeep Kulange"); => String instance

String instance get space on heap( Runtime data/memory area of JVM ).

Instantiation with out new operator:

String s1 = "";
String s2 = "Sandeep Kulange";
//"Sandeep Kulange" => String literal / literal

/* char[] data = new char[]{ 'S','a','n','d','e','e','p','

','K','u','l','a','n','g','e'};
String s1 = new String( data ); */
 String literals get space on String literal pool( Shared memory area for String instances on heap
).

What is this reference?

this is a keyword in Java.
this is pointer in C++ and reference in Java.
this reference is considered as implicit parameter to the method.
Method parameter do not get space inside instance. Since this is a method parameter, it doesn't get
space inside instance.
In Java, method local variable, method parameter and method call get space into Stack frame.
Stack frame get space into Java Stack and Java stack get space per thread.
this reference get space once per method call on java stack.
If we call non static method ( is also called as instance method ) on instance then compiler implicitly
pass reference of calling/current instance as argument to the method. To accept/catch reference of
instance, compiler impilicitly declare one reference variable as a method parameter. Such method
parameter is called as this reference.
Using this reference, non static fields and non static methods can communicate with each other.
Hence this reference is considered as a link/connection between them.

void acceptRecord( /*Employee this*/ ){

Scanner sc = new Scanner([Link]);
[Link]("Name : ");
[Link] = [Link]();
[Link]("Empid : ");
[Link] = [Link]();
[Link]("Salary : ");
[Link] = [Link]();
}

To access instance members of the class inside method, use of this keyword is optional.
 void acceptRecord( /*Employee this*/ ){
Scanner sc = new Scanner([Link]);
[Link]("Name : ");
name = [Link](); //OK
[Link]("Empid : ");
empid = [Link](); //Ok
[Link]("Salary : ");
salary = [Link](); //OK
}

Definition:
this reference is implicit reference variable which is available in every non static method /
instance method of class which is used to store reference of current / calling instance.
Consider code in C

int num1 = 10;

int main( void ){
int num1 = 20;
printf("Num1 : %d\n", num1);
return 0;
}

In C/C++, if name of local & global variable is same then preference is always given to the local
variable.
Consider code in java:

class Date{
int day, month, year;
void setDay( /* Date this,*/int day ){
//day = day; //Assignment to self
[Link] = day;
}
}
class Program{
public static void main(String[] args) {
Date date = new Date( );
[Link]( 23 ); //[Link]( date, 23 );
}
}

If name of method local variable / method paramater and name of field is same then preference is
always given to the local variable. In this case, If we want to give preference to field then we should
use this referene before field. For the reference consider above code.
 Static method do not get this reference.

Coding conventions in java:

Reference: [Link]
[Link]
Pascal case naming / coding convention
Consider examples:
String
StringBuffer
NumberFormatExcaption
IndexOutOfBoundsException
In this coding convention, including first word, first character of each word must be in upper case.
We should use this convention for:
For Type names( Interface/Clas/Enum etc )
For file name
Camel case naming / coding convention
Consider examples:
main
parseInt
showInputDialog
waitForPendingFinalizer
In this coding convention, excluding first word, first character of each word must be in upper case.
 We should use this convention for:
Field
Method
Method local variable and method parameter
Coding convention for package name
Consider examples:
[Link]
[Link]
[Link]
[Link]
package name should be in lower case.
Coding convention for enum constant
Consider example:

enum ShapeType{
LINE, RECTANGLE, CIRLE, TRIANGLE
}

Name of enum constants should be in uppercase.

Naming convention for final variable:
public static final int SIZE
public static final int BYTES
public static final int MIN_VALUE
public static final int MAX_VALUE
Name of final field should be in upper case.
OOPS concepts related to field and methods
If we delare fields( specifically instance variable ) inside class then it get space once per instance
according to order of their declaration inside class.
Method do not get space inside instance. Rather all the instances of "same class" share single copy
of method defined inside class.
By passing reference of current instance to the method, instances share single copy of the method.
Structure of instances of same class is always same/common.
 All the instances of same class share single copy of method.

Characteristics of instance
State
Value stored inside instance is called as state of that instance.
Value stored inside field represents state of the instance.
Behavior
Number / set of operations( behaviors/methods) which are allowed to perform/call on instance
represents behavior of the instance.
Methods defined inside class represents behavior of the instance.
Identity
Value of any field which is used to indentify instance uniquely is called its identity.
 Reference:
[Link]
[Link]
What is class and instance?
Class
Definition:
Class is a collection of fields and methods.
Structure and behavior of the instance depends on class hence class is considered as a
template model or blueprint for an insrance.
Class represents set of instances which is having common structure and common behavior.
Example: Car, Book, Laptop, Mobile Phone etc.
Class is imaginary / logical entity.
Class implementation represents encapsulation.
Reference:
[Link]
[Link]

Instance
Definition:
An entity which is having physical existance is called as instance.
In C++, physical entity is called as object and in Java it is called instance.
An entity which is having state, behavior and identity is called as instance.
 Example: Tata Nano, "Java Certification-Khalid Mughal", "MacBook Air", "iPhone-14"
Process of creating instance is called as instantiation.
By creating instance we are achieving abstraction.
null literal and NullPointerException
#define NULL ((void*)0) //C
#define NULL 0 //C++

NULL is macro which used to initialize pointer.

int *ptr = NULL;

Consider literals in Java:

true / false: boolean literals
0,1,9: integer literals
3.14: double literal
"DAC": String literal
null
null is literal in Java, which is used to initialize reference.

Employee emp1 = null;

Employee emp2 = new Employee( );

If reference contains, null value then reference variable is called as null reference variable / null
object.
Consider following code:

class Program{
public static void main(String[] args) {
Employee emp;
[Link](); // error: variable emp might not have been
initialized
[Link]();
}
}

Solution:

class Program{
public static void main(String[] args) {
Employee emp = null; //emp is null object
 [Link](); //[Link]
[Link]();
}
}

Using null object, if we try to access any instance member of the class then JVM throws
NullPointerException.
Reference: [Link]
Difference between value type and reference types
Reference: [Link]
Value type
Primitive type is also called as value type.
There are 8 value/primitive types in java.
boolean, byte, char, short, int, float, double, long
Variable of value type contains value.

int num1 = 10;

In case of copy operation, value gets copied.

int num1 = 10;

int num2 = num1;

In case of fields, variable of value type by default contains 0 value.

class Date{
int day; //0
int month; //0
int year; //0
}

We can not store null value inside variable of value type.

int number = null; //Not OK

We can not create variable/instance of value type using new operator;

 //int num1 = 10; //OK
int num1 = new int( 10 ); //Not OK

Variable of value type get space on Java stack( by considering it as method local variable ).
Reference type
Not primitive type is also called as reference type.
There are 4 reference/non primitive types in java.
interface, class, enum, array
Variable of reference type contains reference.

Integer i = new Integer(10);

In case of copy operation, reference gets copied.

Integer i1 = new Integer( 10 );

Integer i2 = i1;

In case of fields, variable of reference type by default contains null value.

class Employee{
String name; //null
Date joinDate; //null
}

We can store null value inside variable of reference type.

Integer number = null; //OK

To create instance of reference type, we must use new operator.

Integer i = new Integer( 10 );

Employee emp = new Employee( );

Instance of reference type get space on Heap section.

Memory allocation for reference variable
 class Date{
int day;
int month;
int year;
//TODO
}
class Employee{
static Scanner sc; //Static field
//sc is reference variable and it will get space on method area.
int empid; //Field
Date joinDate; //Non Static Field
//joinDate will get space inside Employee instance; i.e on Heap section.
}
class Program {
public static void main(String[] args) {
Employee emp = new Employee();
//Employee emp=> It is object reference. Since it is method local
varibale it will get space on Java Stack.
//new Employee( ); => It is Date instance. It will get space on
Heap.
}
public static void main1(String[] args) {
Date joinDate = new Date( );
//Date joinDate; => It is object reference. Since it is method local
varibale it will get space on Java Stack.
//new Date( ); => It is Date instance. It will get space on Heap.
}
}

Method local reference variable get space on Java stack.

Non static reference field get space inside instance on heap.
Static reference field get space on method area.
Method Overloading
Consider code in C programming language:

void sum( int num1, int num2 ){

int result = num1 + num2;
printf("Result : ",result);
}
void add( double num1, double num2 ){
double result = num1 + num2;
printf("Result : ",result);
}
int main( void ){
sum( 10, 20 );
add( 10.1, 20.2 );
return 0;
}
According to oops, If implementation of any method is logically same/equivalilent then we should give
same name to the method.
If we want to give same name to the method then we should follow some rules:
If we want to give same name to the methods and if type of all the parameters are same then
number of parameters passed to the method must be different.

class Program {
static void sum( int num1, int num2 ){ // 2 method parameters
int result = num1 + num2;
[Link]("Result : "+result);
}
static void sum( int num1, int num2, int num3 ){ // 3 method
parameters
int result = num1 + num2 + num3;
[Link]("Result : "+result);
}
public static void main(String[] args) {
[Link]( 10, 20 );
[Link]( 10, 20, 30 );
}
}

If we want to give same name to methods and if number of parameters passed to the method
are same then type of at least one parameter must be different.

class Program {
static void sum( int num1, int num2 ){ // 2 method parameters
int result = num1 + num2;
[Link]("Result : "+result);
}
static void sum( int num1, double num2 ){ // 2 method
parameters
double result = num1 + num2;
[Link]("Result : "+result);
}
public static void main(String[] args) {
[Link]( 10, 20 );
[Link]( 10, 20.5 );
}
}

If we want to give same name to the methods and if number of parameters passed to the
method are same then order of type of parameters must be different.

class Program {
static void sum( int num1, float num2 ){ // 2 method
 parameters
float result = num1 + num2;
[Link]("Result : "+result);
}
static void sum( float num1, int num2 ){ // 2 method
parameters
float result = num1 + num2;
[Link]("Result : "+result);
}
public static void main(String[] args) {
[Link]( 10, 20.2f );
[Link]( 10.1f, 20 );
}
}

Only on the basis of different return type, we can not give same name to methods.

class Program {
static void sum( int num1, int num2 ){ // 2 method
parameters
int result = num1 + num2;
[Link]("Result : "+result);
}
static int sum( int num1, int num2 ){ // 2 method parameters
int result = num1 + num2;
return result;
}
public static void main(String[] args) {
[Link]( 10, 20 );
[Link]( 10, 20 );
}
}

When we define multiple methods with same name using above rules then it is called as method
overloading.
In other words, process of defining methods with same name and different signature is called as
method overloading.
Methods, which are taking part in method overloading are called as overloaded methods.
If implementation of methods are functionally equivalilent / same then we should overload method i.e.
we should give same name to the methods.
Return type is not considered in method overloading.
return value from method as well as catching value from method is optional hence return type
is not considered in method overloading.
Constructor
Constructor chaining
Instance initialization block
Need of getter and setter methods
Day 5
Coding conventions:
Camel Case
Camel case is a naming convention in which the first letter of each word in a compound word is
capitalized, except for the first word.
Example: showInputDialog
Pascal Case
Pascal case is a naming convention in which the first letter of each word in a compound word is
capitalized.
Example: ArrayIndexOutOfBoundsException
Snake Case
Snake case combines words by replacing each space with an underscore (_).
Example:MAX_VALUE
Kebab Case
Kebab case is the way to write compound words separated by hyphens (-) instead of using
space. Generally, everything is written in lowercase.
Example: “what-is-kebab-case”
Declaration and Definition
According to Dennis Ritchie, declaration refers to the place where nature of the variable is stated but
no storage is allocated.

int main( void ){

int num1; //Declaration as well as definition
extern int num2; //Declaration
int num3 = 30; //Declaration as well as definition
printf("%p\n", &num1); //OK
printf("%p\n", &num2); //Linker Error
return 0;
}

Definition refers to the place where storage is allocated / assigned.

Scope in C
Block scope
Function scope
Prototype scope
File scope
Program scope
 int num6 = 60; //Program Scope
static int num5 = 30; //File Scope
int main( void ){
//Function Declaration
int sum( int num1, int num2 ); //Prototype scope

int num3 = 10; //Function Scope

//Start new block here
{
int num4 = 20; //Block Scope
}
sum( 10, 20 ); //Function Call
return 0
}
int sum( int num1, int num2 ){ //Function Definition
return num1 + num2;
}

Initialization( Revision )
Process of providing value to the variable during its declaration is called as initialization.

int number = 10; //Initialization

int num1 = 10; //Initialization

int num2 = num1; //Initialization

We can initialize any variable only

Constructor
A block of code( which looks like method but it is not considered as method ) which is used to
initialize instance, is called as constructor of the class.
Constructor is considered as special syntax of the class due to following reasons:
Its name is same as class name.
It doesn't have any return type.
It gets called implicitly.
In the lifetime of instance, constructor gets called only once.

class Date{
int day;
int month;
int year;
Date( ){ //Constructor
LocalDate ld = [Link]();
 [Link] = [Link]();
[Link] = [Link]();
[Link] = [Link]();
}
}

For the referece, JVM do not call constructor.

JVM give call to the constructor once per instance.
We can not call constructor on instance explicitly. It is designed to call implicitly.

import [Link];
import [Link];
class Date{
int day;
int month;
int year;
Date( ){ //Constructor
[Link]("Inside constructor");
LocalDate ld = [Link]();
[Link] = [Link]();
[Link] = [Link]();
[Link] = [Link]();
}
}
class Program{
public static void main(String[] args) {
Date dt1 = new Date(); //Here constructor will call implicitly
//[Link]( ); //Not allowed
}
public static void main1(String[] args) {
//Date dt1 = null; //Here construcor will not be call
//new Date( ); //Here constructor will call on anonymous
instance
Date dt2 = new Date(); //Here constructor will call on only once
}
}

Reference: [Link]
Types of constructor
There are 3 types of constructor in Java:
Parameterless constructor
Parameterized constructor
Default constructor
Parameterless constructor
It is also called as zero argument constructor / programmer defined default constructor.
 Consider example:

Date( ){ //Parameterless Constructor

[Link] = 0;
[Link] = 0;
[Link] = 0;
}

A constructor which do not take any parameter is called as Parameterless constructor.

Consider following code snippet:

Date dt = new Date( );

If we create instance without passing arguments( i.e. we are passing 0 arguments ) then
Parameterless constructor gets called.
Parameterized constructor
A constructor which take parameter is called as Parameterized constructor.
Consider example:

Date( int day, int month, int year ){ //Parameterized Constructor

[Link]("Inside constructor");
[Link] = day;
[Link] = month;
[Link] = year;
}

Consider following code snippet:

Date dt1 = new Date( 23, 7, 1983 );

If we create instance by passing arguments then parameterized construcor gets called.

We can define multiple constructors inside class. It is called as constructor overloading.

class Date{
int day;
int month;
int year;
Date( ){
[Link]("Inside parameterless constructor");
 [Link] = 0;
[Link] = 0;
[Link] = 0;
}
Date( int day, int month, int year ){ //Constructor
[Link]("Inside parameterized constructor");
[Link] = day;
[Link] = month;
[Link] = year;
}
}
class Program{
public static void main(String[] args) {
Date dt1 = new Date( 23, 7, 1983 );

Date dt2 = new Date( );

}
}
/*
sandeep@Sandeeps-MacBook-Air Day_5.5 % javac [Link]
sandeep@Sandeeps-MacBook-Air Day_5.5 % java Program
Inside parameterized constructor
Inside parameterless constructor
*/

Constructor calling sequence depends on order of instance declaration.

Default constructor
If we do not define any constructor( no parameterless / no parameterized ) inside class then compiler
generates once constructor for the class by default. It is called as default constructor.
Default constructor is zero argument constructor.
Consider following code:

class Date{
int day;
int month;
int year;
}
class Program{
public static void main(String[] args) {
Date dt1 = new Date( ); //OK
//Here on instance, default constructor will call
}
}

Consider following code:

 class Date{
int day;
int month;
int year;
}
class Program{
public static void main(String[] args) {
Date dt1 = new Date( ); //OK
//Compiler can generate only default parameterless constructor

Date dt2 = new Date( 1,4,2023); //NOT OK

//Compiler never generate default parameterized constructor
}
}

Consider following code:

class Date{
int day;
int month;
int year;

Date( int day, int month, int year ){ //parameterized constructor

[Link] = day;
[Link] = month;
[Link] = year;
}
}
class Program{
public static void main(String[] args) {
Date dt1 = new Date( ); //Error
Date dt2 = new Date( 1,4,2023);
}
}

Consider constructors of [Link] class

public Integer(int value)

//Integer i1 = new Integer( ); //Not OK

int value = 123;
Integer i1 = new Integer( value ); //OK
Integer i2 = new Integer( 123 ); //OK

public Integer(String s) throws NumberFormatException

 String s = "123";
Integer i1 = new Integer( s ); //OK
Integer i2 = new Integer( "123"); //OK
Integer i3 = new Integer( "a1b2c3"); //NumberFormatException

Consider constructors of [Link] class

public String()

String s1 = new String( );

public String(String original)

String str = "Hello";

String s2 = new String( str );
String s3 = new String( "Hello" );

String s1 = new String( "Hi" );

String s2 = new String( s1 );

Explicit constructor invocation

To reuse body of exisiting constructor we can call constructor from another constructor. It is called as
constructor chaining.
For constructor chaining we should use this statement.

class Date{
int day;
int month;
int year;

Date( ){
//Explicit call to the construcor
this( 1, 4, 2023); //Constructor chaining
}
Date( int day, int month, int year ){
[Link] = day;
[Link] = month;
[Link] = year;
}
}

this statement must be first statment inside constructor.

 Consider example of Stack:

class Stack{
int top;
int[] arr;
Stack( ){
this( 5 ); //Constructor chaining
}
Stack( int size ){
[Link] = -1;
[Link] = new int[ size ];
}
}

Reference: [Link]
Stack
Data structure describes two things:
How to organize data in ram.
Which operations should be used to organise data inside RAM.
Types of data structure:
Linear / sequential data structure
Array, Stack, Queue, LinkedList etc.
Non Linear data structure
Tree, Graph, Hashtable etc.
Stack is a linear data structure in which we can manage elements in Last In First Out order( LIFO ).
We can perform following operations on Stack:
boolean empty( );
void push( int element );
int peek( );
boolean full( );
void pop();
Value stored inside data structure is called element.
Consider syntax of array:

int[] arr = new int[ 3 ]; //Single dimensional array

Instance initialization block

Consider following code:

class Stack{
int top;
int[] arr;
 {//Instance initialization block
[Link] = -1;
}
Stack( ){
//[Link] = -1;
[Link] = new int[ 5 ];
}
Stack( int size ){
//[Link] = -1;
[Link] = new int[ size ];
}
}

Reference: [Link]
Access Modifier
In Java, parent class is called as super class and child class is called as sub class.
The modifiers, which are used to control visibility of the members of the class is called access
modifiers.
There are 4 access modifiers in Java:
private
package level private ( no modifier / default means --> package level private )
protected
public

Reference: [Link]
Need of Getter and Setter method
Process of declaraing fields of the class private is called as data hiding.

class Student{
//Data hiding
private String name;
private int rollNumber;
private float marks;
}

Data hiding is also called as data encapsulation.

 Process of giving controlled access to the data is called as data security.

class Student{
private String name;
private int rollNumber;
private float marks;
public void setMarks( float marks ){
if( marks > 100 )
throw new IllegalArgumentException("Invalid marks.");
[Link] = marks;
}
//acceptRecord
}
class Program{
public static void main(String[] args) {
Student s1 = new Student();
[Link]( 101 );
}
}

Final modifier
Absolute path and relative path
Reference: [Link]
Path and classpath
Reference: [Link]
[Link] class
Reference: [Link]
Use below command on terminal to get more details:

javap [Link]

toString method
Day 6
class Employee{
//TODO : Fields
//TODO : Ctor
//TODO : Getters and Setters
}
class EmployeeTest{
/* Employee emp;
public EmployeeTest(){
emp = new Employee();
} */
private Employee emp = new Employee( );
//TODO: acceptRecord()
//TODO: printRecord()
}
class Program{
public static void main(String[] args) {
EmployeeTest test = new EmployeeTest( );
//TODO: accept and print
}
}

Final Modifier
Final method local variable

class Program{
public static void main(String[] args) {
int number = 10; //Initialization
number = number + 5;
[Link]("Number : "+number); //15
}
}

After storing value inside variable, if we dont want to modify its value then we should use final
modifier.
In java, we can declare local variable final.

class Program{
public static void main(String[] args) {
final int number = 10; //Initialization
number = number + 5; //error: cannot assign a value to final
variable number
[Link]("Number : "+number);
 }
}

class Program{
public static void main(String[] args) {
final int number;
number = 10; //Assignment
//number = number + 5; //error: variable number might already
have been assigned
[Link]("Number : "+number); //10
}
}

public static void main(String[] args) {

final int number = 10; // //Initialization
//number = 20; //error: cannot assign a value to final variable
number
[Link]("Number : "+number); //10
}

class Program{
private static Scanner sc = new Scanner([Link]);
public static void main(String[] args) {
[Link]("Number : ");
final int number = [Link](); // //Initialization
//number = 20; //error: cannot assign a value to final variable
number
[Link]("Number : "+number); //10
}
}

We can provide value to final variable before compilation as well as after compilation.
Final field
We can declare fiel final.
After initialization, if we dont want to modify value of any field inside any method of the class
including constructor body then we should declare field final.
We must provide value to the final field either inside constructor body or at the time of declaration.

class Test{
//Field
private final int number; //NOT OK
}
 class Test{
//Field
private final int number = 10; //OK
}

class Test{
//Field
private final int number;
public Test( ){
[Link] = 10; //OK
}
}

class Test{
//Field
private final int number = 10; //OK
public Test( ){
[Link] = 20; //Not OK
}
}

Generally we should use snake case convention for final field.

class Test{
private final int NUMBER = 10; //Field
public void showRecord( ){
//[Link] = [Link] + 1; //Not OK
[Link]("Number : "+[Link]);
}
public void printRecord( ){
//[Link] = [Link] + 1; //Not OK
[Link]("Number : "+[Link]);
}
}
class Program{
public static void main(String[] args) {
Test t = new Test();
[Link](); //10
[Link](); //10
[Link](); //10
}
}
 We will discuss final method and final class in inheritance.
We can declare method final.
We can not redfine/override final method inside sub class.
We can declare class final.
We can not create sub class of final class.
What is the meaning of "final Complex c1 = new Complex( 10, 20);" statement?

class Complex{
private int real;
private int imag;
public Complex( ){
this( 0, 0);
}
public Complex( int real, int imag ){
[Link] = real;
[Link] = imag;
}
public int getReal() {
return [Link];
}
public void setReal(int real) {
[Link] = real;
}
public int getImag() {
return [Link];
}
public void setImag(int imag) {
[Link] = imag;
}
}
class Program{
public static void main(String[] args) {
final Complex c1 = new Complex( 10, 20);
[Link](100); //OK
[Link](200); //OK
[Link]("Real Number : "+[Link]()); //100
[Link]("Imag Number : "+[Link]()); //200

c1 = new Complex( 50, 60); //error: cannot assign a value to final

variable c1
}
}
 In Java, we can declare reference final but we can not declare instance final.

Absolute path versus Relative Path

Absolute path
Example: D:\CDAC\Sandeep\Java\Day6\Day_6.1\src\[Link].
A path of a file / directory from root directory is called as absolute path.
Relative Path
.. represents parent directory
. represents current directory
Change directory: cd D:\CDAC\Sandeep\Java\Day6\Day_6.1
Example : .\src\[Link]
Path of a file / directory from current directory is called as relative path.
Path versus Classpath
Path
Path is OS platforms environment varible which is used to locate java development tools.
How to set path?
set path="C:\Program Files\Java\jdk_1.8.0_361\bin"; //In MS Windows
export PATH=/usr/bin/
Classpath
 Classpath is Java platforms environment variable which is used to locate .class / .jar files
How to set classpath?
set classpath=.\bin;
export CLASSPATH=./bin;

Introduction of Object class

abstract class Number{ //Parent class / Super class
//TODO
}
final class Integer extends Number{ //Child class / Sub class
//TODO
}

In Java, parent class is called as super class and child class is called as sub class.
Object is a concrete class declared in [Link] package.
[Link] do not extend any class or do not implement any interface. In other words, it is super
class of all the classes( not interfaces ) in core Java.
It is also called as ultimate base class / super cosmic base class / root of java class hierarchy.

abstract class Number extends Object{

//TODO
}
final class Integer extends Number{
//TODO
}
 class Program extends Object{
public static void main(String[] args) {
[Link]("Hello World");
}
}

Any class can contain:

Nested types( interface / class / enum )
Field
Constructor
Methods
Blocks( instance / static )
[Link] class do not contain any nested type and field.
[Link] class contains only parameterless constructor.

Object o1 = new Object("Sandeep"); //Not OK

Object o2 = new Object( ); //OK

There are 11 methods( 5 non final( 2 native + 3 non native ) + 6 final methods( 4 native + 2 non native
methods)) in [Link] class.
Use following command to check signature of methods:

javap [Link]

5 Non final methods of [Link] class( we can override these methods inside sub class
)
public String toString( );
public boolean equals( Object obj );
public native int hashCode( );
protected native Object clone( )throws CloneNotSupportedException
protected void finalize( )throws Throwable
6 Final methods of [Link] class
public final native Class<?> getClass()
public final void wait( ) throws InterruptedException
public final native void wait( long timeout ) throws InterruptedException
public final void wait( long timeout, int nanos ) throws InterruptedException
public final native void notify();
public final native void notifyAll();
Overriding toString method
toString is a non final method of [Link] class
 public String toString( );

If we want to return state of the instance in String form then we should use toString method.
If we do not define toString() method inside class then super class's toString method will call. If any
super class do not contain toString() method then Object class's toString() method will call.
Consider definition of toString method from [Link] class:

public String toString() {

return [Link]().getName() + "@" +
[Link]([Link]());
}

toString() method of [Link] class returns String in following form:

[Link] name@Hexadecial HashCode

Hashcode is not an address / reference of the instance. It is a logical integer number which can
be generated by processing state of the instance.
According to client's requirement, If implementation of super class method is partially complete the
we should redefine/override method inside sub class.
If we dont want hashCode then we should override toString() method inside sub class.

public String toString( ){

return [Link]+" "+[Link]+" "+[Link]+"
"+[Link]+" "+[Link];
}

The result in toString() method should be a concise but informative that is easy for a person to read.

public String toString( ){

return [Link]+" "+[Link]+" "+[Link];
}

public String toString( ){

return [Link]("%-25s%-10d%-10.2f", [Link], [Link],
[Link]);
}

Static Field
If we create instance of the class then all the fields get space inside instance.

class Test{
private int num1;
private int num2;
private int num3;
public Test( int num1, int num2 ){
this.num1 = num1;
this.num2 = num2;
this.num3 = 500;
}
}
class Program {
public static void main(String[] args) {
Test t1 = new Test( 10, 20 ); //10,20,500
Test t2 = new Test( 30, 40 ); //30,40,500
Test t3 = new Test( 50, 60 ); //50,60,500
}
}

If we want to share, value of any field inside all the instances of same class then we should declare
field static.
A field of the class, which get space inside instance is called as instance variable. In other words, only
non static field get space inside instance. Hence non static field is also called as instance variable.
Instance variable get space once per instance on heap memory.
To use instance variable we must use object reference.
A field of the class which do not get space inside instance is called as class level variable. In other
words, static fields do not get space inside instance. Hence static field is also called as class level
variable.
Class level variable get space during class loading once per class on method area.
To access class level variable we should use class name and dot operator.

class X{
private int num1;
private int num2;
private static int count = 500;
}
X x1 = new X(10,20); //10,20, 500
X x2 = new X(30,40);//30,40,500
X x3 = new X(50,60);//50,60,500

class Y{
private int num3;
private int num4;
private static int count = 600;
}
Y y1 = new Y(11,12); //11,12,600
Y y2 = new Y(13,14); //13,14,600
Y y3 = new Y(15,16); //15,16,600

class Z{
private int num5;
private int num6;
private static int count = 700;
}
Z z1 = new Z(21,22); //21,22,700
Z z2 = new Z(23,24); //23,24,700
Z z3 = new Z(25,26); //25,26,700

class Test{
private int num1;
private int num2;
private static int num3;

//Static initialization block

static {
Test.num3 = 500;
}
public Test( int num1, int num2 ){
this.num1 = num1;
this.num2 = num2;
}
public void printRecord( ){
[Link]("Num1 : "+this.num1);
 [Link]("Num2 : "+this.num2);
[Link]("Num3 : "+Test.num3);
}
}
class Program {
public static void main(String[] args) {
Test t1 = new Test( 10, 20 ); //10,20,500
[Link]();
}
}

Static Initializer block

To intialize non static fields we should use constructor and to intialize static field we should use static
initialization block.

class Test{
private int num1;
private int num2;
private static int num3;

//Static initialization block

static {
Test.num3 = 500;
}
public Test( int num1, int num2 ){
this.num1 = num1;
this.num2 = num2
}
}
 We can define multiple static blocks inside class. In this case JVM execute it sequentially.
Static Method
To access non static members of the clas we should define non static method inside class and to
access static members of the class we should define static method inside class.
Non static method is designed to call on instance hence it is called as instance method and static
method is designed to call on class name hence it is called as class level method.
To access instance method we should use instance and to access class level method we should use
class name and dot operator.
According to Java concept, this reference is considered as a link/connection between instance
variable and instance method.
Static method do not get this reference.
Why static method do not get this reference?
If we call non static method on instance then non static method get this reference.
Static method is designed to call on class name.
Since static method is not designed to call on instance, it doesn't get this reference.
Since static method do not get this reference, we can not access non static members directly inside
static method.
In other words, static method can access only static members of the class.

class Program{
public int num1 = 10;
public static int num2 = 20;
public static void main(String[] args) {
//[Link]( num1 ); //Not OK
Program p = new Program();
[Link]( p.num1 );
[Link]( num2 ); //OK
}
}

Using instance, we can access non static members inside static method.
Count instances of the class
Singleton class
Day 7
static method
Inside method, if there is need to use this reference then method should be non static otherwise
method should be static.

class Program{
/* public double power( double base, int index ){
double result = 1;
for( int count = 1; count <= index; ++ count )
result = result * base;
return result;
} */
public static double power( double base, int index ){
double result = 1;
for( int count = 1; count <= index; ++ count )
result = result * base;
return result;
}
public static void main(String[] args) {
//Program p = new Program();
//double result = [Link](2, 3);

double result = [Link](2, 3); //OK

//double result = power(2, 3); //OK
[Link]("Result : "+result);
}
}

If constructor is public then we can create instance of the class inside method of same class as well
as method of different class.

class Complex{
private int real;
private int imag;
public Complex( ){
[Link]("Inside constructor.");
[Link] = 10;
[Link] = 20;
}
public static void test( ){
Complex c2 = new Complex(); //OK
}
}
class Program{
public static void main(String[] args) {
Complex c1 = new Complex(); //OK
[Link]();
 }
}

We can declare constructor private.

If constructor is private then we can create instance of the class inside method of same class only.

class Complex{
private int real;
private int imag;
private Complex( ){
[Link]("Inside constructor.");
[Link] = 10;
[Link] = 20;
}
public static void test( ){
Complex c2 = new Complex(); //OK
}
}
class Program{
public static void main(String[] args) {
//Complex c1 = new Complex(); //NOT OK
[Link]();
}
}

Instance Counter
class InstanceCounter{
private static int count;
public InstanceCounter( ){
[Link] = [Link] + 1;
}
public static int getCount() {
return [Link];
}
}
class Program{
public static void main(String[] args) {
InstanceCounter c1 = new InstanceCounter();
InstanceCounter c2 = new InstanceCounter();
[Link]("Instance Count : "+[Link]());
}
}

Method local variable get space once per method call.

 class Program{
public static void printRecord( ){
int count = 0; //Non Static Method Local Variable
count = count + 1;
[Link]("Count : "+count);
}
public static void main(String[] args) {
[Link](); //1
[Link](); //1
[Link](); //1
}
}

In Java, we can declate local variable final but we can not declare it static.

public static void printRecord( ){

static int count = 0; //error: illegal start of expression
count = count + 1;
[Link]("Count : "+count);
}

Static variable is also called as class level variable. According to oops, class level variable should be
declared inside class scope. Hence we can not declare local variable static. But we can declare field
static.

class Program{
private static int count = 0;
public static void printRecord( ){
count = count + 1;
[Link]("Count : "+count);
}
public static void main(String[] args) {
[Link](); //1
[Link](); //2
[Link](); //3
}
}

Design pattern
Reusable solution which is used to solve common problems during development is called as design
pattern.
Creational
Abstract factory
Builder
Factory method
 Prototype
Singleton
Structural
Adapter
Bridge
Composite
Decorator
Facade
Flyweight
Proxy
Behavioral
Chain of responsibility
Command
Interpreter
Iterator
Mediator
Memento
Observer
State
Strategy
Template method
Visitor
Singleton class
A class from which we can create only one instance is called as singleton class.
Method 1:

class Singleton{
private Singleton( ){
//TODO
}
private static Singleton reference;
public static Singleton getReference( ){
if( reference == null )
reference = new Singleton( );
return reference;
}
}
class Program{
public static void main(String[] args) {
Singleton s1 = [Link]();
Singleton s2 = [Link]();
}
}
 Method 2

class Singleton{
private int num1;
private int num2;
private static Singleton reference;
static{
reference = new Singleton();
}
public static Singleton getReference() {
return reference;
}
private Singleton( ){
this.num1 = 10;
this.num2 = 20;
}
}
class Program{
public static void main(String[] args) {
Singleton s1 = [Link]();
Singleton s2 = [Link]();
}
}

Package
It is a Java language feature which is used:
To avoid name clashing/collision/ambiguity/conflict

[Link]
[Link]

To group functionally equivalent / related types together.

Package is a logical concept. In other words we can not create instance of package.
In Java, Package can contain:
Sub Package
Interface
Class
Enum
Exception
Error
Annotation Types
Consider following example:

[Link]
//java : main package
//lang : sub package
//Object : Type name( interface, class....etc)

package is a keyword in Java.

How to define class inside package?
In C++
namespace std{
class Complex{
//TODO: Member declaration
};
}

In Java

package p1; //package declaration statement

class Complex{ //packaged class
//TODO: Member declaration
};

If we define any class inside package then it is called as packaged class.

Package declaration statment must be first stament in .java file.

class Complex{
//TODO: Member declaration
};
package p1; //Not OK

package p1; //OK

package p2; //Not OK
class Complex{
//TODO: Member declaration
};

package p1; //OK

import [Link];
import [Link];
class Complex{
//TODO: Member declaration
};

If we do not define any class inside package then it is considered as a member of default
package.

class Complex{
//TODO: Member declaration
};
 Java compiler maps pakage name with the folder.
If we want to use any type(class/interface) in different package then
Either we should use import statement
Or fully qualified type name
Consider following code:

//File Name: [Link]

package p1;
??? class TComplex { //Here ??? means package level private
public String toString() {
return "[Link]( )";
}
}

If we do not specify access modifier then default modifier of class is always package level private.
If access modifier of type is package level private then we can not access it outside the package.
If we want to use any type outside the package then type must be public.
According to Java Language Specification(JLS), name of the public class and name of the .java file
must be same.

//File Name: [Link]

package p1;
public class Complex {
public String toString() {
return "[Link]( )";
}
}

Since name of the public class and name of the .java file must be same, we can not define multiple
public classes in single .java file.
We can not declare class private or protected. In other words, access modifier of a class can be
either package level private or public only.
Demo 1
Consider code in [Link]

//File Name: [Link]

package p1;
public class Complex {
public String toString() {
return "[Link]( )";
}
}
Compile [Link]

javac -d .\bin .\src\[Link]

Consider code in [Link]

import [Link];
class Program{
public static void main(String[] args) {
//[Link] c1 = new [Link]();
Complex c1 = new Complex();
[Link]( [Link]());
}
}

Compile [Link]

set classpath=.\bin;
javac -d .\bin .\src\[Link]

Execute Java application

java Program
 Conclusion: we can access packaged class inside unpackaged class.

Demo 2
Consider [Link]

//File Name: [Link]

public class Complex {
public String toString() {
return "[Link]( )";
}
}

Compile [Link]

javac -d .\bin .\src\[Link]

Consider [Link]

package p1;
class Program{
public static void main(String[] args) {
Complex c1 = new Complex();
 [Link]( [Link]());
}
}

Compile [Link]

set classpath=.\bin;
javac -d .\bin .\src\[Link] //error: cannot find symbol Complex

If we define any class without package then it is considered as a member of default package.
Conclusion: Since we can not import default package, It is impossible to use unpackged class inside
packaged class.
Demo 3
Consider [Link]

package p1;
public class Complex {
public String toString() {
return "[Link]( )";
}
}

Compile [Link]

javac -d .\bin .\src\[Link]

Consider [Link]

package p2;
import [Link];
class Program{
public static void main(String[] args) {
Complex c1 = new Complex();
[Link]( [Link]());
}
}

Compile [Link]
 set classpath=.\bin;
javac -d .\bin .\src\[Link]

Execute Java application

java Program //Error: Could not find or load main class Program
java [Link] //OK

Conclusion: We can define every class in separte package.

Demo 4
Consider [Link]

package p1;
public class Complex {
public String toString() {
return "[Link]( )";
}
}

Compile [Link]

javac -d .\bin .\src\[Link]

 Consider [Link]

package p1;
//import [Link]; //Optional
class Program{
public static void main(String[] args) {
Complex c1 = new Complex();
[Link]( [Link]());
}
}

Compile [Link]

set classpath=.\bin;
javac -d .\bin .\src\[Link]

Execute Java application

java [Link]

Demo 5
 Consider [Link]

package p1.p2;
public class Complex {
public String toString() {
return "[Link]( )";
}
}

Compile [Link]

javac -d .\bin .\src\[Link]

Consider [Link]

package p1.p3;
import [Link];
class Program{
public static void main(String[] args) {
Complex c1 = new Complex();
[Link]( [Link]());
}
}

Compile [Link]

set classpath=.\bin;
javac -d .\bin .\src\[Link]

Execute Java application

java [Link]

Conclusion: We can define class inside sub packages.

[Link] package contains all the fundamental classes of core Java. Java compiler by default import
[Link] package in every .java file. Hence to use types declared in [Link] package use of import
statement is optional.
import and static import
Find area of circle:
 class Program{
public static void main(String[] args) {
double radius = 10.5;
double area = [Link] * [Link](radius, 2);
[Link]("Area : "+area);
}

Is it possible to access static members of differnt class without class name.

import static [Link];

import static [Link];
class Program{
public static void main(String[] args) {
double radius = 10.5;
double area = PI * pow(radius, 2);
[Link]("Area : "+area);
}
}

Without class name, if we want to access static members of the class then we should use static
import.

import static [Link];

import static [Link];
import static [Link];
class Program{
public static void main(String[] args) {
double radius = 10.5;
double area = PI * pow(radius, 2);
[Link]("Area : "+area);
}
}

If we want to use any type( interface, class, enum, error, exception, annotation) outside package then
we should use import statement.
If we want to use static members of the class, without class outside class name, then we should use
static import.
naming conventions for package
[Link]
[Link]
[Link]
oracle. jdbc. driver.
[Link]
Reference: [Link]
Eclipse introduction
Day 8
Which are non primitive types in Java?
Interface
Class
Enum
Array
Array
How will you store 3 integer values in Java program?
First approach

int num1 = 10;

int num1 = 20;
int num1 = 30;

Second approach

int arr[ 3 ] = { 10, 20, 30 }; //In C/C++

 arr is name of the array
Array size is 3
10, 20, 30 are elements.
Index of 10 is 0
Index of 20 is 1
Index of 30 is 2
Definition
Array is a linear / seqiential data structure in which, we can store multiple elements of same
type in continuous memory location.
In Java, array is non primitive/reference type. In other words, to create array instance we must
use new operator.
If we want to process elements of array then we should use method declared in:
[Link]
[Link]( Reflection )
[Link]
Donwload jar from
"[Link]
location
Types of array
Single dimensional array
Multi dimensional array
Ragged array
Types of loop
do-while loop
while loop
for loop
foreach loop
Single dimensional array
Array reference declaration:

int arr[ ]; //OK

int [ arr ]; //Not OK
 int[ ] arr; //OK: Recommended
int[ ] arr = null; //OK

Instantiation of array

new int[ 3 ]; //Array instance with default value: 0

new boolean[ 3 ]; //Array instance with default value: false

Array instance with reference:

int[] arr = null;

arr = new int[ 3 ];

int[] arr = new int[ 3 ];

 int[] arr = new int[ -3 ]; //NegativeArraySizeException

Scanner sc = new Scanner( [Link] );

[Link]("Enter array size : ");
int size = [Link]();
int[] arr = new int[ size ];

Consider example of do-while loop

public static void main(String[] args) {

int[] arr = new int[ 3 ]; //OK
int index = 0;
do {
[Link]("arr[ "+index+" ] : "+arr[ index ]);
index = index + 1;
}while( index < 3 ); //Exit controlled loop
}

Consider example of while loop

public static void main(String[] args) {

int[] arr = new int[ 3 ]; //OK
int index = 0;
while( index < 3 ) { //Entry controlled loop
[Link]("arr[ "+index+" ] : "+arr[ index ]);
index = index + 1;
 }
}

Consider example of for loop

public static void main(String[] args) {

int[] arr = new int[ 3 ]; //OK
for( int index = 0; index < 3; ++ index )
[Link]("arr[ "+index+" ] : "+arr[ index ]);
}

Consider example of foreach loop

public static void main(String[] args) {

int[] arr = new int[ 3 ]; //OK
//ForEach loop; It is also called as iterator
for(int element : arr ) //( Forward only & read only loop)
[Link](element);
}

How will you initialize array in Java?

int[] arr = new int[ ]{ 10, 20, 30 }; //OK

int[] arr = { 10, 20, 30 }; //OK

int[] arr = new int[ 3 ]{ 10, 20, 30 }; //NOT OK

length is a property of array data structure which returns size/length of the array.

private static void printRecord(int[] arr) {

for( int index = 0; index < [Link]; ++ index )
[Link]( arr[ index ]+" ");
[Link]();
}
public static void main(String[] args) {
int[] arr1 = new int[ ]{ 10, 20, 30, 40, 50 }; //OK
[Link]( arr1 );

int[] arr2 = new int[ ]{ 10, 20, 30 }; //OK

[Link]( arr2 );

int[] arr3 = new int[ ]{ 10, 20, 30, 40, 50, 60, 70 }; //OK
[Link]( arr3 );
}
How will accept and print record of array

public class Program {

static Scanner sc = new Scanner([Link]);
private static void acceptRecord(int[] arr) {
if( arr != null ) {
for( int index = 0; index < [Link]; ++ index ) {
[Link]("Enter element : ");
arr[ index ] = [Link]();
}
}
}
private static void printRecord(int[] arr) {
if( arr != null ) {
for( int index = 0; index < [Link]; ++ index )
[Link]( arr[ index ]+" ");
}
[Link]();
}
public static void main(String[] args) {
//int[] arr = null;
int[] arr = new int[ 3 ];

[Link]( arr );

[Link](arr);
}
}

How to use for each loop on array

public class Program {

private static void printRecord(int[] arr) {
 if (arr != null) {
for( int element : arr )
[Link](element+" ");
}
[Link]();
}

public static void main(String[] args) {

int[] arr = new int[] { 10, 20, 30 };
[Link](arr);
}
}

Consider following code:

public class Program {

public static void main(String[] args) {
boolean[] arr1 = new boolean[3];
[Link]( [Link]()); //[Z@6d06d69c

byte[] arr2 = new byte[3];

[Link]( [Link]()); //[B@7852e922

char[] arr3 = new char[3];

[Link]( [Link]()); //[C@4e25154f

short[] arr4 = new short[3];

[Link]( [Link]()); //[S@70dea4e

int[] arr5 = new int[3];

[Link]( [Link]()); //[I@5c647e05

float[] arr6 = new float[3];

[Link]( [Link]()); //[F@33909752

double[] arr7 = new double[3];

[Link]( [Link]()); //[D@55f96302

long[] arr8 = new long[3];

[Link]( [Link]()); //[J@3d4eac69

String[] arr9 = new String[3];

[Link]( [Link]());
//[[Link];@42a57993

int[][] arr10 = new int[3][3];

[Link]([Link]()); //[[I@75b84c92

int[][][] arr11 = new int[3][3][3];

[Link]([Link]()); //[[[I@6bc7c054
}
}
 Reference: Please check documentation of [Link] class: public String getName()
If we want to get elements of array using toString() method then we should using toString method of
[Link] class.

public static void main(String[] args) {

int[] arr = new int[ ] { 10, 20, 30 };
[Link]( [Link](arr) );
}

Using illeagal index, if we try to access elements of array then JVM throws
ArrayIndexOutOfBoundsException.

public class Program {

public static void main(String[] args) {
int[] arr = new int[ ] { 10, 20, 30 };
int element = arr[ [Link] ];
//ArrayIndexOutOfBoundsException
[Link]( element );
}
public static void main2(String[] args) {
int[] arr = new int[ ] { 10, 20, 30 };
int element = arr[ 3 ]; //ArrayIndexOutOfBoundsException
[Link]( element );
}
public static void main1(String[] args) {
int[] arr = new int[ ] { 10, 20, 30 };
int element = arr[ -1 ]; //ArrayIndexOutOfBoundsException
[Link]( element );
}
}

How will you create array of primitive values

Consider following

boolean[] arr = new boolean[ ]{ true, false, true };

int[] arr = { 10, 20, 30 };
double[] arr = new double[ 3 ];
arr[ 0 ] = 1.1;
arr[ 1 ] = 1.2;
arr[ 2 ] = 1.3;
 If we create array of primitive type then it contains values. If we do not specify value then default
value is depends of default value of data type.
How will you create array of references
If we create of references then array by default contains null value.
Consider following code:

package [Link];

import [Link];
import [Link];
class Date{
private int day;
private int month;
private int year;

public Date() {
LocalDate ld = [Link]();
[Link] = [Link]();
[Link] = [Link]();
[Link] = [Link]();
}

public Date(int day, int month, int year) {

[Link] = day;
[Link] = month;
[Link] = year;
}

@Override
public String toString() {
return [Link]+" / "+[Link]+" / "+[Link];
}
 }
public class Program {
public static void main(String[] args) {
Date[] arr = new Date[ 3 ]; //Array of references
[Link]( [Link](arr)); //[null, null,
null]
}
}

How will you create array of instances

Consider following code

public static void main(String[] args) {

Date[] arr = new Date[ 3 ]; //Array of references
for( int index = 0; index < [Link]; ++ index )
arr[ index ] = new Date();

for( int index = 0; index < [Link]; ++ index )

[Link]( arr[ index ].toString()); //OK
}
How can we pass argument to the function in C++?
We can pass argument to the function by value.

//int a = x;
//int b = y;
void swap( int a, int b ){
int temp = a;
a = b;
b = temp;
}
int main( void ){
int x = 10;
int y = 20;

swap( x, y ); //Function call by value

cout<<"X : "<< x <<endl; //10

cout<<"Y : "<< x <<endl; //20
return 0;
}

We can pass argument to the function by address.

//int *a = &x;
//int *b = &y;
void swap( int *a, int *b ){
int temp = *a;
*a = *b;
*b = temp;
}
 int main( void ){
int x = 10;
int y = 20;

swap( &x, &y ); //Function call by address

cout<<"X : "<< x <<endl; //20

cout<<"Y : "<< x <<endl; //10
return 0;
}

- We can pass argument to the function by reference.

```java
//int &a = x;
//int &b = y;
void swap( int &a, int &b ){
int temp = a;
a = b;
b = temp;
}
int main( void ){
int x = 10;
int y = 20;

swap( x, y ); //Function call by reference

cout<<"X : "<< x <<endl; //20

cout<<"Y : "<< x <<endl; //10
return 0;
}

In Java, we can pass any argument( primitive / non primitive ) to the method by value only.
Consider code:

package [Link];
public class Program {

private static void swap(int a, int b) {

int temp = a;
a = b;
b = temp;
}
public static void main(String[] args) {
int x = 10;
int y = 20;
[Link]( x, y );
[Link]("X : "+x); //10
[Link]("Y : "+y); //20
 }
}

If we want to simulate pass by reference mechanisam then we should use array in Java.
Consider following code:

public class Program {

private static void swap(int[] arr ) {
int temp = arr[ 0 ];
arr[ 0 ] = arr[ 1 ];
arr[ 1 ] = temp;
}
public static void main(String[] args) {
int x = 10;
int y = 20;
int[] arr = new int[ ] { x, y };

[Link]( arr );
x = arr[ 0 ];
y = arr[ 1 ];

[Link]("X : "+x); //20

[Link]("Y : "+y); //10
}
}
 How to accept record for single variable inside method?

import [Link];
public class Program {
private static Scanner sc = new Scanner([Link]);
public static void acceptRecord( int[] number ) {
[Link]("Enter number : ");
number[ 0 ] = [Link]();
}
private static void printRecord(int[] number) {
[Link]("Number : "+number[ 0 ]);
}
public static void main(String[] args) {
int[] number = new int[ 1 ];
[Link]( number );
[Link]( number );
}
}

Multi dimensional array

Array of array where, size of every array is same/constant.
Reference declaration:

public static void main(String[] args) {

int arr1[ ][ ] = null; //OK

int[ ] arr2[ ] = null; //OK

 int[ ][ ] arr3 = null; //OK
}

Instantiation:

public static void main(String[] args) {

int[ ][ ] arr = new int[ 4 ][ 3 ];
}

How to accept and print record

import [Link];

public class Program {

private static Scanner sc = new Scanner([Link]);

private static void acceptRecord(int[][] arr) {

for (int row = 0; row < [Link]; ++row) {
for (int col = 0; col < arr[row].length; ++col) {
[Link]("Enter number : ");
arr[row][col] = [Link]();
}
}
}

private static void printRecord(int[][] arr) {

for (int row = 0; row < [Link]; ++row) {
 for (int col = 0; col < arr[row].length; ++col) {
[Link](arr[row][col] + " ");
}
[Link]();
}
}
}
public static void main(String[] args) {
int[][] arr = new int[4][3];
[Link](arr);
[Link](arr);
}

How will you initialize multidimensional array

public static void main(String[] args) {

int[][] arr1 = new int[][] { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9
}, { 10, 11, 12 } }; //OK

int[][] arr2 = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 }, { 10, 11,

12 } }; //OK
}
Day 9
Ragged Array
Array of array where column size of every array is different.

Reference declaration:

public static void main(String[] args) {

int arr1[ ][ ] = null;

int[ ] arr2[ ] = null;

int[ ][ ] arr3 = null;

}

Instantiation

public static void main(String[] args) {

int[ ][ ] arr = new int[ 4 ][ ];
arr[ 0 ] = new int[ 3 ];
arr[ 1 ] = new int[ 5 ];
arr[ 2 ] = new int[ 2 ];
arr[ 3 ] = new int[ 4 ];
}
Initialization

public static void main(String[] args) {

int[][] arr = new int[4][];
arr[0] = new int[] { 1, 2, 3 };
arr[1] = new int[] { 4, 5, 6, 7, 8 };
arr[2] = new int[] { 9, 10 };
arr[3] = new int[] { 11, 12, 13, 14 };
}

How to use toString() method?

public static void main(String[] args) {

int[][] arr = new int[4][];
arr[0] = new int[] { 1, 2, 3 };
arr[1] = new int[] { 4, 5, 6, 7, 8 };
arr[2] = new int[] { 9, 10 };
arr[3] = new int[] { 11, 12, 13, 14 };

//[Link]( [Link](arr)); //[[1, 2, 3],

[4, 5, 6, 7, 8], [9, 10], [11, 12, 13, 14]]

//[Link]( [Link]()); //[[I@6d06d69c

/* [Link]( [Link]( arr[ 0 ] ) );

[Link]( [Link]( arr[ 1 ] ) );
[Link]( [Link]( arr[ 2 ] ) );
[Link]( [Link]( arr[ 3 ] ) ); */

for( int index = 0; index < 4; ++ index )

[Link]( [Link]( arr[ index ] ) );
}

How to use foreach loop

public static void main(String[] args) {

int[][] arr = new int[4][];
arr[0] = new int[] { 1, 2, 3 };
arr[1] = new int[] { 4, 5, 6, 7, 8 };
arr[2] = new int[] { 9, 10 };
arr[3] = new int[] { 11, 12, 13, 14 };

for( int[] row : arr ) {

for( int col : row )
[Link]( col+" ");
[Link]();
}
}
How to accept and print record?

import [Link];

public class Program {

private static Scanner sc = new Scanner([Link]);
private static int[][] getArray() {
int[][] arr = new int[4][];
arr[0] = new int[3];
arr[1] = new int[5];
arr[2] = new int[2];
arr[3] = new int[4];
return arr;
}
private static void acceptRecord(int[][] arr) {
if( arr != null ) {
for( int row = 0; row < [Link]; ++ row ) {
for( int col = 0; col < arr[ row ].length; ++ col ) {
[Link]("arr[ "+row+" ][ "+col+" ] : ");
arr[ row ][ col ] = [Link]();
}
}
}
}
private static void printRecord(int[][] arr) {
if( arr != null ) {
for( int row = 0; row < [Link]; ++ row ) {
for( int col = 0; col < arr[ row ].length; ++ col ) {
[Link](arr[ row ][ col ]+" ");
}
[Link]();
}
}
}
public static void main(String[] args) {
int[][] arr = [Link]();
[Link]( arr );
[Link]( arr );
}
}

How will you write hello world w/o giving semicolon

public static void main(String[] args) {

if( [Link]("Hello World" ) != null ) {
}
}
Variable argument / arity method
Consider examples of variable argument method from Java API:
public PrintStream printf(String format, Object... args) -- [Link]
public static String format(String format, Object... args) -- [Link]
public Object invoke(Object obj, Object... args) -- [Link]

public class Program {

private static void sum(int... arguments) {
int result = 0;
for( int element : arguments )
result = result + element;
[Link]("Result : "+result);
}
public static void main(String[] args) {
[Link]( );

[Link]( 10, 20 );

[Link]( 10, 20, 30, 40, 50 );

[Link]( 10, 20, 30, 40, 50, 60, 70 );

[Link]( 10, 20, 30, 40, 50, 60, 70, 80, 90, 100 );
}
}

Enum
If we want to improve readability of the source code then we should use enum in C/C++/java.
Consider code in C programming language:

#include<stdio.h>

int sum( int num1, int num2 ){

return num1 + num2;
}

int sub( int num1, int num2 ){

return num1 - num2;
}

int multiplication( int num1, int num2 ){

return num1 * num2;
}

int division( int num1, int num2 ){

return num1 / num2;
 }
void print_record( int result ){
printf("Result : %d\n",result);
}

enum ArithmeticOperation{
EXIT, SUM, SUB,MULTIPLICATION, DIVISION // Enum Constants
//EXIT = 0, SUM = 1, SUB = 2,MULTIPLICATION = 3, DIVISION = 4 //
Enum Constants
};

enum ArithmeticOperation menu_list( ){

enum ArithmeticOperation choice;
printf("[Link].\n");
printf("[Link].\n");
printf("[Link].\n");
printf("[Link].\n");
printf("[Link].\n");
printf("Enter choice : ");
scanf("%d", &choice);
return choice;
}
int main( void ){
enum ArithmeticOperation choice;
while( ( choice = menu_list( ) ) != EXIT ){
int result = 0;
switch( choice ){
case SUM:
result = sum( 100, 20 );
break;
case SUB:
result = sub( 100, 20 );
break;
case MULTIPLICATION:
result = multiplication( 100, 20 );
break;
case DIVISION:
result = division( 100, 20 );
break;
}
print_record( result);
}
return 0;
}

enum is keyword in java

enum is non primitive type in Java.
Consider example of enum in Java:
 enum Color{
RED, GREEN, BLUE
//RED = 0, GREEN = 1, BLUE = 2
}
//RED, GREEN, BLUE : Name of enum constants
//0,1,2 : Ordinals

We can not change ordinal value of enum constant.

How to give name to the literals in C programming language

enum Day{
MON = 1, TUES = 2, WED = 3, THURS = 4, FRI = 5, SAT = 6, SUN = 7
}

How to give name to the literals in Java programming language

enum Day{
MON( 1 ), TUES( 2 ), WED( 3), THURS ( 4 ), FRI( 5 ), SAT( 6 ),
SUN( 7 );
// 1,2,3,4,5,6,7 : Literals
//MON, TUES, WED, THURS, FRI, SAT, SUN : Name of enum constants
//0,1,2,3,4,5,6 : Ordinals
}

Consider another example of enum in Java:

enum Color{
RED( 255,0,0), GREEN(0,255,0), BLUE(0,0,255)
//RED = 0, GREEN = 1, BLUE = 2
}
//(255,0,0),(0,255,0),(0,0,255)
//RED, GREEN, BLUE : Name of enum constants
//0,1,2 : Ordinals

Consider another example of enum in Java:

enum Day{
MON( 1, "Monday"), SUN( 7, "SunDay");
}
//( 1, "Monday"), ( 7, "SunDay"); //Literals
//MON, SUN : Name of enum constants
//0, 1 : Ordinal values
Using enum, we can give name to the single literal as well group of literals of same type / different
type.
[Link] is considered as super class of all the enums in Core Java language.

Methods of [Link] class

public String toString();
public boolean equals( Object obj );
public native int hashCode( );
protected native Object clone()throws CloneNotSupportedException;
protected void finalize()throws Throwable;
public final native Class<?> getClass();
public final void wait( )throws InterruptedException;
public final native void wait( long timeout )throws InterruptedException;
public final void wait( long timeout, int nanos )throws InterruptedException;
public final void notify();
public final void notifyAll();
Method of [Link] class
public final Class getDeclaringClass()
public final String name()
public final int ordinal()
public static <T extends Enum> T valueOf(Class enumType, String name)
Methods of user defined enum

enum Color{
 }

public static Color[] values(); - It returns array of enum constant.

public static Color valueOf(String name); - It converts string enum constant into Enum
Consider enum code in Java

enum Color{ //[Link]

RED, GREEN, BLUE
}

Let us observe compiler generated code

final class Color extends Enum<Color> {

public static final Color RED; //[Link]
public static final Color GREEN; //[Link]
public static final Color BLUE; //[Link]

public static Color[] values(); //Color[] colors = [Link]()

public static Color valueOf(String); //Color color =
[Link]("GREEN");
}

Since enum is implicitly considered as final class, we can not extend enum. In other words we can not
create sub type of enum.
Consider code to demonstrate name()/ordinal() and values() method.

enum Color{
RED, GREEN, BLUE
}
public class Program {
public static void main(String[] args) {
Color[] colors = [Link]();
for( Color color : colors )
[Link]( [Link]()+" "+[Link]());
}
public static void main4(String[] args) {
Color color = [Link];
[Link]( [Link]()+" "+[Link]());

color = [Link];
[Link]( [Link]()+" "+[Link]());

color = [Link];
[Link]( [Link]()+" "+[Link]());
}
 public static void main3(String[] args) {
[Link]( [Link]()); //BLUE
[Link]( [Link]()); //2
}
public static void main2(String[] args) {
[Link]( [Link]()); //GREEN
[Link]( [Link]()); //1
}
public static void main1(String[] args) {
[Link]( [Link]()); //RED
[Link]( [Link]()); //0
}
}

To assign name to the literals, it is mandatory to define constructor inside enum.

Access modifier of enum constructor can be either package level private or private only.

package [Link];
enum Day {
MON("Monday"), TUES("TuesDay"), WED("WednesDay");

private String dayName;

private Day(String dayName) {

[Link] = dayName;
}
public String getDayName() {
return dayName;
}
}

public class Program {

public static void main(String[] args) {
Day day = [Link];
[Link]([Link]()); //MON
[Link]([Link]()); //0
[Link]([Link]());//Monday
}
}

enum Day {
MON(1), TUES(2), WED(3);

private int dayNumber;

private Day(int dayNumber) {

[Link] = dayNumber;
}
 public int getDayNumber() {
return dayNumber;
}
}

public class Program {

public static void main(String[] args) {
Day day = [Link];
[Link]([Link]()); //MON
[Link]([Link]()); //0
[Link]([Link]());//1
}
}

enum Day {
MON(1, "MonDay"), TUES(2,"TuesDay"), WED(3,"WednesDay");

private int dayNumber;

private String dayName;
private Day(int dayNumber, String dayName) {
[Link] = dayNumber;
[Link] = dayName;
}
public int getDayNumber() {
return dayNumber;
}
public String getDayName() {
return dayName;
}
public String toString() {
return [Link]("%-10s%-5d%-10s%-5d", [Link](),
[Link](), [Link], [Link]);
}
}

public class Program {

public static void main(String[] args) {
Day[] days = [Link]();
for( Day day : days )
[Link]( [Link]() );
}
public static void main1(String[] args) {
Day day = [Link];
[Link]([Link]()); //MON
[Link]([Link]()); //0

[Link]([Link]());//1
[Link]([Link]()); //MonDay

}
}
Menu driven code using enum

package [Link];

import [Link];
import [Link];

enum ArithmeticOperation{
EXIT, SUM, SUB, MULTIPLICATION, DIVISION
}
class ArithmeticOperationTest{
public static int sum( int num1, int num2 ) {
return num1 + num2;
}
public static int sub( int num1, int num2 ) {
return num1 - num2;
}
public static int multiplication( int num1, int num2 ) {
return num1 * num2;
}
public static int division( int num1, int num2 ) {
return num1 / num2;
}
public static void printRecord( int result ) {
[Link]("Result : "+result);
}
private static Scanner sc = new Scanner([Link]);
public static ArithmeticOperation menuList( ) {
[Link]("[Link]");
[Link]("[Link]");
[Link]("[Link]");
 [Link]("[Link]");
[Link]("[Link]");
[Link]("Enter choice : ");
int choice = [Link]();
return [Link]()[ choice ];

/* ArithmeticOperation[] arr = [Link]();

//[EXIT, SUM, SUB, MULTIPLICATION, DIVISION]
return arr[ choice ]; */

}
}
public class Program {
public static void main(String[] args) {
ArithmeticOperation choice;
while( ( choice = [Link]( ) ) !=
[Link] ) {
int result = 0;
switch( choice ) {
case SUM:
result = [Link](100, 20);
break;
case SUB:
result = [Link](100, 20);
break;
case MULTIPLICATION:
result = [Link](100, 20);
break;
case DIVISION:
result = [Link](100, 20);
break;
}
[Link](result);
}
}
}

OOPS
Object oriented programming structure/system
OOPS is not a syntax. It is a programming methodology which is used to solve real world problems
using classes and objects.
Dr Alan kay is inventor of OOPS.
Grady Booch is inventor of UML.
Author of "Object Oriented Analysis and Design with Applications"
According to Grady Booch there should be some major and minor features in the oops.
4 Major Elements / Features / Parts /Pillars
By major, we mean that a language without any one of these elements is not object oriented.
Abstraction - To achive simplicity
 Encapsulation - To hide data and to achieve security
Modularity - To reduce module dependency
Hierarchy - To achieve reusability
Types of hierarchy
Has-a - represents Association( Specialized form => Composition/Aggregation)
Is-a - represents generalization( also called as inheritance )
Use-a - represents dependency
Creates-a - represents instantiation
3 Minor Elements / Features / Parts /Pillars
By minor, we mean that each of these elements is a useful, but not essential.
Typing / Polymorphism - To reduce maintenance of the system
Concurrency - To utilize h/w resources( Memory/CPU ) efficiently
Persistance - To maintain state of the instance of secondary storage.
Abstraction
Abstraction is a major element / pillar of oops.
Process of getting essesntials things from object/instance is called as abstraction.
Abstraction focuses on outer behavior of an instance.

Abstraction in java:

class Program{
public static void main(String[] args) {
 Complex c1 = new Complex( );
[Link]();
[Link]();
}
}

import [Link];
class Program{
public static void main(String[] args) {
Scanner sc = new Scanner( [Link] );
String name = [Link]( );
}
}

interface Printtable{
void print();
}

Creating instance and calling/invoking methods on it represents abstraction in Java.

Encapsulation
Definition
Implementation of abstraction is called as encapsulation.
Binding of data and code together is called as encapsulation

class Complex{
private int real;
private int imag;
public Complex( ){
[Link] = 0;
[Link] = 0;
}
public void acceptRecord( ){
Scanner sc = new Scanner( [Link] );
[Link]("Real Number : ");
[Link] = [Link]();
[Link]("Imag Number : ");
[Link] = [Link]();
}
public void printRecord( ){
[Link]("Real Number : "+[Link]);
[Link]("Imag Number : "+[Link]);
}
}
Class definition represents encapsulation.

Abstraction and encapsulation are complementary concepts: Abstraction focuses on the observable
behavior of an object, whereas encapsulation focuses on the implementation that gives rise to this
behavior.
Day 10
Major and minor elements / pillars /parts of oops
Abstraction
It is a major pillar of oops.
Process of getting essential things from instance / system is called as abstraction.
Abstraction focuses on external behavior of the instance.
Abstraction changes from entity to entity.
Abstraction helps to achive simplicity.
In Java, if we want to achieve abstraction then we should create instance and invoke method on it.
For Example:

class Program{
public static void main(String[] args) {
Complex c1 = new Complex( );
[Link]( );
[Link]( );
}
}

Encapsulation
Definition:
Binding of data and code together is called as encapsulation.
Implementation of abstraction is called as encapsulation.
Abstraction and encapsulation are complementry concepts. In other words abstraction focuses on
external behavior whereas encapsulation focuses internal behavior.
Using encapsulation:
We can achieve abstraction
We can hide data from user:
Process of declararing fields private is called as data hiding. Data hiding is also called as
data encapsulation.
Data hiding helps us to achive data security.
To achive encapsulation we should define class. Hence class is considered as a basic unit of
encapsulation.
For Example:

class Complex{
private int real;
private int imag;
public Complex( ){
[Link] = 0;
[Link] = 0;
}
 public void acceptRecord( ){
//TODO
}
public void printRecord( ){
//TODO
}
}

Modularity
It is a major pillar of oops.
It is the process of developing complex system using small parts.
Modularity helps us to minimize module dependency.
In Java, we can achieve Modularity using packages and .jar file.

Hiearchy
It is a major pillar of oops.
Level / order / ranking of abstraction is called as hierarchy.

Using hierarchy, we can achieve code reusability.

Development time will be reduce
Development cost will be reduce
Developers effoort will reduce
Types of hierarchy
Has-a hierarchy
Also called as part-of hierarchy.
It represents Association.
There are 2 specialized form of association:
Compositon
Aggregation
Is-a hierarchy
It is also called as Kind-of hierarchy.
It represents generalization.
Generalization is also called as inheritance.
Types of Inheritance:
Implementation inheritance
Single level inheritance : ( Allowed in Java )
Multiple inheritance : ( Not Allowed in Java )
Hierarchical level inheritance : ( Allowed in Java )
Multilevel inheritance : ( Allowed in Java )
Interface inheritance
Single level inheritance : ( Allowed in Java )
Multiple inheritance : ( Allowed in Java )
Hierarchical level inheritance : ( Allowed in Java )
Multilevel inheritance : ( Allowed in Java )
 Use-a hierarchy
It represents dependency.
Creates-a hierarchy
It represents instantiation.
Typing
It is a minor pillar of oops.
Typing is also called as Polymorphism.
It comes from the greek roots "poly" (many) and "morphe" (form).
An ability of an instance to take multiple forms is called as Polymorphism.
If we want to reduce maintainence of the systen then we should use Polymorphism.
Types of Polymorphism:
Compile time Polymorphism
We can achieve it using method overloading
Runtime Polymorphism
In Java, it is also called as dynamic method dispatch.
We can achieve it using method overriding.
Concurrency
It is a minor pillar of oops.
It is the process of executing multiple task simultaneously.
Main purpose of concurrency is to utilize h/w resources efficiently.
In Java we achieve concurrency using multithreading.
Persistence
It is a minor pillar of oops.
It is process of maintaining state of instance of secondary storage( HDD / DB ).
In Java, we can achieve Persistence using serialization , JDBC etc.
Persistence helps to achieve reliablity
Association
If has-a relationship is exist between the type then we should use association.
Consider following examples:
Car has-a engine / wheel.
Car has-a music system.
Room has-a wall/window
Room has-a chair
System unit has-a motherboard
System unit has-a modem
Has-a hierarchy is also called as part-of hierarchy.
Consider example of Car and Engine
Car has-a engine
Engine is part of car
When onject/instance is part/component of another object/instance then it is called as association.
Consider following example:

class Engine{
//Fields
//Constructors
//Methods
}
class Car{
//Car has a engine
private Engine e = new Engine(); //Association
}

Car Instance is dependent instance

Engine instance dependency instance
If we declare instane of a class as a field inside another class then it is considered as association.
In Java, association do not represent physical containment. In other words, instance can not be part
of another instance directly. Association is maintained through reference variable.
Composition
Consider example of car and wheel & engine
Car has a wheel

class Wheel{
//TODO
}
class Engine{

}
class Car{
private Wheel[] wheels; //Association --> Composition
private Engine e; //Association --> Composition
}

Car instance is dependent instance

Wheel & Engine instance is dependency instance
In case of association, if dependency instance can not exist without dependent instance then it
reprsents composition.
Composition represents tight coupling.
Aggregation
Consider example of University and Student

class Student{
//TODO
}
class University{
private Stundet[] students; //Association --> Aggregation
//TODO
}

University instance is dependent instance.

Student instance is dependency instance.
In case of association, if dependency instance exist without dependent instance then it represents
aggregation.
Aggregation represents loose coupling.
Inheritance
Consider Person class
 class Person{
private String name;
private int age;
public Person( ) {
this( "", 0); //Constructor chaining
}
public Person( String name, int age ) {
[Link] = name;
[Link] = age;
}
public void showRecord( ) {
[Link]("Name : "+[Link]);
[Link]("Age : "+[Link]);
}
}

public class Program {

public static void main(String[] args) {
//Person p = new Person( );
Person p = new Person( "Sandeep", 39 );
[Link]( );
}
}

Consider Employee class

class Employee{
private String name;
private int age;
private int empid;
private float salary;

public Employee() {
this("",0,0,0.0f);
}

public Employee(String name, int age, int empid, float salary) {

[Link] = name;
[Link] = age;
[Link] = empid;
 [Link] = salary;
}

public void displayRecord( ) {

[Link]("Name : "+[Link]);
[Link]("Age : "+[Link]);
[Link]("Empid : "+[Link]);
[Link]("Salary : "+[Link]);
}
}

public class Program {

public static void main(String[] args) {
//Employee emp = new Employee();
Employee emp = new Employee("Sandeep", 39, 3778, 45000.50f);
[Link]();
}
}

If is a relationship is exist between the types then we should use inheritance.

class Person{ //Parent class / Super class

}
class Employee extends Person{ //Child class / Sub class
//Here Employee class can reuse fields/constructors/methods and
nested types of Person class
}

extends is a keyword which is used to create child class.

In Java, parent class is called as super class and child is called as sub class.
[Link] is super class of all the classes in Java language.

class Person extends Object{

}
class Employee extends Person {

Now class Person is direct super class of class Employee and class Object is indirect super
class of class Employee.
In Java, any class can extend only one class.

class A{ } //OK
class B{ } //OK
class C extends B{ } //OK
class D extends A, B{ } //Not OK

During inheritance, members of sub class do not inherit into super class. Hence using super class
instance, we can access members of super class only.

class Person{ //Super class

String name;
int age;

public void showRecord( ) {

[Link]("Name : "+[Link]);
[Link]("Age : "+[Link]);
}
}

class Employee extends Person{ //Sub class

int empid;
float salary;

public void displayRecord( ) {

[Link]("Empid : "+[Link]);
[Link]("Salary : "+[Link]);
}
}

public class Program {

public static void main(String[] args) {
Person p = new Person();
[Link] = "Sandeep"; //OK
[Link] = 39; //OK
//[Link] = 3778; //Not OK
 //[Link] = 45000.50f; //Not OK
[Link]();
//[Link](); //Not OK

}
}

During inheritance, members of super class inherit into sub class. Hence using sub class instance, we
can access members of super class as well as sub class.

class Person{ //Super class

String name;
int age;

public void showRecord( ) {

[Link]("Name : "+[Link]);
[Link]("Age : "+[Link]);
}
}

class Employee extends Person{ //Sub class

int empid;
float salary;

public void displayRecord( ) {

[Link]("Empid : "+[Link]);
[Link]("Salary : "+[Link]);
}
}

public class Program {

public static void main(String[] args) {
Employee emp = new Employee();
[Link] = "Sandeep";
[Link] = 39; //OK
[Link] = 3778; //OK
[Link] = 45000.45f; //OK
[Link]();
[Link]();
}
}

If we create instance of sub class then all the non static fields declared in super class and sub class
get space inside it. In other words, non static fields of super class inherit into sub class.

Using sub class name, we can use/access static fields of super class. It means that static field of
super class inherit into sub class.
All( static and non static ) the fields of super class inherit into sub class but only non static fields get
space inside instance of sub class.
We can call/invoke, non static method of super class on instance of sub class. In other words, non
static method of super class inherit into sub class.

public static void main(String[] args) {

Employee emp = new Employee();
[Link]();
[Link]();
}

We can invoke, static method of super class on sub class name. In other words, static method of
super class inherit into sub class.
Except constructor, all(static and non static ) the methods of super class inherit into sub class.
If we create instance of sub class then first super class constrcutor gets called and then sub class
constructor gets called.
From any constructor of sub class, by default, super class's parameterless constructor gets called.
If we want to call any constructor of super class from constructor of sub class then we should use
super statement.
super is keyword in java.
super statement must be first statement inside constructor body.

class Person{ //Super class

String name;
int age;
public Person( ) {
[Link] = "";
[Link] = 0;
}
public Person(String name, int age) {
[Link] = name;
[Link] = age;
}
}
class Employee extends Person{ //Sub class
int empid;
float salary;
public Employee( ) {
[Link] = 0;
[Link] = 0.0f;
}
public Employee( String name, int age, int empid, float salary ) {
super( name, age ); //Super statement
 [Link] = empid;
[Link] = salary;
}
}

Except constrcutor, all the members of super class inherit into sub class.
Definition of Inheritance
Journey from generalization to specialization is called inheritance.
Process of acquiring/accessing members of parent class into child class is called as
inheritance.
Interface inheritance:
During inheritance, if super type and sub types are interfaces then it is called as interface
inheritance.

//Single Interface inheritance

interface A{
//TODO
}
interface B extends A{ //Single Interface inheritance : OK
//TODO
}

//Multiple Interface inheritance

interface A{
//TODO
}
interface B{
//TODO
}
interface C extends A, B{ //Multiple Interface inheritance :
OK
//TODO
}

//Hierarchical interface inheritance

interface A{
//TODO
}
interface B extends A{ //Single interface inheritance : OK
//TODO
}
interface C extends A{ //Single Interface inheritance : OK
 //TODO
}

// Multilevel interface inheritance

interface A{
//TODO
}
interface B extends A{ //Single interface inheritance : OK
//TODO
}
interface C extends B{ //Single Interface inheritance : OK
//TODO
}

Implementation inheritance
During inheritance, if super type and sub type is class then it is called as implementation
inheritance.

//Single implementation inheritance

class A{
//TODO
}
class B extends A{ //Single implementation inheritance : OK
//TODO
}

//Multiple implementation inheritance

class A{
//TODO
}
class B{
//TODO
}
class C extends A, B{ //Multiple implementation inheritance :
NOT OK
//TODO
}

//Hierarchical implementation inheritance

class A{
//TODO
}
class B extends A{ //Single Interface inheritance : OK
//TODO
}
class C extends A{ //Single Interface inheritance : OK
//TODO
}

//Multilevel implementation inheritance

class A{
//TODO
}
class B extends A{ //Single Interface inheritance : OK
//TODO
}
class C extends B{ //Single Interface inheritance : OK
//TODO
}
Day 11
Is java support multiple inheritance?
Java supports multiple interface inheritance.

interface A{ }
interface B{ }
interface C extends A, B{ } //OK: Multiple interface inheritance

Java supports multiple interface implementation inheritance

interface A{ }
interface B{ }
class C implements A, B{ } //OK: Multiple interface implementation
inheritance

Java do not support multiple implementation inheritance

class A{ }
class B{ }
class C extends A, B{ } //Not OK: Multiple Implementation inheritance

In C++, combination of two or more than two types of inheritance is called hybrid inheritance.
If we combine hierarchical inheritance and multiple inheritance then it becomes diamond
inheritance, which creates some problems.
To avoid diamond problem, Java do not support multiple implementation inheritance / multiple
class inheritance.
Conclusion: In Java, class can extend only one class.
Consider following code:

class Object{
public String toString( );
public boolean equals( Object obj )
public native int hashCode( );
protected native Object clone( )throws CloneNotSupportedException;
protected void finalize()throws Throwable;
public final native Class<?> getClass( );
public final void wait( )throws InterruptedException;
public final native void wait( long timeOut )throws
InterruptedException;
public final void wait( long timeOut, int nanos )throws
InterruptedException;
public final void notify();
 public final void notifyAll();
}
class Person extends Object{
//TODO
}
class Employee extends Person{
//TODO
}

In above code, class Person will extend [Link] class and class Employee will extend
only Person class( Not [Link] class ).
class Person is direct super class and class [Link] is indirect super class of Employee
class.
Types of inheritance
Single inheritance
In case of inheritance, if single super type is having single sub type then it is called as single
inheritance.
For example: Car is a vehicle.

Syntax:

class Vehicle{
//TODO
}
class Car extends Vehicle{ //Single inheritance( implementation
inheritance )
//TODO
}
 interface Iterable<T>{
//TODO
}
interface Collection<E> extends Iterable<T>{ //Single inheritance(
interface inheritance )
//TODO
}

Multiple inheritance
In case of inheritance, If multiple super types are having single sub type then it is called multiple
inheritance.
For Example: Fax-Copier machine is a fax machine and Fax-Copier machine is also Copier machine.

Syntax:

class FaxMachine{ } //OK

class CopierMachine{ }//OK
class FaxCopierMachine extends FaxMachine, CopierMachine{ } //Not
OK: Multiple Inheritance

interface List<E>{ }
interface Queue<E>{ }
class LinkedList implements List<E>, Queue<E>{ } //OK: Multiple
Inheritance

Hierarchical inheritance
In case of inheritance, If single super type is having multiple sub types then it is called as hierarchical
inheritance.
 For Example: SavingsAccount is Account, CurrentAccount is a Account.

Syntax:

//Hierarchical inheritance
class Account{ }
class SavingsAccount extends Account{ } //Single inheritance
class CurrentAccount extends Account{ } //Single inheritance

interface Collection<E>{ }
interface List<Collection> extends <Collection<E>{ }
interface Queue<E> extends Collection<E>{ }
interface Set<E> extends Collection<E>{ }

Multilevel inheritance
In case of inheritance, if single inheritance is having multiple levels then it is called as multilevel
inheritance.
 For Example: Employee is a Person; Manager is a Employee; Salesanager is a Manager;

Syntax:

//Multilevel inheritance
class Person{ };
class Employee extends Person{ } //Single inheritance
class Manager extends Employee{ } //Single inheritance
class SalesManager extends Manager{ } //Single inheritance

//Multilevel inheritance
interface Iterable<T>{ }
interface Collection<E> extends Iterable<T>{ }
interface Queue<E> extends Collection<E>{ }
interface Deque<E> extends Queue<E>{ }

Syntax to use class and interface

Interfaces: I1, I2, I3
Classes: C1, C2, C3
I2 implements I1 //Not OK
I2 extends I1 //OK: Interface inheritance
I3 extends I1, I2 //OK: Multiple Interface inheritance
I1 extends C1; //Not OK
I1 implements C1; //Not OK
C1 extends I1; //Not OK
C1 implements I1; //OK: Interface implementation inheritance
C1 implements I1,I2; //OK: Multiple Interface implementation inheritance
 C2 extends C1 implements I1,I2; //OK
C2 implements C1; //Not OK
C2 extends C1; // OK: Implementation inheritance
C3 extends C1,C2; // Not OK: Multiple Implementation inheritance
Access modifiers revision
Below table will describe the access modifiers in Java:

Reference: [Link]
Private members( fields/methods/nested types ) inherit into sub class. If we want to access value of
private field inside sub class then we should use getter and setter methods of super class.

class A{
private int num1;
public A( ) {
this.num1 = 10;
}
public int getNum1() {
return this.num1;
}
}
class B extends A{

}
public class Program {
public static void main(String[] args) {
B b = new B();
//[Link](b.num1); //The field A.num1 is not visible
[Link]( b.getNum1() ); //10
}
public static void main1(String[] args) {
A a = new A();
//[Link](a.num1); //The field A.num1 is not visible
[Link]( a.getNum1() );
}
}
Accessing members using super keyword
According, clients requirement, if implementation of super class method is logically incomplete /
partially complete then we should redefine method inside sub class. In other words, we should
override method inside sub class.

public class Person {

private String name;
private int age;
public Person() {
this("",0);
}
public Person(String name, int age) {
[Link] = name;
[Link] = age;
}
public void printRecord( ) {
[Link]("Name : "+[Link]);
[Link]("Age : "+[Link]);
}
}

public class Employee extends Person{

private int empid;
private float salary;
public Employee() {
this("",0,0,0.0f);
}
public Employee( String name, int age, int empid, float salary ) {
super( name, age );
[Link] = empid;
[Link] = salary;
}
public void printRecord() { //overriden method
[Link]("Empid : "+[Link]);
[Link]("Salary : "+[Link]);
}
}
public class Program {
public static void main(String[] args) {
Employee emp = new Employee("Sandeep", 39,3778, 45000.50f);
[Link](); //Due to shadowing, [Link]()
will call //3778, 45000.50f
}
}

If name of super class method and sub class method is same and if we try to invoke such
method on instance of sub class then preference will be given to the sub class method. It is
called as method shadowing.
 If we want to use any member of super class inside method of sub class then we should use super
keyword.

public class Employee extends Person{

private int empid;
private float salary;
public Employee() {
this("",0,0,0.0f);
}
public Employee( String name, int age, int empid, float salary ) {
super( name, age );
[Link] = empid;
[Link] = salary;
}
public void printRecord() { //overriden method
[Link]();
[Link]("Empid : "+[Link]);
[Link]("Salary : "+[Link]);
}
}

According to client's requirement, if implementation of exisiting class is logically incomplete / partially

complete then we should extend that class. In other words we should create sub class of that class i.e
we should use inheritance.
Shadowing
In case of local variable

class Complex{
private int real;
private int imag;
public Complex( ) {
[Link] = 10;
[Link] = 20;
}
public void setReal(int real) {
real = real; //Shadowing : Local variable is assigned to itself
}
public void setImag(int imag) {
[Link] = imag;
}
@Override
public String toString() {
return [Link]+" "+[Link];
}
}
public class Program {
public static void main(String[] args) {
Complex c1 = new Complex( ); //10,20
 [Link](50);
[Link]([Link]()); //10,20
}
}

In case of fields

class A{
int num1 = 10;
int num3 = 30;
}
class B extends A{
int num2 = 20;
int num3 = 40;
public void printRecord( ) {
[Link]("Num1 : "+num1); //OK: 10
[Link]("Num1 : "+this.num1); //OK: 10
[Link]("Num1 : "+super.num1); //OK: 10

[Link]("Num2 : "+num2); //OK: 20

[Link]("Num2 : "+this.num2); //OK: 20

[Link]("Num3 : "+num3); //OK: 40 =>

Shadowing
[Link]("Num3 : "+this.num3); //OK: 40 =>
Shadowing
[Link]("Num3 : "+super.num3); //OK: 30
}
}
public class Program {
public static void main(String[] args) {
B b = new B();
[Link]();
}
}

In case method

class A{
public void showRecord( ) {
[Link]("[Link]()");
}
public void printRecord( ) {
[Link]("[Link]()");
}
}
class B extends A{
public void displayRecord( ) {
[Link]("[Link]()");
 }
public void printRecord( ) {
[Link]("[Link]()");
}
}
public class Program {
public static void main(String[] args) {
B b = new B();
[Link](); //[Link]()
[Link](); //[Link]()
[Link](); //[Link]() => Shadowing
}
}

Upcasting and downcasting

class Person{
String name;
int age;
public Person() {
[Link] = "";
[Link] = 0;
}
public Person(String name, int age) {
[Link] = name;
[Link] = age;
}
public void showRecord( ) {
[Link]("Name : "+[Link]);
[Link]("Age : "+[Link]);
}
}
class Employee extends Person{
int empid;
float salary;
public Employee() {
super();
[Link] = 0;
[Link] = 0.0f;
}
public Employee( String name, int age, int empid, float salary ) {
super( name, age);
[Link] = empid;
[Link] = salary;
}
public void displayRecord( ) {
[Link]();
[Link]("Empid : "+[Link]);
[Link]("Salary : "+[Link]);
}
}
Since members of sub class do not inherit into super class, using super class instance, we can
access members of super class only.

public static void main1(String[] args) {

Person p = new Person();
[Link] = "Sandeep";
[Link] = 39;
//[Link] = 3778; //Not OK
//[Link] = 45000.50f; //Not OK
[Link]();
//[Link](); //Not OK
}

Since members of super class inherit into sub class, using sub class instance we can access
members of super class as well as sub class.

public static void main(String[] args) {

Employee emp = new Employee();
[Link] = "Sandeep";
[Link] = 39;
[Link] = 3778;
[Link] = 45000.50f;
[Link]();
[Link]();
}
Since members( fields, methods, nested type ) of super class inherit into sub class, we can consider
sub class instane as super class instance.
Since sub class instance can be considered as super class instance, we can use it in place of super
class instance.

Person p1 = new Person( ); //OK

Person p2 = p1; //OK

Employee e1 = new Employee(); //OK

Employee e2 = e1; //OK

Employee emp = new Employee();

Person p = (Person)emp; //OK: Upcasting
Person p = emp; //OK: Upcasting

Person p = new Employee(); //OK: Upcasting

 Since members of sub class do not inherit into super class, we can not consider super class instance
as sub class instance.
Since super class instance can not be considered as sub class instance, we can not use it in place of
sub class instance.

Employee e1 = new Employee(); //OK

Employee e2 = e1; //OK

Person p1 = new Person();

Person p2 = p1;

Person p = new Person();

Employee emp = (Employee)p; //Not OK

Employee emp = new Person(); //Not OK

Final conclusion:
Person p = new Person(); //OK
Person p = new Employee(); //OK
Employee emp = new Employee(); //OK
Employee emp = new Person(); //Not OK
Upcasting
 Definition
Process of converting reference of sub class into reference of super class is called as
upcasting.

Employee emp = new Employee(“Sandeep”, 39, 3778, 45000.50);

//Person p = ( Person )emp; //Upcasting: OK
Person p = emp; //Upcasting: OK

Super class reference can contain reference of sub class instance. It is also called as
upcasting.

Person p = new Employee(“Sandeep”, 39, 3778, 45000.50);

If we want to minimize object/instance dependency in the code then we should use upcasting.
Downcasting
Process of converting reference of super class into reference of sub class is called as downcasting.

Person p = new Employee(); //Upcasting

[Link] = “Sandeep”;
[Link] = 39;
Employee emp = (Employee)p; //Downcasting
[Link] = 3778
[Link] = 45000.50f;

In case of upcasting, explicit type casting is optional but in case of dowcasting explicit typecasting is
manadatory.

public static void main(String[] args) {

Person p = null;
Employee emp = (Employee) p; //Downcasting
[Link]( p); //null
[Link](emp); //null
}

public static void main(String[] args) {

Person p = new Employee(); //Upcasting
Employee emp = (Employee) p; //Downcasting: OK
}
 public static void main(String[] args) {
Person p = new Person();
Employee emp = (Employee) p; //Downcasting: ClassCastException
}

If JVM fails to do downcasting then it throws ClassCastException.

Method overriding
If implementation of super class method is logically incomplete then we should redefine/override
method inside sub class.
Process of redefining, method of super class inside sub class is called as method overriding.
In case of upcasting, process of calling method of sub class using reference of super class is called
as dynamic method dispatch.

class Person{
public void printRecord( ){
[Link]("[Link]");
}
}
class Employee extends Person{
public void printRecord( ){
[Link]("[Link]");
}
}
class Program{
public static void main(String[] args) {
Person p = new Employee(); //Upcasting
[Link](); //Dynamic method dispatch
}
}

Note: In case of upcasting we can not access fields and non overriden methods of sub class. If we
want to access it the we should do downcasting.
Rules of method overriding
Below are the rules of method overriding
Access modifier of sub class method should be same or it should be wider.
Return type in sub class method should be same or it should be sub type.
Method name, number of paramaters and type of parameters in sub class method must be
same.
Checked exception list in sub class method should be same or it should be sub set.
Override is annotation declared in [Link] package. It helps developer to override method using
above rules. If we make any mistake then it generates metadata for the compiler to generate error.
 class Person{
public void printRecord( ){
[Link]("[Link]");
}
}
class Employee extends Person{
@Override
public void printRecord( ){
[Link]("[Link]");
}
}
class Program{
public static void main(String[] args) {
Person p = new Employee(); //Upcasting
[Link](); //Dynamic method dispatch
}
}

instanceof operator
ArrayStoreException
operator== versus equals method
Day 12
If we want to reduce object/instance dependency in the code then we should use upcasting.
In case of upcasting, using super class reference variable, we can access :
. Fields of super class( if it is non private )
. Methods of super class
. Overriden method of sub class
In case of upcasting, if we want to access fields of sub class and non overriden method of sub class
then we should do downcasting.
instanceof

instanceof is operator in Java which returns boolean value( true / false )

If we want to check type of instance at runtime then we should use instance of operator. In other
words, we want to check whether super class reference is containing reference of Rectangle instance
of Circle instance then we should use instanceof operator.
Consider example:

public void acceptRecord( ) {

if( [Link] != null ) {
if( [Link] instanceof Rectangle ) {
Rectangle rect = (Rectangle) [Link]; //Downcasting
[Link]("Length : ");
[Link]( [Link]());
[Link]("Breadth : ");
[Link]([Link]());
 //[Link]();
}else {
Circle circle = (Circle) [Link]; //Downcasting
[Link]("Radius : ");
[Link]( [Link]());
//[Link]();
}
[Link](); //Dynamic method dispatch
}
}

process of calling method of sub class on reference of super class is called as dynamic method
dispatch.
Boxing:
Process of converting value of primitive type into non primitive type is called as boxing.
For example:

int number = 10;

String str = [Link]( number ); //Boxing

int number = 10;

Integer i = [Link]( number ); //Boxing

[Link] is super class of all the classes in Java programming language.

Consider following code:

Integer i1 = new Integer( 123 );

Object o1 = new Integer( 123 ); //Upcasting
Object o2 = [Link]( 123 ); //Upcasting

public static void main(String[] args) {

int number = 123;
Object o = number;
// [Link](number); //Auto-Boxing
//Object o = [Link](number); //Upcasting
[Link]( o ); //123
}

If boxing is done implicitly then it is called as auto-boxing.

ArrayStoreException:
 If we try to store incompatible value inside array then JVM throws ArrayStoreException
Consider following code:

public static void main(String[] args) {

/* Object o1 = new String("ABC");
Object o2 = new String("PQR");
Object o3 = new String("XYZ"); */

Object[] arr = new String[ 3 ];

arr[ 0 ] = new String("ABC");
arr[ 1 ] = "PQR";
arr[ 2 ] = new StringBuffer("XYZ"); //ArrayStoreException
[Link]([Link](arr));
}

What is the difference between operator == and equals.

We can not compare state of variable of primitive type using equals method.

public static void main(String[] args) {

int num1 = 10;
int num2 = 10;
if( [Link]( num2 ) ) //NOT OK: Cannot invoke equals(int) on
the primitive type int
[Link]("Equal");
else
[Link]("Not Equal");
}

If we want to compare state/value of variable of primitive type then we should use operator ==.

public static void main(String[] args) {

int num1 = 10;
int num2 = 10;
if( num1 == num2 ) //OK
[Link]("Equal");
else
[Link]("Not Equal");
//Output: Equal
}

We can use operator == with the variable of non primitive type.

public static void main(String[] args) {

Employee emp1 = new Employee("Sandeep", 3778, 45000.50f );
 Employee emp2 = new Employee("Sandeep", 3778, 45000.50f );
if( emp1 == emp2 ) //OK: Comparing state of references
[Link]("Equal");
else
[Link]("Not Equal");
//Not Equal
}

If we want to compare state of references then we should use operator ==.

If we want to compare state of instances then we should use equals method.
equals is non final method of [Link] class.
Syntax:

public boolean equals( Object obj );

If we do not define equals() method inside class then super class's equals method will call.
Consider implementation of equals method from [Link] class:

public boolean equals(Object obj) {

return (this == obj);
}

class Employee{
private String name;
private int empid;
private float salary;
public Employee(String name, int empid, float salary) {
[Link] = name;
[Link] = empid;
[Link] = salary;
}
}
public class Program {
public static void main(String[] args) {
Employee emp1 = new Employee("Sandeep", 3778, 45000.50f );
Employee emp2 = new Employee("Sandeep", 3778, 45000.50f );
if( [Link](emp2) )
[Link]("Equal");
else
[Link]("Not Equal");
//Not Equal
}
public static void main1(String[] args) {
Employee emp1 = new Employee("Sandeep", 3778, 45000.50f );
 Employee emp2 = new Employee("Sandeep", 3778, 45000.50f );
if( emp1 == emp2 ) //OK: Comparing state of references
[Link]("Equal");
else
[Link]("Not Equal");
//Not Equal
}
}

According to clients requirement, If implementation of super class method is logically incomplete

then we should redefine / override method in sub class.

class Employee{
private String name;
private int empid;
private float salary;
public Employee(String name, int empid, float salary) {
[Link] = name;
[Link] = empid;
[Link] = salary;
}
//Employee this = emp1;
//Object obj = emp; //Upcasting
@Override
public boolean equals( Object obj ) {
if( obj != null ) {
Employee other = (Employee) obj; //Downcasting
if( [Link] == [Link] )
return true;
}
return false;
}
}
public class Program {
public static void main(String[] args) {
Employee emp1 = new Employee("Sandeep", 3778, 45000.50f );
Employee emp2 = new Employee("Sandeep", 3778, 45000.50f );
//Employee emp2 = null;
if( [Link](emp2) )
[Link]("Equal");
else
[Link]("Not Equal");
//Equal
}
}
Day 13
Project Lombok
Reference [Link]
External system resources
Following are the operating system resources that we can use for the application development:
Memory
Processor
Input and Output devices
File
Socket
Network Connections
Database connections
Operating System API
In the context of Java, all above resources are non Java resources. These are also called as
unmanaged resources(except memory).
In the context of Java, resource is any external system resource that we can use in the application.
Since operating system resources are limited, we should use it carefully.
Exception Concept
Definition
Exception is an issue / unexpected event / instance which occurs during execution of
application.
Exception is an instance which is used to acknowledge user of the system if any exeption
situation occurs in the code.
If we want to manages OS resources carefully then we should use exception handling in Java.
Throwable class Hierarchy
[Link] is ultimate super class of all the classes in Java language.
Methods of [Link] class:
public String toString( );
public boolean equals( Object obj );
public native int hashCode();
protected native Object clone( )throws CloneNotSupportedException
protected void finalize( )throws Throwable;
public final native Class<?> getClass();
public final void wait( )throws InterruptedException
public final native void wait( long timeOut )throws InterruptedException
public final void wait( long timeOut, int nanos)throws InterruptedException
public final native notify( );
public final native notifyAll( );
[Link]:
The Throwable class is the superclass of all errors and exceptions in the Java language.
Only objects that are instances of Throwable class (or one of its subclasses) are thrown by the Java
Virtual Machine or can be thrown by the Java throw statement.
Consider code in C++

int main( void ){

int num1;
cout<<"Enter number : ";
cin>>num1;

int num2;
cout<<"Enter number : ";
cin>>num2;
try{
if( num2 == 0 ){
//throw 0; //OK
//throw ArithmeticException( "Divide by zero exception");
//OK
throw "Divide by zero exception"; //OK
}else
int result = num1 / num2;
cout<<"Result : "<<result<<endl;
}
}catch( string &ex ){
cout<<ex<<endl;
}
return 0;
}
Consider code in Java

class MyException{
private String message;
public MyException(String message) {
[Link] = message;
}
}
public class Program {
public static void main(String[] args){
int num1 = 10;
int num2 = 0;
try {
if( num2 == 0 )
//throw 0; //No exception of type int can be thrown; an
exception type must be a subclass of Throwable
//throw "/ by 0"; //No exception of type String can be
thrown; an exception type must be a subclass of Throwable
throw new MyException("/ by 0");//No exception of type
MyException can be thrown; an exception type must be a subclass of
Throwable
int result = num1 / num2;
[Link]("Result : "+result);
}catch( Exception ex ) {
//TODO
}
}
}

Consider following code:

public class Program {

public static void main(String[] args){
int num1 = 10;
int num2 = 0;
try {
if( num2 == 0 ) {
ArithmeticException ex = new ArithmeticException("Value of
denominator should not be zero");
throw ex; //OK
}
int result = num1 / num2;
[Link]("Result : "+result);
}catch( Exception ex ) {

}
}
Similarly, only Throwable class or one of its subclasses can be the argument type in a catch clause.
Consider following code:

public class Program {

public static void main(String[] args) {

String str = null;

[Link](10);
int num1 = 10;
int num2 = 0;
try {
int result = num1 / num2;
[Link]("Result : " + result);
} catch (ArithmeticException ex) { //No exception of type
String can be thrown; an exception type must be a subclass of
Throwable

}
}
}

Consider following code:

public class Program {

public static void main(String[] args) {

String str = null;

[Link](10);
int num1 = 10;
int num2 = 0;
try {
int result = num1 / num2;
[Link]("Result : " + result);
} catch (ArithmeticException ex) { //
//TODO
}
}
}

Constructor Summary
public Throwable()

Throwable tw = new Throwable();

public Throwable(String message)

 String message = "error message";
Throwable tw = new Throwable( message );
//or
Throwable tw = new Throwable( "error message" );

public Throwable(Throwable cause)

Throwable cause = new Throwable( "error message" );

Throwable tw = new Throwable( cause );
//or
Throwable tw = new Throwable( new Throwable( "error message" )
);

public Throwable(String message, Throwable cause)

Throwable cause = new Throwable( "error message" );

Throwable tw = new Throwable( "new error message", cause );

protected Throwable(String message, Throwable cause, boolean enableSuppression, boolean

writableStackTrace)

Throwable cause = new Throwable( "error message" );

Throwable tw = new Throwable( "new error message", cause, false,
true );

Method Summary
public String getMessage()
public Throwable initCause(Throwable cause)
public Throwable getCause()
public final void addSuppressed(Throwable exception)
public void printStackTrace()
public void printStackTrace(PrintStream s)
public void printStackTrace(PrintWriter s)
public StackTraceElement[] getStackTrace()
Error versus Exception
Error and Exception are direct sub classes of [Link] class.
Error
 An Error is a subclass of Throwable that indicates serious problems that a reasonable application
should not try to catch.
Most such errors are abnormal conditions.
Runtime error which gets generated due to environmental condition( hardware failure / OS failure /
JVM failure etc ) is considered as error in java programming language.
Consider following code:

public class Program {

public static void main(String[] args) {
try {
int[] arr = new int[ Integer.MAX_VALUE ];
[Link]( [Link](arr));
}catch( OutOfMemoryError error ) {
[Link]([Link]()); //Requested array size
exceeds VM limit
}
}
}

We can write try-catch block to handle errros. But we can not recover from errors hence it is not
recommended to use try catch block for the errors.
Example:
OutOfMemoryError
StackOverflowError
VirtualMachineError
Exception
The class Exception and its subclasses are a form of Throwable that indicates conditions that a
reasonable application might want to catch.
Runtime error which gets generated due to application is considered as exception in java
programming language.
We can use try-catch block to handle exception.
Example:
CloneNotSupportedException
InterrupedException
NumberFormatException
NullPointerExcption
NegativeArraySizeException
ArrayIndexOutOfBoundsException
ArrayStoreException
ClassCastException
ArithmeticException
Checked versus unchecked exception
 Checked exception and unchecked exception are types of exception in Java, which are designed for
Java compiler( Not for JVM ).
Unchecked Exception
[Link] is considered as super class of all the unchecked exception.
[Link] and all its sub classes are considered as unchecked exception.
Examples of unchecked exception
RuntimeException
NumberFormatException
NullPointerExcption
NegativeArraySizeException
ArrayIndexOutOfBoundsException
ArrayStoreException
ClassCastException
ArithmeticException
Compiler do not force developer to handle or to use try-catch block for unchecked exception.
Checked Exception
[Link] is considered as super class of all the checked exception.
[Link] and all its sub classes except [Link](and its sub classes )
are considered as checked exceptions
Examples of checked exception
[Link]
[Link]
[Link]
[Link]
Compiler force developer to handle or to use try-catch block for checked exception.
AutoCloseable and Closeable
Closeable is an interface which is delcared in [Link] package.
Method: void close() throws IOException
It is introduced in JDK 1.5
Consider following code:

import [Link];
import [Link];
import [Link];

class Test implements Closeable{

private Scanner sc;
public Test() {
[Link] = new Scanner([Link]);
}
 @Override
public void close() throws IOException {
[Link]();
}

}
public class Program {
public static void main(String[] args) {
try {
Test t = new Test();

[Link]();
} catch (IOException e) {
// TODO Auto-generated catch block
[Link]();
}
}
}

"void close() throws IOException" is a method of [Link] interface which is used to

clean/release resources.
If any class implements Closeable interface then that class has a ability to close resources using
close method.
AutoCloseable is an interface which is declared in [Link] package.
Method: void close()throws Exception
It is introduced in JDK 1.7
AutoCloseable is same as Closeable with gurantee of calling close method automatically.

//Class Test => Resource Type

class Test implements AutoCloseable{
private sc;
public Test() {
[Link] = new Scanner([Link]);
}

@Override
public void close() throws Exception {
[Link]();
}

}
public class Program {
public static void main(String[] args) {
try {
Test t = new Test(); //new Test() => Resource
 [Link]();
} catch (Exception e) {
// TODO Auto-generated catch block
[Link]();
}
}

Any class which implements AutoCloseable / Closeable interface is called as resource type and its
instance is called resource.
If we use try with resource then close() method gets called automatically.
Exception handling using try catch throw throws and finally
If we want to handle exception then we should use 5 keywords in java:
try
catch
throw
throws
finally
While performing arithmetic operation, if we get any exception condition like "divide by zero" then
JVM throws ArithmeticException.
try
It is a keyword in Java.
If we want to keep watch on single statement or group of statements for exception then we should
use try block / handler.
we can not define try block after catch/finally block.
Try block must have at least one catch block or finally block or resource statement.
Consider following syntax:

public static void main(String[] args) {

try{
//TODO
}catch( Exception ex ){
//TODO
}
}

public static void main(String[] args) {

try{
//TODO
}finally{
//TODO
}
}
 public static void main(String[] args) {
try(Scanner sc = new Scanner()){ //try-with-resource
//TODO
}
}

throw
It is a keyword in java.
If we want to generate new exception then we should use throw keyword.
Only objects that are instances of Throwable class (or one of its subclasses) are thrown by the JVM
or can be thrown by the Java throw statement.

String ex = new String("Divide by zero exception");

throw ex;//No exception of type String can be thrown; an exception
type must be a subclass of Throwable

throw statement is a jump statement.

catch
It is a keyword in Java.
To handle exception, we should use catch block / handler.
We can not define catch block before try and after finally block.
Catch block can handle exception thrown from try block only.
For single try block, we can provide multiple catch block. In this case, JVM can execute only one
catch depending on the situation.
In a single catch block, we can handle multiple specific exception.

catch ( ArithmeticException | InputMismatchException ex ) {

//Multi catch block
[Link]();
}

Do not Repeat Yourself( DRY ).

If we want to handle multple execptions of super and sub types then first we must handle sub types
exception.
 public static void main(String[] args) {
Scanner sc = null;
try {
[Link]("Opening resource");
sc = new Scanner([Link]);

[Link]("Num1 : ");
int num1 = [Link]();

[Link]("Num2 : ");
int num2 = [Link]();

if( num2 == 0 )
throw new ArithmeticException("Divide by zero exception");
int result = num1 / num2;
[Link]("Result : "+result);
}catch ( ArithmeticException ex) {
[Link]();
}catch ( RuntimeException ex) {
[Link]();
}catch ( Exception ex) {
[Link]();
}
}
 Using [Link] class we can define catch block which can handle any checked as well as
uncheked exception.

try{
//TODO
}catch( Exception ex ){ //Generic catch block
[Link]();
}

Generally, generic catch block comes after all specific catch blocks.
finally
It is a keyword in Java.
If we want to close or release local resources then we should use finally block.
For given try block we can provide only one finally block.
We can define block after all try and catch blocks.
JVM always execute finally block.
try with resource
public static void main(String[] args) {
//try ( Program p = new Program()) { //Not Ok: The resource
type Program does not implement [Link]
try( Scanner sc = new Scanner([Link])){
[Link]("Num1 : ");
int num1 = [Link]();

[Link]("Num2 : ");
int num2 = [Link]();

if( num2 == 0 )
throw new ArithmeticException("Divide by zero exception");
int result = num1 / num2;
[Link]("Result : "+result);

}catch ( Exception ex) {

[Link]();
}
}

throws
It is a keyword in Java
If we want delegate exception from method to the caller method then we should use throws
keyword/clause.
 public class Program {
public static void displayRecord( ) throws InterruptedException {
for( int count = 1; count <= 10; ++ count ) {
[Link]("Count : "+count);
[Link](500);
}
}
public static void main(String[] args) {
try {
[Link]();
} catch (InterruptedException e) {
[Link]();
}
}
}

Custom exception and its need.

JVM do not understand exceptional conditions in the business logic. To handle it we should define
user defined / custom exception class.
How to define custom unchecked exception class?

class StackOverflowException extends RuntimeException{

//TODO
}

How to define custom checked exception class?

class StackOverflowException extends Exception{

//TODO
}

Exception chaining
Process of handling exception by throwing new type of exception is called as exception chaining.
Consider following code:

package [Link];
abstract class A{
public abstract void print( );
}
class B extends A{
@Override
public void print() throws RuntimeException{
try {
for( int count = 1; count <= 10; ++ count ) {
[Link]("Count : "+count);
[Link](250);
}
} catch (InterruptedException cause) {
throw new RuntimeException(cause); //Exception Chaining
}
}
}
public class Program {
public static void main(String[] args) {
try {
A a = new B();
[Link]();//Dynamic method dispatch
} catch (RuntimeException e) {
//[Link]();
Throwable cause = [Link]();
[Link](cause);
}
}
}
Day 14
class A extends Exception{ }
class B extends Exception{ }
class C extends Exception{ }
public class Program {
//public static void print( int number ) throws A, B, C {
public static void print( int number ) throws Exception {
if( number == 10 )
throw new A();
if( number == 20 )
throw new B();
if( number == 30 )
throw new C();
[Link]("Number : "+number);
}
public static void main(String[] args) {
try {
[Link](50);
} catch (Exception e) {
[Link]();
}
}
}

We can not override static method inside sub class:

class Super{
public static void showRecord( ) {
[Link]("[Link]()");
}
}
class Sub extends Super{
@Override
public static void showRecord( ) { //Compiler Error
[Link]("[Link]()");
}
}

Non static methods are by default virtual in Java.

In Java virtual methods are designed to call on object reference.
Static methods are designed to call on class name. Since static methods are not designed to call on
object reference it is not virtual by default. Hence we can not override static method inside sub class.
 class Super{
public static void showRecord( ) {
[Link]("[Link]()");
}
}
class Sub extends Super{
public static void showRecord( ) {
[Link]("[Link]()");
}
}
public class Program {
public static void main(String[] args) {
[Link](); //[Link]()
[Link](); //[Link]() //Due to method shadowing
/ method hiding
}
}

class Super{
public void printRecord( ) {
[Link]("[Link]()");
}
}
class Sub extends Super{
@Override
public void printRecord( ) { //Overrided method
[Link]("[Link]()");
}
}
public class Program {
public static void main(String[] args) {
//Super s1 = new Super();
//[Link]();

Sub s2 = new Sub();

[Link](); //[Link]() //Due to method shadowing
/ method hiding
}
}

Rules of method overriding

Access modifer in sub class method should be same or it should be wider.
Return type of sub class method should covariant. It means that, return type in sub class method
should be same or it should be sub type.
Method name, number of paramters and type of parameters inside sub class method must be same.
Checked exception list in sub class method should be same or it should be sub set.
Following methods we can not override / redefine inside sub class
private method
static method
constructor
final method
Final method final class
According business requirement, if implementation of super class method is logically incomplete then
we should override method inside sub class.
According business requirement, if implementation of super class method is logically 100% complete
then we should declare super class method final.
final is modifier in Java.
We can not redefine final method inside sub class. In other words, we can not override final method
inside sub class.
Final method inherit into sub class. Hence we can use it inside sub class.
Examples of final method:
public final int ordinal();
public final String name();
public final Class<?> getClass();
public final void wait( )throws InterruptedExcption
public final native void wait( long timeOut )throws InterruptedExcption
public final void wait( long timeOut, int nanos )throws InterruptedExcption
public final void notify();
public final void notifyAll();
We can declare overriden method final.

class A{
public void f2( ) {
[Link]("A.f2");
}
public final void f3() {
[Link]("A.f3");
}
}
class B extends A{
@Override
public final void f2() {
[Link]("B.f2");
}
}
public class Program {
public static void main(String[] args) {
B b = new B();
b.f2();
}
}
 According business requirement, if implementation of class is logically 100% complete then we
should declare such class final.
We can not extend final class. In other words, we can not create sub class of final class.
Examples of final class:
[Link]
[Link]
[Link]
[Link]
All the wrapper classes
[Link]
[Link]
Abstract method an abstract class
According business requirement, if implementation of super class method is logically 100%
incomplete then we should declare super class method abstract.
abstract is modifier in java.
We can not provide body to the abstract method.
If we declare method abstract then we must declare class abstract.
We can not instantiate abstract class. In other words, we can not create instance of abstract class but
we can create reference of abstract class.
Abstract class may/may not contain abstract method.
If super class contains abstract method then sub class must override it otherwise sub class will be
considered as abstract.
Consider following code:

abstract class A{
public abstract void f1( );
}
class B extends A{
@Override
public void f1() {
//TODO
}
}

Consider following code:

abstract class A{
public abstract void f1( );
}
abstract class B extends A{
 }

Examples of abstract class:

[Link]
[Link]
[Link]
[Link]
Examples of abstract methods:
public abstract int intValue();
public abstract float floatValue()
public abstract double doubleValue()
public abstract long longValue()
Without declaraing method abstract, we can can declare class abstract.

abstract class A{
public abstract void f1( );
public abstract void f2( );
public abstract void f3( );
}
abstract class B extends A{
@Override
public void f1() { }
@Override
public void f2() { }
@Override
public void f3() { }
}
class C extends B {
@Override
public void f1() {
[Link]("C.f1");
}
}
class D extends B {
@Override
public void f2() {
[Link]("D.f2");
}
}
class E extends B{
@Override
public void f3() {
[Link]("E.f3");
}
}
public class Program {
 public static void main(String[] args) {
A a = null;

a = new C();
a.f1();

a = new D();
a.f2();

a = new E();
a.f3();
}
}

Sole constructor
A constructor of super class which is designed to call from constructor of only sub class is called sole
constructor.

abstract class A{
private int num1;
private int num2;
public A( int num1, int num2) { //Sole Constructor
this.num1 = num1;
this.num2 = num2;
}
public void printRecord( ) {
[Link]("Num1 : "+this.num1);
[Link]("Num2 : "+this.num2);
}
}
class B extends A{
private int num3;
public B( int num1, int num2, int num3 ) {
super( num1, num2 );
this.num3 = num3;
}
@Override
public void printRecord() {
[Link]();
[Link]("Num3 : "+this.num3);
}
}
public class Program {
public static void main(String[] args) {

B b = new B( 10, 20, 30 );

[Link]();
}
}
Wrapper class hierarchy
Boxing & auto-boxing
Unboxing & auto-unboxing
Generic programming
Day 15
Wrapper class

Primtive Types in Java

boolean, byte, char, short, int, float, double, long.
In Java, primitive types are not classes. If we want to process values of primitive type then we can use
corresponding class. It is called wrapper class.
All the wrapper classes are final and declared in [Link] package.
All the wrapper classes implments [Link] and [Link] interface.
Any Wrapper class do not contain parameterless constructor
Super class reference variable can contain refrence of instance of sub class. It is called as upcasting.

Object o1 = new Boolean( true ); //OK: Upcasting

Object o2 = new Character( 'A' ); //OK: Upcasting
Object o3 = new Byte( 123 ); //OK: Upcasting
Number n1 = new Byte( 123 ); //OK: Upcasting
Byte b1 = new Byte( 123 ); //OK
Object o4 = new Short( 9999 ); //OK: Upcasting
Number n2 = new Short(9999 ); //OK: Upcasting
Object o5 = new Integer( 123456 ); //OK: Upcasting
Number n3 = new Integer( 123456 ); //OK: Upcasting
Object o6 = new Long(123456789 ); //OK: Upcasting
Number n4 = new Long(123456789); //OK: Upcasting
Object o7 = new Float(3.14f); //OK: Upcasting
Number n5 = new Float(3.14f); //OK: Upcasting
Object o8 = new Double(3.142d); //OK: Upcasting
Number n6 = new Double(3.142d); //OK: Upcasting

Consider example of integer

 int n1 = new int( 10 ); //Not OK
Integer n1 = new Integer( 10 ); //OK
Number n2 = new Integer( 10 ); //OK: Upcasting
Object n3 = new Integer( 10 ); //OK: Upcasting

Boxing and Auto-Boxing

Consider following example:

int number = 123;

Integer i1 = new Integer( number ); //Boxing

int number = 123;

Integer i2 = [Link]( number ); //Boxing

int number = 123;

String s1 = [Link]( number ); //Boxing

int number = 123;

String s2 = [Link]( number );

Process of converting value of variable of primitive type into non primitive type is called as boxing.

Consider following example:

 public static void main(String[] args) {
int number = 123;
Object obj = number; //Auto-Boxing
//Integer i = [Link](number) //Boxing
//Object o = i; //Upcasting
[Link]( obj );
}

If boxing is done implicitly then it is called auto-boxing.

UnBoxing and Auto-Unboxing

Consider following example:

//Integer i = new Integer( "123" );

Integer i = new Integer( 123 );
int number = [Link]( ); //UnBoxing

String str = "456";

int number = [Link]( str ); //UnBoxing
 Process of converting state of non primitive type into primitive type is called as unboxing.

If unboxing is done implicitly then it is called as auto-unboxing.

public static void main(String[] args) {

Integer i = new Integer(123);
int number = i; //Auto-Unboxing
//int number = [Link]();
[Link]("Number : "+number);
}

Upcasting and downcasting

Upcasting definition
We can convert reference of sub class into reference of super class. It is called as upcasting.
 Employee emp = new Employee();
//Person p = (Person)emp; //OK: Upcasting
Person p = emp; //OK: Upcasting

We can directly store reference of sub class instance into super class reference variable. It is
called as upcasting.

Person p = new Employee(); //Upcasting

If we want to reduce object/instance dependency in the code then we should use upcasting.
In case of upcasting, using super class reference variable we can access:
non private fields of super class.
non private methods of super class.
overriden methods of sub class.
Downcasting definition
We can convert reference super class into reference of sub class. It is called as downcasting.

Person p = new Employee( ); //Upcasting

Employee emp = (Employee)p; //Downcasting

If JVM failed to do downcasting then it throws ClassCastException.

Employee e = new Person(); //Compile time checking => Compiler

Error

Person p = new Person( );

Employee emp = (Employee)p; //Downcasting: ClassCastException

In case of upcasting, using super class reference variable, we can not access non private fields and
non overriden methods of sub class. If we want to access it then we should do downcasting.
Consider following code:

class A{
public void print( ){
[Link]("[Link]");
}
public void display( ){
[Link]("[Link]");
}
}
class B extends A{
@Override
public void print( ){
[Link]("[Link]");
}
public void show( ){
[Link]("[Link]");
}
}

class Program{
public static void main( String[] args ){
A a1 = new A(); //OK
[Link](); //[Link]

B b1 = new B( ); //OK
[Link](); //[Link] => Due to shadowing preference will be given
to [Link]

A a2 = new B(); //OK: Upcasting

[Link]( ); //[Link]
 [Link]( );//[Link]
[Link]( ); //Compiler error

B b2 = new A(); //Compiler error

[Link]( );
}
}

Generic Programming
Let us define stack to store boolean elements

class Stack{
private int top = -1;
private boolean[] arr;
public Stack( ) {
this( 5 );
}
public Stack( int size ) {
[Link] = new boolean[ size ];
}
public boolean empty( ) {
return [Link] == -1;
}
public boolean full( ) {
return [Link] == [Link] - 1;
}
public void push( boolean element ) throws StackOverflowException
{
if( [Link]())
throw new StackOverflowException("Stack is full");
[Link] = [Link] + 1;
[Link][ [Link] ] = element;
}
public boolean peek( ) throws StackUnderflowException {
if( [Link]())
throw new StackUnderflowException("Stack is empty");
return [Link][ [Link] ];
}
public void pop( ) throws StackUnderflowException {
if( [Link]())
throw new StackUnderflowException("Stack is empty");
[Link] = [Link] - 1;
}
}

Let us define stack to store integer elements

 class Stack{
private int top = -1;
private int[] arr;
public Stack( ) {
this( 5 );
}
public Stack( int size ) {
[Link] = new int[ size ];
}
public boolean empty( ) {
return [Link] == -1;
}
public boolean full( ) {
return [Link] == [Link] - 1;
}
public void push( int element ) throws StackOverflowException {
if( [Link]())
throw new StackOverflowException("Stack is full");
[Link] = [Link] + 1;
[Link][ [Link] ] = element;
}
public int peek( ) throws StackUnderflowException {
if( [Link]())
throw new StackUnderflowException("Stack is empty");
return [Link][ [Link] ];
}
public void pop( ) throws StackUnderflowException {
if( [Link]())
throw new StackUnderflowException("Stack is empty");
[Link] = [Link] - 1;
}
}

Let us define stack to store double elements

class Stack{
private int top = -1;
private double[] arr;
public Stack( ) {
this( 5 );
}
public Stack( int size ) {
[Link] = new double[ size ];
}
public boolean empty( ) {
return [Link] == -1;
}
public boolean full( ) {
return [Link] == [Link] - 1;
}
public void push( double element ) throws StackOverflowException {
 if( [Link]())
throw new StackOverflowException("Stack is full");
[Link] = [Link] + 1;
[Link][ [Link] ] = element;
}
public double peek( ) throws StackUnderflowException {
if( [Link]())
throw new StackUnderflowException("Stack is empty");
return [Link][ [Link] ];
}
public void pop( ) throws StackUnderflowException {
if( [Link]())
throw new StackUnderflowException("Stack is empty");
[Link] = [Link] - 1;
}
}

If we want to reduce developers effort then we should do generic programming.

In Java, we can write generic code using:
. [Link] class
. Generics
Generic programming using [Link] class
We can use [Link] class to store value of primitive as well as non-primitive. Hence to write
generic code we use [Link] class.

int number = 123;

Object obj = number; //OK
/*
Integer i = [Link]( number ); //Boxing
Object obj = i; //Upcasting
*/

Object obj = new Date(); //OK

Consider following code:

class Box{
private Object reference;
public Object getReference() {
return reference;
}
public void setReference(Object reference) {
[Link] = reference;
 }
}
 Using [Link] class, we can write generic code but we can not write type-safe generic code.

public static void main(String[] args) {

Box b1 = new Box( );
[Link](new Date());
//Date date = (Date) [Link](); //Downcasting
String str = (String) [Link](); //Downcasting:
ClassCastException
}

If we want to write type-safe generic code then we should use generics.

Generics
Generics is a Java language feature which helps developer to write generic code by passing data
type as a agrument.
Consider generic code using Generics:

//Now class Box is called as parameterized type

class Box<T>{ // Here T is Type parameter
private T reference;
public T getReference() {
return reference;
}
public void setReference(T reference) {
[Link] = reference;
}
}
public class Program {
public static void main(String[] args) {

Box<Date> b1 = new Box<Date>( ); //Here Date is called as Type

 argument

[Link](new Date());

Date date = [Link]();

[Link](date);
}
}

Why Generics
Generics gives us stronger typechecking at compile time. In other words, using generics we can write
type-safe generic code.
It completly eliminates need of explict typecasting.
It helps developer to define generic algorithms and data structures.
Generics Syntax:
We can specify type argument during declaration of reference as well as instantiation.

Box<Date> b1 = new Box<Date>( ); //OK

If we specify type argument during reference declaration then specifying type argument during
instantiation is optional. It is called as type inference.

Box<Date> b1 = new Box<>( ); //OK

We must specify type argument during declaration of reference.

Box<> b1 = new Box<Date>( ); //Not OK

We can not use inheritance for type argument.

Box<Object> b1 = new Box< Date>( ); //Not OK

List<Date> list = new ArrayList<Date>( ); //OK

Box<Date> b1 = new Box< Object>( ); //Not OK

If we use parameterized type without type argument then it is called as raw type.
 Box b = new Box(); //OK: Here Box is called as raw type
//Box<Object> b1 = new Box< Object>( );

During instantiation of parameterized type, type argument must be non primitive type.

Box<int> b1 = new Box<>( ); //Not OK: type argument int is not

allowed

If we want to store primitive values inside instance of parameterized type then type argument must
be Wrapper class.

Box<Integer> b1 = new Box<>( ); //OK

Commonly used type parameter names in Java

T : Type
N : Number
K : Key
V : Value
E : Element
S, U, R : Second type parameter names
We can specify multiple type arguments

interface Map<K, V>{

K getKey( );
V getvalue( );
}
class HashMap<K,V> implements Map<K,V>{
private K key;
private V value;
public HashMap( K key, V value ) {
[Link] = key;
[Link] = value;
}
@Override
public K getKey() {
return [Link];
}
@Override
public V getvalue() {
return [Link];
}
}
 public class Program {
public static void main(String[] args) {
Map<Integer, String> map = new HashMap<>(1, "DAC");
Integer key = [Link]();
String value = [Link]();
[Link](key+" "+value);
}
}

Bounded Type Parameter

If we want to put restriction on data type which is used as type argument then we should specify
bounded type parameter.

class Box<T extends Number>{ //Now T is bounded Type parameter

private T reference;
public T getReference() {
return reference;
}
public void setReference(T reference) {
[Link] = reference;
}
}
public class Program {
public static void main(String[] args) {
//Box<Boolean> b1 = new Box<>( ); //Not OK
//Box<Character> b2 = new Box<>( ); //Not OK
Box<Number> b3 = new Box<>( ); //OK
Box<Integer> b4 = new Box<>( ); //OK
Box<Double> b5 = new Box<>( ); //OK
//Box<String> b6 = new Box<>( ); //Not OK
//Box<Date> b7 = new Box<>( ); //Not OK
}
}

ArrayList demo

import [Link];

public class Program {

public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<>();
[Link](10); //[Link]([Link](10));
[Link](20); //[Link]([Link](20));
[Link](30); //[Link]([Link](30));

for( Integer element : list )

[Link](element);
 }
}

Wild Card
In Generics ? is called as wild card which represents unknown type.
Types of wild card
Unbouned wild card
Upper Bouned wild card
Lower Bounded wild card.
Consider following code

public static ArrayList<Integer> getIntegerArrayList( ) {

ArrayList<Integer> list = new ArrayList<>();
[Link](10);
[Link](20);
[Link](30);
return list;
}
public static ArrayList<Double> getDoubleArrayList( ) {
ArrayList<Double> list = new ArrayList<>();
[Link](10.1);
[Link](20.2);
[Link](30.3);
return list;
}
public static ArrayList<String> getStringArrayList( ) {
ArrayList<String> list = new ArrayList<>();
[Link]("DAC");
[Link]("DMC");
[Link]("DESD");
return list;
}

Unbouned wild card

private static void printRecord(ArrayList<?> list) {

for (Object element : list)
[Link](element);
}

In above code, list will contain reference of ArrayList which can contain any type of element.
 public static void main(String[] args) {
ArrayList<Integer> integerList = [Link]();
[Link]( integerList );

ArrayList<Double> doubleList = [Link]();

[Link](doubleList);

ArrayList<String> stringList = [Link]();

[Link](stringList );
}

Upper Bouned wild card

private static void printRecord(ArrayList<? extends Number> list) {

for (Object element : list)
[Link](element);
}

In the above code, list will contain reference of ArrayList which can containf Number and its sub type
of elements

public static void main(String[] args) {

ArrayList<Integer> integerList = [Link]();
[Link]( integerList ); //OK

ArrayList<Double> doubleList = [Link]();

[Link](doubleList); //OK

ArrayList<String> stringList = [Link]();

[Link](stringList ); //Not OK
}

Lower Bounded wild card

private static void printRecord(ArrayList<? super Integer> list) {

for (Object element : list)
[Link](element);
}

In above code, list will contain reference of ArrayList which can contain Integer and its super type of
elements.
 public static void main(String[] args) {
ArrayList<Integer> integerList = [Link]();
[Link]( integerList ); //OK

ArrayList<Double> doubleList = [Link]();

//[Link](doubleList); //NOT OK

ArrayList<String> stringList = [Link]();

//[Link](stringList ); //Not OK
}

Restrictions on Generics
Reference: [Link]
Day 16
Synthetic Constructs in Java
Reference: [Link]
Generic Method
We can define generic method using [Link] class.

public class Program {

public static void print( Object object) {
[Link]( object );
}
public static void main(String[] args) {
[Link]( true );
[Link]( 123 );
[Link]( 'A' );
[Link]( 1234567 );
[Link]( 3.142f );
[Link]( 123.4567d );
[Link]( "Good Morning!!" );
[Link]( new Date() );
}
}

Generic method using generics

public class Program {

public static <T> void print( T value) {
[Link]( value );
}
public static void main(String[] args) {
[Link]( true );
[Link]( 123 );
[Link]( 'A' );
[Link]( 1234567 );
[Link]( 3.142f );
[Link]( 123.4567d );
[Link]( "Good Morning!!" );
[Link]( new Date() );
}
}

We can specify bounded type parameter for method:

 public class Program {
public static <T extends Number> void print( T value) {
[Link]( value );
}
public static void main(String[] args) {
//[Link]( true ); //Not OK
[Link]( 123 );
//[Link]( 'A' );//Not OK
[Link]( 1234567 );
[Link]( 3.142f );
[Link]( 123.4567d );
//[Link]( "Good Morning!!" );//Not OK
//[Link]( new Date() );//Not OK
}
}

Type Erasure
Consider generic type without upper bound.

class Box<T>{
private T data;

public Box() {
}
public Box(T data) {
[Link] = data;
}
public T getData() {
return data;
}
public void setData(T data) {
[Link] = data;
}
@Override
public String toString() {
return [Link]();
}
}

Below is the code with type erasure.

class Box{
private Object data;

public Box() {
}
public Box(Object data) {
 [Link] = data;
}
public Object getData() {
return data;
}
public void setData(Object data) {
[Link] = data;
}
@Override
public String toString() {
return [Link]();
}
}

Consider generic type with upper bound( Number).

class Box<T extends Number>{

private T data;

public Box() {
}
public Box(T data) {
[Link] = data;
}
public T getData() {
return data;
}
public void setData(T data) {
[Link] = data;
}
@Override
public String toString() {
return [Link]();
}
}

Below is the code with type erasure.

class Box{
private Number data;

public Box() {
}
public Box(Number data) {
[Link] = data;
}
public Number getData() {
return data;
}
 public void setData(Number data) {
[Link] = data;
}
@Override
public String toString() {
return [Link]();
}
}

Bridge method
Consider following code:

class Box<T>{
private T data;

public Box() {
}
public Box(T data) {
[Link] = data;
}
public void setData(T data) {
[Link] = data;
}
@Override
public String toString() {
return [Link]();
}
}
class Sample extends Box<Integer>{

public Sample() {
super();
}
public Sample(Integer data) {
super(data);
}
/*
//Method added by compiler to achive dynamic method dispatch
public void setData(Object data) { //Bridge method
[Link]((Integer)data);
} */
@Override
public void setData(Integer data) {
[Link](data);
}
}
 public static void main3(String[] args) {
Sample s = new Sample();
Box b = s; //Upcasting
[Link](123); //OK
[Link]([Link]()); //123
}

public static void main(String[] args) {

Sample s = new Sample();
Box b = s; //Upcasting
[Link]( "Hello" ); //ClassCastException
[Link]([Link]());
}

Restrictions on Generics
Cannot Instantiate Generic Types with Primitive Types

Stack<int> s1 = new Stack<>(); //Not OK

Stack<Integer> s1 = new Stack<>(); //OK

Cannot Declare Static Fields Whose Types are Type Parameters

class Box<T>{
private static T data; //Not OK
//TODO: Getter and Setter
}

Cannot Use Casts or instanceof with Parameterized Types

public static void printRecord( List<String> list ){

if( list instanceof ArrayList<String> ){ //Not OK
ArrayList<String> arrayList = ( ArrayList<String> ) list; //OK
}
}
public static void main( String[] args ){
ArrayList<String> arrayList = new ArrayList<>( );
[Link]( "DAC" );
[Link]( "DMC" );
[Link]( "DESD" );
[Link]( arrayList );

LinkedList<String> linkedList = new LinkedList<>( );

[Link]( "RED" );
 [Link]( "GREEN" );
[Link]( "BLUE" );
[Link]( linkedList );
}

Cannot Create Arrays of Parameterized Types

Box<Integer> box = new Box<>(); //OK

Box<Integer>[ ] arr = new Box<>[ 5 ]; //Not OK

Cannot Create, Catch, or Throw Objects of Parameterized Types

class QueueFullException<T> extends Throwable // compile-time error

{ /* ... */ }

class MathException<T> extends Exception // compile-time error

{ /* ... */ }

public static <T extends Exception, J> void execute(List<J> jobs) {

try {
for (J job : jobs)
// ...
} catch (T e) { // compile-time error
// ...
}

A class cannot have two overloaded methods that will have the same signature after type erasure.

public class Example {

public void print(Set<String> strSet) { }
public void print(Set<Integer> intSet) { }
}

Why main method is static?

JVM is responsible for calling main method.
Consider following scenarios if main method is non static:
If class is abstract.
 abstract class Program{
public void main( String[] args ){
//TODO
}
}

If class is concrete but constructor is private:

class Program{
private Program( ){
//TODO
}
public void main( String[] args ){
//TODO
}
}

If class is concrete and class contains only public parameterized constructor

class Program{
public Program( String s1, int i1, float f1, double d1 ){
//TODO
}
public void main( String[] args ){
//TODO
}
}

To overcome above problems, main method is declared as static.

Fragile Base class problem
If we make changes in the body super class then we must recompile super class as well as all its sub
classes. This problem is called as fragile base class problem.
We can solve fragile base class problem by defining super type as interface.
Abstraction using interface
Set of rules are called as specification/standard.
If we want to define specifications for sub classes in java then we should define interface.
Interface is contract between service provider and service consumer
Advantage of interface:
To build trust between service provider and service consumer.
It helps to achive abstraction
It help to minimize service provider dependency
Non primitive types in Java:
interface
class
enum
array
interface is a keyword in java
In Java, interface can contain:
Nested type
Field
Abstract method
Default method
Static interface method
interface fields are implicitly considered as public static and final

interface Printable{
//int value; //Error: The blank final field value may not have been
initialized
int value = 123;
//public static final int value = 123;
}

interface methods are implicitly considered as public and abstract.

interface Printable{
//void print( ) { } //Error: Abstract methods do not specify a
body
void print( );
//public abstract void print( );
}

We can not instantiate interface but we can create reference of interface.

 public static void main(String[] args) {
Printable p = null; //OK
p = new Printable(); //Not OK
}

We can not define constructor inside interface

Consider folllowing code:

interface Printable{ //Contract

int value = 123;
//public static final int value = 123;

void print( );
//public abstract void print( );
}
class Test implements Printable{ //Service Provider
@Override
public void print() {
[Link]("Value : "+[Link]);
}
}
public class Program { //Service Consumer
public static void main(String[] args) {
Printable p = null; //OK
p = new Test( ); //Upcasting
[Link]();//Dynamic method dispatch
}
}

Syntax to use interface

Interfaces: I1, I2, I3
Classes: C1, C2, C3
I2 implements C1 //Not OK
Super type of interface must be interface
I2 implements I1 //Not OK
Interface can extend another interface
I2 extends I1 //OK
I3 extends I1, I2 //OK
Interface can extend more than one interface. It is callled multiple interface inheritance
C1 extends I1;
Class can implement interface
C1 implements I1 //OK
C1 implements I1, I2 //OK
Class can implement more than one interfaces. It is called as multiple interface
implementation inheritance.
 C2 implements C1 //Not OK
Class can extend another class
C2 extends C1 //OK
C3 extends C1, C2 //Not OK
Class can not extend more than once class. In short class do not support multiple
implementation inheritance.
C2 implements I1 extends C1 //Not OK
Class should first extend class and then implement interface
C2 extends C1 implements I1 //OK
C2 extends C1 implements I1, I2 //OK
Interface fields syntax
interface A{
int num1 = 10;
int num4 = 40;
int num5 = 70;
}
interface B{
int num2 = 20;
int num4 = 50;
int num5 = 80;
}
interface C extends A, B{ //Multiple interface inheritance
int num3 = 30;
int num4 = 60;
}
public class Program {
public static void main(String[] args) {
[Link]("A.num5 : "+A.num5); //70
[Link]("B.num5 : "+B.num5); //80
//[Link]("C.num5 : "+C.num5); //Error: The field
C.num5 is ambiguous
}
public static void main2(String[] args) {
[Link]("A.Num4 : "+A.num4); //40
[Link]("B.Num4 : "+B.num4); //50
[Link]("C.Num4 : "+C.num4); //60
}
public static void main1(String[] args) {
[Link]("Num1 : "+A.num1);
[Link]("Num1 : "+C.num1);

[Link]("Num2 : "+B.num2);
[Link]("Num2 : "+C.num2);

[Link]("Num3 : "+C.num3);
}
}
Interface method syntax:

interface A{
void f1();
}
interface B{
void f2();
}
interface C extends A, B{
void f3();
}
class D implements C{
@Override
public void f1() {
[Link]("D.f1");
}
@Override
public void f2() {
[Link]("D.f2");
}
@Override
public void f3() {
[Link]("D.f3");
}
}
public class Program {
public static void main(String[] args) {
D d = new D();
d.f1();//OK

A a = new D();
a.f1();//OK

B b = new D();
b.f2();//OK

C c = new D();
c.f1(); //OK
c.f2(); //OK
c.f3(); //Ok
}
}

interface A{
void f1();
void f3();
}
interface B{
void f2();
 void f3();
}
class C implements A, B{
@Override
public void f1() {
[Link]("C.f1");
}
@Override
public void f2() {
[Link]("C.f2");
}
@Override
public void f3() {
[Link]("C.f3");
}
}
public class Program {
public static void main(String[] args) {
A a = new C();
a.f1();
a.f3();

B b = new C();
b.f2();
b.f3();
}
}

How to override some of the methods of interface

interface Printable{
void f1();
void f2();
void f3();
void f4();
}
abstract class AbstractPrintable implements Printable{
@Override public void f1() { }
@Override public void f2() { }
@Override public void f3() { }
}
class A extends AbstractPrintable{
@Override
public void f1() {
[Link]("A.f1");
}
}
class B extends AbstractPrintable{
@Override
public void f2() {
[Link]("B.f2");
 }
}
class C extends AbstractPrintable{
@Override
public void f3() {
[Link]("C.f3");
}
}
public class Program {
public static void main(String[] args) {
Printable p = null;

p = new A();
p.f1(); //A.f1

p = new B();
p.f2(); //B.f2

p = new C();
p.f3(); //C.f3
}
}

Types of inheritance
Interface inheritance
Single inheritance( Allowed in java )
Multiple inheritance( Allowed in java )
Hierarchical inheritance( Allowed in java )
Multilevel inheritance( Allowed in java )
implementation inheritace
Single inheritance( Allowed in java )
Multiple inheritance( Not Allowed in java )
Hierarchical inheritance( Allowed in java )
Multilevel inheritance( Allowed in java )
Default interface method
If we want to make changes in the interface at runtime then we should use default method.
We can not provide body to the abstact method but it is mandatory to provide body to the default
method.
It is mandatory to override abstract method but it is optional to override default method.

interface A{
void f1( );
default void f2( ){
//TODO
}
}
class B implements A{
@override
public void f1( ){
//TODO
}
}

interface A{
void f1( );
default void f2( ){
//TODO
}
}
interface B{
void f1( );
default void f3( ){
//TODO
}
}
class C implements A, B{
@override
public void f1( ){
//TODO
}
}

interface A{
void f1( );
default void f2( ){
//TODO
}
}
interface B{
void f1( );
default void f2( ){
//TODO
}
}
class C implements A, B{
@override
public void f1( ){
//TODO
}
@Override
public void f2( ){ //mandatory to override
//TODO
}
}
Consider following code:

interface Collection {
void acceptRecord();

int[] toArray();

void printRecord();

static void swap( int[] arr ) {

int temp = arr[ 0 ];
arr[ 0 ] = arr[ 1 ];
arr[ 1 ] = temp;
}
default void sort() {
int[] arr = [Link]();
for (int i = 0; i < [Link] - 1; i++) {
for (int j = 0; j < [Link] - i - 1; j++) {
if (arr[j] > arr[j + 1]) {

int[] temp = new int[ ] { arr[j], arr[ j + 1 ] };

[Link](temp);
arr[j] = temp[ 0 ];
arr[ j + 1 ] = temp[ 1 ];
}
}
}
}
}

class Array implements Collection {

private int[] arr;

public Array() {
this(5);
}

public Array(int size) {

[Link] = new int[size];
}

@Override
public void acceptRecord() {
try (Scanner sc = new Scanner([Link])) {
for (int index = 0; index < [Link]; ++index) {
[Link]("Enter element : ");
[Link][index] = [Link]();
}
}
}
 @Override
public int[] toArray() {
return [Link];
}

@Override
public void sort() {
for( int i = 0; i < [Link] - 1; ++ i ) {
for( int j = i + 1; j < [Link]; ++ j ) {
if( [Link][ i ] > [Link][ j ] ) {
int[] temp = new int[ ] { arr[ i ], arr[ j ]};
[Link](temp);
arr[ i ] = temp[ 0 ];
arr[ j ] = temp[ 1 ];
}
}
}
}

@Override
public void printRecord() {
[Link]([Link]([Link]));
}
}

public class Program {

public static void main(String[] args) {
Collection c = new Array();
[Link]();
[Link]();
[Link]();
}
}

Static interface methods are helper methods that we can use inside default method as well as inside
sub class. But we can not override it inside sub class.
Functional interface
An interface which can contain Single Abstract Method (SAM) is called as Functional interface / SAM
interface.
Example:
[Link]
[Link]
[Link]
[Link]
[Link]
[Link]
Consider following code:
 @FunctionalInterface
interface A{
void f1();
}

@FunctionalInterface
interface A{
void f1();
default void f2( ){
}
}

@FunctionalInterface
interface A{
void f1();
default void f2( ){
}
static void f3( ){
}
}

@FunctionalInterface
interface A{
void f1();
default void f2( ){
}
default void f3( ){
}
static void f4( ){
}
static void f5( ){
}
}

Shallow copy, Deep copy

Process of copying contents from variable into another variable as it is, is called shallow copy.

int num1 = 10;

int num2 = num1; //Shallow Copy
 Date dt1 = new Date( 13,4,2023);
Date dt2 = dt1; //Shallow Copy of references

If we want to create new instance from existing instance then we should use clone method.
clone is non final and native method of [Link] class:
Syntax:
protected native Object clone( )throws CloneNotSupportedException
Inside clone method, if we want to create shallow copy of instance then we should use [Link]();
Without implementing Cloneable interface, if we try to create clone() of the instane then clone
method throws CloneNotSupportedException.
Marker interface:
An interface which do not contain any member is called as marker / tagging interface.
Marker interface are used to generate metadata. It helps JVM to perform some operations e.g
to do clone, serializing state of java instance etc.
Example:
[Link]
[Link]
[Link]
[Link]

class Date implements Cloneable{

private int day;
private int month;
private int year;

public Date(int day, int month, int year) {

[Link] = day;
[Link] = month;
[Link] = year;
}

public void setDay(int day) {

[Link] = day;
}

public void setMonth(int month) {

[Link] = month;
}

public void setYear(int year) {

[Link] = year;
}
 @Override
public Date clone( ) {
try {
Date other = (Date) [Link]();
return other;
} catch (CloneNotSupportedException e) {
throw new InternalError(e);
}
}

@Override
public String toString() {
return [Link]+" / "+[Link]+" / "+[Link];
}
}

public class Program {

public static void main1(String[] args) {
Date dt1 = new Date(13, 4,2023);
Date dt2 = dt1; //Shallow copy of references
//[Link]( dt1 == dt2 ); //true
}
}

public static void main(String[] args) {

try {
Date dt1 = new Date(13, 4,2023);
Date dt2 = [Link]();
[Link](23);
[Link](7);
[Link](1983);

[Link](dt1);
[Link](dt2);
 } catch (CloneNotSupportedException e) {
// TODO Auto-generated catch block
[Link]();
}
}

Consider example of ArrayList:

public class ArrayList extends AbstractList implements List, RandomAccess, Cloneable, Serializable

public static void main(String[] args) {

ArrayList<Integer> list1 = new ArrayList<>();
[Link](10);
[Link](20);
[Link](30);

ArrayList<Integer> list2 = (ArrayList<Integer>)[Link]();

[Link]();
[Link](list1);
[Link](list2);
}

Shallow Copy
Deep Copy

Write a program to generate Linear singly linked list in java

Operations:
public boolean empty()
public void addLast( int element )
public void removeFirst( )
public void printList( )
Day 17
Shallow Copy of Date reference:

Shallow copy of Date instance:

Shallow Copy of Employee reference:

 Shallow Copy of Employee instance:

Deep Copy of Employee instance:

Fundamental interfaces of Core Java:

[Link]
[Link]
[Link]
[Link]
[Link]
[Link]
[Link]
Comparable interface implementation
Consider data for sorting

If we want to sort array/collection of non primitive type using [Link]() method then non primitive
type must implement Comparable interface.
Comparable is interface declared in [Link] package.
T -> the type of objects that this object may be compared to
Method:
int compareTo(T other)
Returns a negative integer(-1) : current/calling object is less than the specified object.
Returns zero(0): current/calling object is equal to the specified object.
Returns a positive integer(1) : current/calling object is greater than the specified object.
Comparable interface provides natural ordering( default ordering ) of elements inside same class.
This interface imposes a total ordering on the objects of each class that implements it. This ordering
is referred to as the class's natural ordering, and the class's compareTo method is referred to as its
natural comparison method.

@NoArgsConstructor
@AllArgsConstructor
@Getter @Setter
//@ToString
 public class Employee implements Comparable<Employee>{
private int empNumber;
private String empName;
private String job;
private int manager;
private LocalDate hireDate;
private float salary;
private float commision;
private int deptNumber;

@Override
public int compareTo(Employee other) {
return [Link] - [Link];
}
@Override
public String toString() {
return [Link]("%-5d%-10s%-10s%-5d%-15s%-10.2f%-10.2f%-5d",
[Link], [Link], [Link], [Link], [Link],
[Link], [Link], [Link]);
}
}

Comparator interface implementation

If we wan to sort array/collection of non primitive type using different criteria then we should
implement Comparator interface.
Comparator is functional interface declared in [Link] package.
T -> the type of objects that may be compared by this comparator
Method:
int compare(T o1, T o2)
Returns a negative integer(-1) : If first argument is less than the second argument.
Returns zero(0): If first argument is equal to the second argument.
Returns a positive integer(1) : If first argument is greater than the second argument.
Comparator interface provides custom ordering of elements in different classes.

import [Link];

public class DeptNumberComparator implements Comparator<Employee> {

@Override
public int compare(Employee e1, Employee e2) {
return [Link]() - [Link]();
}
}
 import [Link];

public class HireDateComparator implements Comparator<Employee> {

@Override
public int compare(Employee e1, Employee e2) {
return [Link]().compareTo([Link]());
}
}

import [Link];
public class IdComparator implements Comparator<Person>{
@Override
public int compare(Person p1, Person p2) {
if( p1 instanceof Student && p2 instanceof Student ) {
Student s1 = (Student) p1;
Student s2 = (Student) p2;
return [Link]() - [Link]();
}else if( p1 instanceof Employee && p2 instanceof Employee ) {
Employee e1 = (Employee) p1;
Employee e2 = (Employee) p2;
return [Link]() - [Link]();
}else if( p1 instanceof Student && p2 instanceof Employee ) {
Student s1 = (Student) p1;
Employee e2 = (Employee) p2;
return [Link]() - [Link]();
}else {
Employee e1 = (Employee) p1;
Student s2 = (Student) p2;
return [Link]() - [Link]();
}
}
}

Iterable & Iterator

Traversing using iterator

import [Link];
import [Link];

public class Program {

public static void main(String[] args) {
LinkedList<Integer> list = new LinkedList<>();
[Link](10);
[Link](20);
[Link](30);

Integer element = null;

 Iterator<Integer> itr = [Link]();
while( [Link]()) {
element = [Link]();
[Link](element+" ");
}
[Link]();
}
}

Traversing using foreach loop

public static void main(String[] args) {

LinkedList<Integer> list = new LinkedList<>();
[Link](10);
[Link](20);
[Link](30);

for( Integer element : list )

[Link]( element );
}

We can use foreach loop on Array and any instance which implements [Link] interface.
Iterable is interface declared in [Link] package.
T -> the type of elements returned by the iterator
Implementing this interface allows an object to be the target of the "for-each loop" statement.
It is introduced in JDK 1.5
Methods:
[Link] iterator()
default Spliterator spliterator()
default void forEach(Consumer<? super T> action)
Iterator is interface declared in [Link] package.
E -> the type of elements returned by this iterator
It is introduced in JDK 1.2
Methods:
boolean hasNext()
E next()
default void remove()
default void forEachRemaining(Consumer<? super E> action)
 import [Link];
class Node{
int data;
Node next = null;
public Node( int data ) {
[Link] = data;
}
}

class LinkedList implements Iterable<Integer>{

private Node head = null;
private Node tail = null;

public boolean empty( ) {

return [Link] == null;
}
public void addLast( int element ) {
Node newNode = new Node( element );
if( [Link]() )
[Link] = newNode;
else
[Link] = newNode;
[Link] = newNode;
}
@Override
public Iterator<Integer> iterator() {
Iterator<Integer> itr = new LinkedListIterator( [Link] );
//Upcasting
return itr;
}

class LinkedListIterator implements Iterator<Integer>{

private Node trav;

public LinkedListIterator(Node head) {

[Link] = head;
}
@Override
public boolean hasNext() {
return [Link] != null;
}
@Override
public Integer next() {
int data = [Link];
trav = [Link];
return data;
 }
}

public class Program {

public static void main(String[] args) {
LinkedList list = new LinkedList();
[Link]( 10 );
[Link]( 20 );
[Link]( 30 );

for( int element : list )

[Link]( element );
}
}

Process of visiting elements in a collection is calleed as travsering.

In C++ if we use any object as a pointer then such object is called as smart pointer.
Iterator is a smart pointer which is used to traverse collection.
Any class which implements Iterable interface is considered as travsersible using foreach loop.
Abstract class versus Interface
Abstract class
If "is-a" relationship is exist between super type & sub type and if we want to use same method
design/signature in all the sub classes then super type should be abstract class.
 Consider following diagram

Using abstract class we can group elements/instances of realated types together.

Shape[] arr = new Shape[ 3 ];

arr[ 0 ] = new Rectangle(); //Upcasting
arr[ 1 ] = new Circle(); //Upcasting
arr[ 2 ] = new Triangle(); //Upcasting

Super class of abstract class can be either concrete class / abstract class. Abstract class can extend
only one abstract class / concrete class.
We can define constructor inside abstract class.
Abstract may/may not contain abstract method.
When state is involved in super type then it should be abstract class
Interface
If "is-a" relationship is not exist between super type & sub type( "can-do" relationship is exist ) and if
we want to use same method design in all the sub classes then super type should be interface.
 Consider following diagram

Using interface, we can group element/instances of unrelated type together.

Printable[] arr = new Printable[ 3 ];

arr[ 0 ] = new Complex( ); //Upcasting
arr[ 1 ] = new Date( ); //Upcasting
arr[ 2 ] = new Color( ); //Upcasting

Super type of interface must be interface. Interface can extend multiple interfaces.
We can not define constructor inside interface.
Interface methods are by default public and abstract.
When state is not involved in super type then it should be interface.
Nested class
We can define class inside scope of another class. It is called as nested class.
Consider following code:

//Top level class

class Outer{ //[Link]
//Nested class
class Inner{ //Outer$[Link]
//TODO: Implementation part
}
}

Access modifier of top level class can be either package level private or public only but we can use
any access modifier on nested class.
Types of nested class
Non static nested class / Inner class
 Static nested class
Inner class
In Java, non static nested class is called as inner class.
If implementation of nested class depends on top level class then we should declare nested class non
static.

class LinkedList implements Iterable<Integer>{

private Node head = null;

private Node tail = null;

//TODO: other implementation

@Override
public Iterator<Integer> iterator() {
Iterator<Integer> itr = new LinkedListIterator( [Link] );
//Upcasting
return itr;
}

class LinkedListIterator implements Iterator<Integer>{

private Node trav;
public LinkedListIterator(Node head) {
[Link] = head;
}
//TODO: Other implementation
}
}

Note: For the simplicity, consider non static nested class a non static method of the class.
Consider following code:

class Outer{
class Inner{
//TODO
}
}

Instantiation of top level class:

Outer out = new Outer();

Instantiation of inner class:

 Outer out = new Outer();
[Link] in = [Link] Inner();

[Link] in = new Outer().new Inner();

Inside non static nested class i.e inner class, we can not define static members( fields & methods ).
But if we want to declare any static field then it must be final.
Using instance, we can access members of non static nested class inside method of top level class.
Consider following example:

class Outer{
private int num1 = 10; //OK
private static int num2 = 20; //OK

class Inner{
private int num3 = 30; //OK
//private static int num4 = 40; //Not OK
private final static int num4 = 40; //OK
}

public void print( ) {

[Link]("Num1 : "+this.num1);
[Link]("Num2 : "+Outer.num2);
Inner in = new Inner();
[Link]("Num3 : "+in.num3);
[Link]("Num4 : "+Inner.num4);
}
}
public class Program {
public static void main(String[] args) {
Outer out = new Outer();
[Link]();
}
}

Without instance, we can access all the members of top level class inside method of non static
nested class i.e inner class.
Consider following code:

class Outer{
private int num1 = 10;
private static int num2 = 20;
 class Inner{
private int num3 = 30;
private final static int num4 = 40;
public void print( ) {
[Link]("Num1 : "+num1); //OK
[Link]("Num2 : "+num2); //OK
[Link]("Num3 : "+this.num3);
[Link]("Num4 : "+Inner.num4);
}
}
}
public class Program {
public static void main(String[] args) {
[Link] in = new Outer().new Inner();
[Link]();
}
}

Consider following code snippet

class Outer{
private int num1 = 10;
class Inner{
private int num1 = 20;
public void print( ) {
int num1 = 30;
[Link]("Num1 : "+[Link].num1); //10
[Link]("Num1 : "+this.num1); //20
[Link]("Num1 : "+num1); //30
}
}
}
public class Program {
public static void main(String[] args) {
[Link] in = new Outer().new Inner();
[Link]();
}
}

Static Nested Class

If we declare nested class as a static then it is called as static nested class.
If implementation of nested class do not depend on top level class then we should declare nested
class static.
Consider following code:
 class LinkedList implements Iterable<Integer>{
static class Node{
int data;
Node next = null;
public Node( int data ) {
[Link] = data;
}
}

private Node head = null;

private Node tail = null;
}

In Java, we can not declare top level class static but we can declare nested class static.

static class Outer{ //Not OK

//TODO
}

//Top Level class

class Outer{ //[Link]
//Static Nested class
static class Inner{ //OK: Outer$[Link]
//TODO
}
}

Note: For simplicity, consider static nested class as a static method of the class.
Instantiation of Top level class:

Outer out = new Outer( );

Instantiation of static nested class:

[Link] in = new [Link]();

We can declare/define static members inside static nested class.

Using instance, we can access all the members of top level class inside method of top level class.
 class Outer{
private int num1 = 10;
private static int num2 = 20;

static class Inner{

private int num3 = 30; //OK
private static int num4 = 40; //OK
}
public void print( ) {
[Link]("Num1 : "+this.num1);
[Link]("Num2 : "+Outer.num2);
Inner in = new Inner();
[Link]("Num3 : "+in.num3);
[Link]("Num4 : "+Inner.num4);
}
}
public class Program {
public static void main(String[] args) {
Outer out = new Outer();
[Link]();
}
}

We can access static members of the top level class inside method of static nested class directly. But
to access non static member of the class we must use instance of the class.

class Outer{
private int num1 = 10;
private static int num2 = 20;

static class Inner{

private int num3 = 30; //OK
private static int num4 = 40; //OK

public void print( ) {

//[Link]("Num1 : "+num1); //Not OK
Outer out = new Outer();
[Link]("Num1 : "+out.num1); //OK
[Link]("Num2 : "+num2); //OK
[Link]("Num3 : "+this.num3);
[Link]("Num4 : "+Inner.num4);
}
}
}
public class Program {
public static void main(String[] args) {
[Link] in = new [Link]();
[Link]();
}
}
Local Class
We can define class inside scope of another method. It is called as local class.
Local class is also called as method local class.
we can not use reference / instance of local class outside method.
Types of local class:
Method local inner class.
Method local anonymous inner class.
Method local inner class.
In Java, we can not declare local variable as well as local class static.
Since method local class is non static, it is also called as method local inner class.

public class Program {

public static void main(String[] args) {
//Method local inner class
class Complex{ //Program$[Link]
private int real = 10;
private int imag = 20;
public Complex() {
this(0,0);
}
public Complex(int real, int imag) {
[Link] = real;
[Link] = imag;
}
@Override
public String toString() {
return [Link]+" "+[Link];
}
}
Complex c1 = new Complex();
[Link]([Link]());
}
}

Method local anonymous inner class

In Java, we can define class without name. It is called as anonymous class.
We can define anonymous class inside method only. Hence it is called as anonymous inner class.
If we want to define anonymous inner class then we must use new operator.

public class Program {

public static void main(String[] args) {
//Object obj; //obj is refernce of [Link] class
 //new Object( ); //Anonymous instance of [Link] class
//Object obj = new Object(); //Instance with object reference

Object obj = new Object( ) { //Program$[Link]

private String message = "Hello World";
@Override
public String toString() {
return [Link];
}
};

String str = [Link]();

[Link]( str );
}
}

abstract class Shape{

protected double area;
public double getArea() {
return area;
}
public abstract void calculateArea();
}

public class Program {

public static void main(String[] args) {
Shape sh = new Shape() {
private double radius = 10.5;
@Override
public void calculateArea() {
[Link] = [Link] * [Link](radius, 2);
}
};
[Link]();
[Link]("Area : "+[Link]());
}
}

interface Printable{
void print( );
}
public class Program {
public static void main(String[] args) {
Printable p = new Printable() {
@Override
public void print() {
[Link]("Hello World!!");
}
};
 [Link]();
}
}

Reflection
Annotation
Day 18
What is Metadata?
Data about data is called as metadata. In other words, metadata refers to data that provides
information about other data.
For example, metadata for a photo might include:
The date and time it was taken
The location where it was taken
The camera used to take it
The resolution of the image.
In the case of digital media, metadata can include information about:
the artist
title
genre and album of a particular song or video.
In a file management application, metadata such as:
file name
size
creation date and modification date are commonly used to organize and search for files.
Metadata of Interface
What is the name of interface?
In which package it is declared?
Which is the access modifier of interface?
Which annotations are used on interface?
Which are the super interfaces of interface?
Which are the members declared inside interface?
Metadata of Class
What is the name of class?
In which package it is declared?
Which are the modifiers used on class?
Which are the annotations used on class?
Which is the super class of class?
Which are the super interfaces of the class?
Which are the members declared inside class?
Metadata of the Field
What is the name of the field?
Which is the type of field?
Which are the modifiers of field?
Which annotations has been used on the field?
Whether field is declared or inherited field?
Metadata of the method
What is the name of method?
Which are the modifiers used with method?
Which is the return type of method?
Which are the parameters of the methods?
Which exceptions method throws?
Which annotations has been used on the method.
Whether method is declared or inerhited method?
Application of Metadata
Metadata removes the need for native C/C++ header and library files when compiling.
Integrated Development Environment(IDE) uses metadata to help us write code. Its IntelliSense
feature parses metadata to tell us what fields and methods a type offers and in the case of a method,
what parameters the method expects.
Metadata allows an objectʼs fields to be serialized into a memory block, sent to another machine, and
then deserialized, re-creating the objectʼs state on the remote machine.
The Garbage Collector uses metadata to keep track of each object's lifecycle, from creation to
destruction.
Reflection
Reflection in Java is a feature that allows a program to examine or modify the behavior of a class,
method, or object at runtime.
It is a relatively advanced feature and should be used only by developers who have a strong grasp of
the fundamentals of the language.
reflection is a powerful technique and can enable applications to perform operations which would
otherwise be impossible.
using reflection, we can:
Obtain information about the class at runtime, such as its name, superclass, implemented
interfaces, constructors, methods, and fields.
Create new objects of a class dynamically, without knowing the class name at compile time.
Access and modify the values of fields in an object, even if they are declared as private.
Invoke methods on an object dynamically, without knowing the method names at compile time.
How to use reflection in Java?
Consider following code:

class Date{
//TODO: Member definition
}
class Address{
//TODO: Member definition
}
class Person{
//TODO: Member definition
 }
class Program{
public static void main(String[] args) {
Date birthDate = new Date( 23, 7, 1983 );
Date joinDate = new Date( 1, 1, 2007 );
Address curAddress = new Address( "Pune-46");
Person person = new Person("Sandeep", currentAddress, birthDate );
}
}

When class loader loads Program, String, Date, Address, Person class for execution then it create
instance of [Link] per loaded type on Method area. Instance contains metadata of the
loaded type.

[Link] class
Class class is a final class declared in [Link] package.
The entry point for all reflection operations is [Link].
Instances of the class [Link] represent classes and interfaces in a running Java application.
Class has no public constructor. Instead Class objects are constructed automatically by the Java
Virtual Machine.
Methods of [Link]:
public static Class<?> forName(String className) throws ClassNotFoundException
public Annotation[] getAnnotations()
public Annotation[] getDeclaredAnnotations()
public ClassLoader getClassLoader()
public Constructor<?>[] getConstructors() throws SecurityException
public Constructor getConstructor(Class<?>... parameterTypes) throws
NoSuchMethodException, SecurityException
public Field getDeclaredField(String name) throws NoSuchFieldException, SecurityException
public Field[] getDeclaredFields() throws SecurityException
public Field getField(String name) throws NoSuchFieldException, SecurityException
public Field[] getFields() throws SecurityException
public Class<?>[] getInterfaces()
public Method[] getMethods() throws SecurityException
 public Method[] getDeclaredMethods()throws SecurityException
public String getName()
public String getSimpleName()
public Package getPackage()
public InputStream getResourceAsStream(String name)
public String getTypeName()
public T newInstance() throws InstantiationException, IllegalAccessException
Retrieving Class Objects
Using getClass() method:

Integer i = new Integer( 123 );

Class<?> c = [Link]( ); //OK

getClass is final method of [Link] class:

public final native Class<?> getClass();

Using .class Syntax

int i = 123;
Class<?> c = [Link]( ); //Not OK
Class<?> c = [Link]; //OK
Class<?> c = [Link]; //OK

It is convenient to use .class syntax with primitive type and abstract class.
Using [Link]() method
If the fully-qualified name of a class is available, it is possible to get the corresponding Class
using the static method [Link]().

Class<?> c = [Link]("[Link]"); //OK

Class<?> c = [Link]("[D"); //OK: same as double[].class

Class<?> c = [Link]("[[[Link]"); //OK: same as

String[][].class

Using TYPE Field for Primitive Type

Each of the primitive types and void has a wrapper class in [Link] that is used for boxing of
primitive types to reference types. Each wrapper class contains a field named TYPE which is
 equal to the Class for the primitive type being wrapped.
The .class syntax is a more convenient and the preferred way to obtain the Class for a primitive
type; however there is another way to acquire the Class.

Class<?> c = [Link];
Class<?> c = [Link]; //OK
Class<?> c = [Link]; //OK

Examine Type Metadata

import [Link];

public class Program {

public static void main(String[] args) {
Class<?> c = [Link];

String typeName = [Link](); //Returns the name of the entity

represented by this Class object.

String simpleTypeName = [Link](); //Returns the simple

name of the underlying class.

Package pkg = [Link]();

String packageName = [Link](); //Return the name of this
package.

int mod= [Link]();

String modifiers = [Link](mod); //Returns string
representation of the set of modifiers.

Class<?> sc = [Link]();
String superClassName = [Link]();//Returns the name of the
super class

Class<?>[] si = [Link]();
StringBuffer sb = new StringBuffer();
for (Class<?> i : si) {
[Link]([Link]());//Returns the name of the super
interfaces
}
}
}

Examine Field Metadata

import [Link];
import [Link];
 public class Program {
public static void main(String[] args) {
Class<?> c = [Link];
Field[] fields = [Link](); //Returns an array of public
fields that are declared in the class or its superclasses
Field[] declaredFields = [Link](); //Returns an array
of all the fields declared in the class
for (Field field : declaredFields) {
String modifiers = [Link]([Link]());
String typeName = [Link]().getSimpleName();
String fieldName = [Link]();
[Link]( modifiers+" "+typeName+" "+fieldName);
}
}
}

getFields() returns an array of public fields that are declared in the class or its superclasses. This
includes fields inherited from the superclass or any interface that the class implements. This method
does not return any private or protected fields, regardless of whether they are inherited or declared in
the class.
getDeclaredFields() returns an array of all the fields declared in the class. This includes public,
private, and protected fields. It does not include any fields inherited from a superclass or an interface.
Examine Method Metadata

import [Link];
import [Link];
import [Link];

public class Program {

public static void main(String[] args) {
Class<?> c = [Link];
Method[] methods = [Link]();
Method[] declaredMethods = [Link]();
for (Method method : declaredMethods) {
String modifiers = [Link]( [Link]());
String returnType = [Link]().getSimpleName();
String methodName = [Link]();

StringBuffer paramList = new StringBuffer("( ");

Parameter[] parameters = [Link]();
for( Parameter parameter : parameters ) {
String type = [Link]().getSimpleName();
[Link](type);
[Link](" ");
String name = [Link]();
[Link](name);
[Link](", ");
}
 if( [Link] > 0 )
[Link]( [Link]() - 2 );
[Link](" )");

StringBuffer exceptionList = new StringBuffer( );

Class<?>[] exceptionTypes= [Link]();
if( [Link] > 0 )
[Link]("throws ");
for( Class<?> exceptionType : exceptionTypes) {
[Link]( [Link]() );
[Link]( ", ");
}
if( [Link] > 0 )
[Link]( [Link]() - 2 );

[Link]( modifiers+" "+ returnType+" "+methodName

+""+paramList+""+exceptionList);
}
}
}

getMethods(): This method returns an array of Method objects that represent all the public methods
of the class (including inherited methods) and the public methods declared in any interfaces
implemented by the class.
getDeclaredMethods(): This method returns an array of Method objects that represent all the
methods declared explicitly by the class, including both public and non-public methods. It does not
include any inherited methods or the methods declared in any interfaces implemented by the class.
Accessing private fields using Reflection

import [Link];

class Complex{
private int real;
private int imag;
public Complex() {
[Link] = 10;
[Link] = 20;
}
public int getReal() {
return [Link];
}
public int getImag() {
return [Link];
}
}
public class Program {
public static void main(String[] args) {
try {
 Complex complex = new Complex();
[Link]("Real Number : "+[Link]());
[Link]("Imag Number : "+[Link]());

Class<?> c = [Link]();
Field field = null;

field = [Link]("real");
[Link](true);
[Link](complex, 50);

field = [Link]("imag");
[Link](true);
[Link](complex, 60);

[Link]("Real Number : "+[Link]());

[Link]("Imag Number : "+[Link]());
} catch (NoSuchFieldException | SecurityException |
IllegalArgumentException | IllegalAccessException e) {
[Link]();
}
}
}

Reflection to access and invoke a private constructor of a class.

import [Link];
import [Link];

class Complex {
private int real;
private int imag;

private Complex(int real, int imag) {

[Link] = real;
[Link] = imag;
}

public int getReal() {

return [Link];
}

public int getImag() {

return [Link];
}
}

public class Program {

public static void main(String[] args) {
try {
Class<?> c = [Link];
 Constructor<?> constructor =
[Link]([Link], [Link]);
[Link](true);
Complex complex = (Complex) [Link](50, 60);
[Link]("Real Number : " + [Link]());
[Link]("Imag Number : " + [Link]());
} catch (NoSuchMethodException | SecurityException |
InstantiationException | IllegalAccessException
| IllegalArgumentException | InvocationTargetException e)
{
[Link]();
}
}
}

Middleware Application

//[Link]
public class Calculator {
public double sum( int num1, float num2, double num3) {
return num1 + num2 + num3;
}
public int sub( int num1, int num2 ) {
return num1 + num2;
}
}

//[Link]
class Convert{
public static Object changeType( String type, String value ) {
switch( type ) {
case "int":
return [Link](value);
case "float":
return [Link](value);
case "double":
return [Link](value);
}
return null;
}
}

//[Link]
import [Link];
import [Link];
import [Link];
 public class Program {
public static void main(String[] args) {
try( Scanner sc = new Scanner([Link])){
[Link]("Enter F.Q. Class Name : ");
String className = [Link]();
//[Link]
Class<?> c = [Link](className);

[Link]("Enter Method Name : ");

String methodName = [Link](); //sum

Method[] methods = [Link]();

for (Method method : methods) {
if( [Link]().equals( methodName ) ) {
Parameter[] parameters = [Link]();
Object[] arguments = new Object[ [Link]() ];
for( int index = 0; index < [Link](); ++
index ) {
String parameterType = parameters[ index
].getType().getName();
[Link]("Enter value for the argument
"+parameterType+" Type : ");
Object argument = [Link](parameterType,
[Link]());
if( argument != null )
arguments[ index ] = argument;
}

Object result = [Link]([Link](), arguments );

[Link]("Result : "+result);
break;
}
}
}catch( Exception ex ) {
[Link]();
}
}
}

Advantages of Reflection:
Dynamic class loading: Reflection allows classes to be loaded and instantiated dynamically, which
can be useful when the class to be used is not known at compile time.
Introspection: Reflection allows the properties and methods of a class to be inspected at runtime.
This can be useful for building tools like debuggers or IDEs, where we need to be able to examine the
structure of a program while it is running.
Frameworks and libraries: Many Java frameworks and libraries make use of reflection to provide
powerful features like dependency injection, ORM, and serialization.
Testing: Reflection can be useful for testing by allowing access to private methods and fields, and for
mocking objects.
Drawbacks of Reflection:
Performance overhead: Reflection operations are slower than direct method calls because they
involve additional runtime checks and lookups.
Security risks: Reflection can be used to bypass access controls and security measures, allowing
malicious code to access private fields and methods or modify the behavior of a program in
unexpected ways.
Complexity and readability: Reflection code can be harder to read and understand, especially for
developers who are not familiar with the language's reflection APIs.
Proxy Design Pattern( Assignment )
The official Java documentation on the Proxy pattern:
[Link]
Reference: The Gang of Four (GoF) book: The GoF book "Design Patterns: Elements of Reusable
Object-Oriented Software".
Multithreading
Singletasking versus multitasking
Process Definition:
Program in execution is called as process.
Running instance of a program is called as process.
Process is also called as task.

Term Singletasking and multitasking is always used in the context of Operating System
An ability of operating system to execute single task at a time is called as Singletasking.
Example: MS DOS is singletasking operating system.
An ability of operating system to execute multiple task at a time is called as Multitasking.
Example: MS Windows, Linuxm Mac OS etc.
Thread concept
Thread Definition
Lightweight process is called as thread.
According to Java, thread is a seperate path of execution which runs independently
Therad always resides in process.
If we want to utilize H/W resources( memory, cpu) efficiently then we should use thread.
If any application take help of single thread for the execution then such application is called as single
threaded application.
If any application take help of multiple threads for the execution then such application is called as
multi threaded application.
Thread is Non Java resource. It is also called unmanged resource.
process based versus thread based multitasking

Before transfering control of CPU from one process to another, schedular must save state of the
process into process control block. Then another process get access of CPU. It is called context
switching.
Since context switching is a heavy task, proess based multitasking is called as heavy weight
multitasking.
 Threads always reside into process. Hence to access the resources thread do not require context
switching. So thread based multitasking is called as lightweight multitasking
Java is multithreaded
When we start execution of Java application, JVM starts execution of main thread and Garbage
collector. Due to these threads, every Java application is multithreaded.
Main Thread
It is called as user thread / Non dameon thread.
Main thread is responsible for invoking main method.
In Java, priority of main thread is 5( Thread.NORM_PRIORITY ).
Garbage Collector
It is called as daemon thread / background thread.
Garbage collector is responsible for invoking finalize method and deallocating / releasing
memory of unused objects.
Garbage collector is also called as finalizer.
In Java, priority of garbage collector is 8( Thread.NORM_PRIORITY + 3).
Multithreading in Java
If we want to use threads in Java then we should use Types declared in [Link] package.
Interface(s)
Runnable
Class(es)
Thread
ThreadGroup
ThreadLocal
Enum:
[Link]
Exception
IllegalThreadStateException
 IllegalMonitorStateException
InterruptedException
Runnable
It is functional interface declared in [Link] package.
Method:
void run() //Business logic method of thread
To create thread, we can use Runnable interface.
Thread

Thread is sub class of [Link] class and it implements [Link] interface.

Instance of Thread class is not a OS thread. Rather it represents OS thread.
JVM is responsible for mapping Thread instance with OS thread.

Nested Type
[Link] is enum declared inside Thread class.

import [Link];

public class Program {

public static void main(String[] args) {
State[] states = [Link]();
for (State state : states) {
[Link]("%-15s%-5d\n", [Link](),
[Link]());
}
}
}

NEW 0
RUNNABLE 1
BLOCKED 2
WAITING 3
TIMED_WAITING 4
TERMINATED 5

Fields:
public static final int MIN_PRIORITY //1
public static final int NORM_PRIORITY //5
public static final int MAX_PRIORITY //10
 Constructors
public Thread()
public Thread(String name)
public Thread(Runnable target)
public Thread(Runnable target, String name)
public Thread(ThreadGroup group, Runnable target, String name)
Methods
public static Thread currentThread()
public final String getName()
public final void setName(String name)
public final int getPriority()
public final void setPriority(int newPriority)
public [Link] getState()
public final boolean isAlive()
public final boolean isDaemon()
public final void join() throws InterruptedException
public final void setDaemon(boolean on)
public static void sleep(long millis) throws InterruptedException
public void start()
public static void yield()
Thread creation using [Link] class and Runnable interface
User Thread versus Daemon Thread
Thread termintation
Blocking calls in Thread
Race condition and synchronized keyword
Inter thread communication using wait,notify/notifyAll
Synchronization using consumer/producer
Thread life cycle.
Day 19
Why Java is multi-threaded
When we start execution of Java application then JVM starts execution of main thread and garbage
collector( GC ). Due to these two threads every java application is multithreaded.
Main Thread
It is user thread / non daemon thread.
It is responsible for calling/invoking main method.
Its default priority in 5( In Java, Thread.NORM_PRIORITY ).
Garbage Collector / Finalizer
It is daemon thread / backgrounf thread.
It is responsible for releasing / reclaiming / deallocating memory of unused( whose
reference count is 0 ) instances.
Before releasing memory of unused instance, GC invoke finalize( similar to destructor in
C++) method on instance.
Its default priority in 8( In Java, Thread.NORM_PRIORITY + 3 ).
If we want to use non java resource into Java then we must use Java Native Interface framework.
Thread is non Java resource and to access it we require JNI. But Java application developer need not
to worry avout it. Because SUN/ORACLE developers has already written logic to access OS thread in
Java. In other words, Java has built-in support to thead. Hence java is considered as multithreaded
programming langauge.
Runnable
It is a functional interface declared in [Link] pckage.
"void run( )" is a method of [Link] interface. In the context of multi-threading, run()
method is called as business logic method.
If we want to create thread in Java then we should use Runnable interface.

class Task implements Runnable{

@Override
public void run() {
[Link]("Hello from run method()");
}
}
public class Program {
public static void main(String[] args) {
Runnable target = new Task(); //Upcasting
Thread th = new Thread(target);
[Link]();
}
}

Thread
[Link] class is a sub class of [Link] class and it implements [Link]
interface.

public class Thread

extends Object
implements Runnable

Thread is non Java resource. In other words, it is unmanaged resource. Hence developer must take
care of its creation as well as termination / dispose.
Instance of [Link] is not a operating system thread. Rather it represents operating system
thread.

If we want to utilize hardware resources efficiently then we should use thread.

Method(s) of [Link] class:
public String toString();
public boolean equals( Object obj );
public native int hashCode( );
protected native Object clone( )throws CloneNotSupportedException
protected void finalize()throws Throwable
public final native Class<?> getClass();
public final void wait( )throws InterruptedException
public final native void wait( long timeOut )throws InterruptedException
public final void wait( long timeOut, int nanos )throws InterruptedException
public final void notify();
public final void notifyAll();
Method(s) of [Link] interface
void run( );
Nested type of [Link] class
[Link] is nested enum defined inside [Link] class.

package [Link];
public class Thread extends Object implements Runnable{
public static enum State{
NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED;
}
}

[Link] is nested functional interface defined inside

[Link] class.

package [Link];
public class Thread extends Object implements Runnable{
@FunctionalInterface
public static interface UncaughtExceptionHandler {
void uncaughtException(Thread t, Throwable e);
}
}

Fields of [Link] class

public static final int MIN_PRIORITY = 1; //Thread.MIN_PRIORITY
public static final int NORM_PRIORITY = 5; //Thread.NORM_PRIORITY
public static final int MAX_PRIORITY = 10; //Thread.MAX_PRIORITY
Constructor Summary of [Link] class:
public Thread();

Thread th = new Thread( );

public Thread(String name );

Thread th = new Thread( "User Thread-1" );

public Thread(Runnable target);

Runnable target = new Task();

Thread th = new Thread( target );
 public Thread(Runnable target, String name);

Runnable target = new Task();

Thread th = new Thread( target, "User Thread-1" );

public Thread(ThreadGroup group, Runnable target);

ThreadGroup group = new ThreadGroup("CDAC-Thread-Group");

Runnable target = new Task();
Thread th = new Thread( group, target );

public Thread(ThreadGroup, String name );

ThreadGroup group = new ThreadGroup("CDAC-Thread-Group");

Thread th = new Thread( group, "User Thread-1");

public Thread(ThreadGroup group, Runnable target, String name);

ThreadGroup group = new ThreadGroup("CDAC-Thread-Group");

Runnable target = new Task();
Thread th = new Thread( group, target, "User Thread-1");

public Thread(ThreadGroup group, Runnable targer, String name , long stackSize) ;

ThreadGroup group = new ThreadGroup("CDAC-Thread-Group");

Runnable target = new Task();
Thread th = new Thread( group, target, "User Thread-1", 0 );

In Java, we can create thread using [Link] class.

class Task extends Thread{

@Override
public void run() {
[Link]("Hello from run method");
}
}
public class Program {
public static void main(String[] args) {
Thread th = new Task( ); //Upcasting
[Link]();
}
}
Method Summary of [Link] class
public static Thread currentThread()
public long getId()
public final String getName()
public final void setName(String name)
public final int getPriority()
public final void setPriority(int newPriority)
public [Link] getState()
public final ThreadGroup getThreadGroup()
public [Link] getUncaughtExceptionHandler()
public static void setDefaultUncaughtExceptionHandler([Link] eh)
public void interrupt()
public static boolean interrupted()
public boolean isInterrupted()
public final boolean isAlive()
public final boolean isDaemon()
public final void join() throws InterruptedException
public final void setDaemon(boolean on)
public static void sleep(long millis) throws InterruptedException
public static void yield()
Getting information of main thread

public static void main(String[] args) {

Thread thread = [Link]();
[Link]( [Link]() ); //Thread[main,5,main]
//main : thread's name
//5 : priority
//main : thread group.
}

public static void main(String[] args) {

Thread thread = [Link]();

String name = [Link]();

[Link]("Thread Name : "+name);

int priority= [Link]();

[Link]("Thread Priority : "+priority);

ThreadGroup group = [Link]();

[Link]("Thread Group : "+[Link]());

State state = [Link]();

[Link]("Thread State : "+[Link]());
 boolean type = [Link]();
[Link]("Thread Type : "+( type ? "Daemon Thread"
: "User Thread") );

boolean status = [Link]();

[Link]("Thread Status : "+( status ? "Alive" :
"Dead") );
}

Output is:

Thread Name : main

Thread Priority : 5
Thread Group : main
Thread State : RUNNABLE
Thread Type : User Thread
Thread Status : Alive

Getting information of garbage collector

class Sample{
public Sample( ) {
[Link]("Inside constructor of
"+[Link]().getSimpleName());
}
public void print( ) {
[Link]("Inside print method of
"+[Link]().getSimpleName());
}
@Override
protected void finalize() throws Throwable {
[Link]("Inside finalize method of
"+[Link]().getSimpleName());

Thread thread = [Link]();

String name = [Link]();

[Link]("Thread Name : "+name);

int priority= [Link]();

[Link]("Thread Priority : "+priority);

ThreadGroup group = [Link]();

[Link]("Thread Group : "+[Link]());

State state = [Link]();

[Link]("Thread State : "+[Link]());
 boolean type = [Link]();
[Link]("Thread Type : "+( type ? "Daemon
Thread" : "User Thread") );

boolean status = [Link]();

[Link]("Thread Status : "+( status ? "Alive" :
"Dead") );
}
}

public static void main1(String[] args) {

Sample sample = null;
sample = new Sample();
[Link]();
sample = null;
//[Link](); //or
[Link]().gc();
}

Output is

Thread Name : Finalizer

Thread Priority : 8
Thread Group : system
Thread State : RUNNABLE
Thread Type : Daemon Thread
Thread Status : Alive

What do you know about final/finally/finalize?

final
It is keyword, we can use with local variable, field, method and class.
If we use final modifier with method local variable and field then it is considered as
constant.
If we use final modifier with method then we can not override/redefine method inside sub
class
If we use final modiifer with class then we can not extend it.
finally
It is a block that we can use with try/catch.
If we want to close local resources then we should use finally block.

public static void main(String[] args) {

Scanner sc = null; //Method local variable
try{
sc = new Scanner( [Link] );
//TODO
 }catch( Exeption ex ){
[Link]();
}finally{
[Link](); //Releasing local resource
}
}

finalize
It is non final method of [Link] class.
If we want to release class level( which is declared as field ) resources then we should
use finalize method.

class Sample{
private Scanner sc; //Field
public Sample( ) {
[Link] = new Scanner( [Link]);
}
//TODO
@Override
protected void finalize() throws Throwable {
[Link]();
}
}
public class Program {
public static void main(String[] args) {
Sample sample = null;
sample = new Sample();
[Link]();
sample = null;
[Link]
}
}

Thread Creation in Java

In Java, we can create thread using 2 ways:
By implementing Runnable interface
By extending Thread class.
Thread Creation in by implementing Runnable interface
If we create Thread instance but do not call start() method on it then is considered in NEW state.

Runnable target = new Task(); //Upcasting

Thread th = new Thread(target); //NEW

To start execution of thread we should start() method.

If we call start() method on thread instance then thread is considered in RUNNABLE state.

Runnable target = new Task(); //Upcasting

Thread th = new Thread(target); //NEW
[Link](); //RUNNABLE

If we call start() method on already started thread then start() method throws
IllegalThreadStateException

Runnable target = new Task(); //Upcasting

Thread th = new Thread(target); //NEW
[Link](); //RUNNABLE
[Link](); //IllegalThreadStateException

When control come out of run method then thread gets terminated. In this case thread is considered
in TERMINATED state.
In following cases, control can come out of run method and thead can terminate:
Successful completion of run method.
Getting exception during execition of run method.
Execution of jump statement( return statement ) inside run method.
If we want to suspend execution of running thread then we should use sleep() method. It is a static
method of [Link] class.

public static void sleep(long millis) throws InterruptedException

millis - the length of time to sleep in milliseconds

1000 millisecond = 1 second
Usage:

[Link]( 250 )

Following methods calls are considered as blocking calls:

sleep()
suspend()
join()
wait()
Input operations in run method
Generally we should use blocking calls very carefully.
If we want to group functionally realated threads together then we should use ThreadGroup.

public static void main(String[] args) {

Runnable target = new Task();

ThreadGroup threadGroup = new ThreadGroup("acts");

Thread th1 = new Thread(threadGroup, target);

[Link]("User Thread#1");
[Link]();

Thread th2 = new Thread(threadGroup, target);

[Link]("User Thread#2");
[Link]();
}

Thread creation using Runnable

class Task implements Runnable{

private Thread thread;
public Task( String name ) {
[Link] = new Thread(this, name);
[Link]();
}

@Override
public void run() {
//TODO: Business Logic
}
}
public class Program {
public static void main(String[] args) {
Task th1 = new Task("User Thread#1");
Task th2 = new Task("User Thread#2");
}
}
 what is the relation between start and run method?

start() method do not call run() method.

If we call start() method on java thread instance then it is considered as request to the JVM to
get thread from operating system and to map it with java thread instance.
Schedular is responsible for picking thread from queue and assiging CPU to it. When schedular
assign CPU to the OS thread then JVM invoke run method on instance who has implemented
[Link] interface.
Thread Creation in by extending Thread class

class Task extends Thread{

public Task( String name ) {
super(name);
[Link]();
}
@Override
public void run() {
//TODO : Business logic
}
}
public class Program {
public static void main(String[] args) {
Task th1 = new Task("User Thread#1");
}
}
Day 20
How to analyze thread dumps:
[Link]
Why Java is multi-threaded
When we start execution of Java application then JVM starts execution of main thread and garbage
collector( GC ). Due to these two threads every java application is multithreaded.
Main Thread
It is user thread / non daemon thread.
It is responsible for calling/invoking main method.
Its default priority in 5( In Java, Thread.NORM_PRIORITY ).
Garbage Collector / Finalizer
It is daemon thread / backgrounf thread.
It is responsible for releasing / reclaiming / deallocating memory of unused( whose
reference count is 0 ) instances.
Before releasing memory of unused instance, GC invoke finalize( similar to destructor in
C++) method on instance.
Its default priority in 8( In Java, Thread.NORM_PRIORITY + 3 ).
If we want to use non java resource into Java then we must use Java Native Interface framework.
Thread is non Java resource and to access it we require JNI. But Java application developer need not
to worry avout it. Because SUN/ORACLE developers has already written logic to access OS thread in
Java. In other words, Java has built-in support to thead. Hence java is considered as multithreaded
programming langauge.
Runnable
It is a functional interface declared in [Link] pckage.
"void run( )" is a method of [Link] interface. In the context of multi-threading, run()
method is called as business logic method.
If we want to create thread in Java then we should use Runnable interface.

class Task implements Runnable{

@Override
public void run() {
[Link]("Hello from run method()");
}
}
public class Program {
public static void main(String[] args) {
Runnable target = new Task(); //Upcasting
Thread th = new Thread(target);
[Link]();
}
}
Thread
[Link] class is a sub class of [Link] class and it implements [Link]
interface.

public class Thread

extends Object
implements Runnable

Thread is non Java resource. In other words, it is unmanaged resource. Hence developer must take
care of its creation as well as termination / dispose.
Instance of [Link] is not a operating system thread. Rather it represents operating system
thread.

If we want to utilize hardware resources efficiently then we should use thread.

Method(s) of [Link] class:
public String toString();
public boolean equals( Object obj );
public native int hashCode( );
protected native Object clone( )throws CloneNotSupportedException
protected void finalize()throws Throwable
public final native Class<?> getClass();
public final void wait( )throws InterruptedException
public final native void wait( long timeOut )throws InterruptedException
public final void wait( long timeOut, int nanos )throws InterruptedException
public final void notify();
public final void notifyAll();
Method(s) of [Link] interface
 void run( );
Nested type of [Link] class
[Link] is nested enum defined inside [Link] class.

package [Link];
public class Thread extends Object implements Runnable{
public static enum State{
NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED;
}
}

[Link] is nested functional interface defined inside

[Link] class.

package [Link];
public class Thread extends Object implements Runnable{
@FunctionalInterface
public static interface UncaughtExceptionHandler {
void uncaughtException(Thread t, Throwable e);
}
}

Fields of [Link] class

public static final int MIN_PRIORITY = 1; //Thread.MIN_PRIORITY
public static final int NORM_PRIORITY = 5; //Thread.NORM_PRIORITY
public static final int MAX_PRIORITY = 10; //Thread.MAX_PRIORITY
Constructor Summary of [Link] class:
public Thread();

Thread th = new Thread( );

public Thread(String name );

Thread th = new Thread( "User Thread-1" );

public Thread(Runnable target);

Runnable target = new Task();

Thread th = new Thread( target );
 public Thread(Runnable target, String name);

Runnable target = new Task();

Thread th = new Thread( target, "User Thread-1" );

public Thread(ThreadGroup group, Runnable target);

ThreadGroup group = new ThreadGroup("CDAC-Thread-Group");

Runnable target = new Task();
Thread th = new Thread( group, target );

public Thread(ThreadGroup, String name );

ThreadGroup group = new ThreadGroup("CDAC-Thread-Group");

Thread th = new Thread( group, "User Thread-1");

public Thread(ThreadGroup group, Runnable target, String name);

ThreadGroup group = new ThreadGroup("CDAC-Thread-Group");

Runnable target = new Task();
Thread th = new Thread( group, target, "User Thread-1");

public Thread(ThreadGroup group, Runnable targer, String name , long stackSize) ;

ThreadGroup group = new ThreadGroup("CDAC-Thread-Group");

Runnable target = new Task();
Thread th = new Thread( group, target, "User Thread-1", 0 );

In Java, we can create thread using [Link] class.

class Task extends Thread{

@Override
public void run() {
[Link]("Hello from run method");
}
}
public class Program {
public static void main(String[] args) {
Thread th = new Task( ); //Upcasting
[Link]();
 }
}

Method Summary of [Link] class

public static Thread currentThread()
public long getId()
public final String getName()
public final void setName(String name)
public final int getPriority()
public final void setPriority(int newPriority)
public [Link] getState()
public final ThreadGroup getThreadGroup()
public [Link] getUncaughtExceptionHandler()
public static void setDefaultUncaughtExceptionHandler([Link] eh)
public void interrupt()
public static boolean interrupted()
public boolean isInterrupted()
public final boolean isAlive()
public final boolean isDaemon()
public final void join() throws InterruptedException
public final void setDaemon(boolean on)
public static void sleep(long millis) throws InterruptedException
public static void yield()
Getting information of main thread

public static void main(String[] args) {

Thread thread = [Link]();
[Link]( [Link]() ); //Thread[main,5,main]
//main : thread's name
//5 : priority
//main : thread group.
}

public static void main(String[] args) {

Thread thread = [Link]();

String name = [Link]();

[Link]("Thread Name : "+name);

int priority= [Link]();

[Link]("Thread Priority : "+priority);

ThreadGroup group = [Link]();

[Link]("Thread Group : "+[Link]());
 State state = [Link]();
[Link]("Thread State : "+[Link]());

boolean type = [Link]();

[Link]("Thread Type : "+( type ? "Daemon Thread"
: "User Thread") );

boolean status = [Link]();

[Link]("Thread Status : "+( status ? "Alive" :
"Dead") );
}

Output is:

Thread Name : main

Thread Priority : 5
Thread Group : main
Thread State : RUNNABLE
Thread Type : User Thread
Thread Status : Alive

Getting information of garbage collector

class Sample{
public Sample( ) {
[Link]("Inside constructor of
"+[Link]().getSimpleName());
}
public void print( ) {
[Link]("Inside print method of
"+[Link]().getSimpleName());
}
@Override
protected void finalize() throws Throwable {
[Link]("Inside finalize method of
"+[Link]().getSimpleName());

Thread thread = [Link]();

String name = [Link]();

[Link]("Thread Name : "+name);

int priority= [Link]();

[Link]("Thread Priority : "+priority);

ThreadGroup group = [Link]();

[Link]("Thread Group : "+[Link]());

State state = [Link]();

 [Link]("Thread State : "+[Link]());

boolean type = [Link]();

[Link]("Thread Type : "+( type ? "Daemon
Thread" : "User Thread") );

boolean status = [Link]();

[Link]("Thread Status : "+( status ? "Alive" :
"Dead") );
}
}

public static void main1(String[] args) {

Sample sample = null;
sample = new Sample();
[Link]();
sample = null;
//[Link](); //or
[Link]().gc();
}

Output is

Thread Name : Finalizer

Thread Priority : 8
Thread Group : system
Thread State : RUNNABLE
Thread Type : Daemon Thread
Thread Status : Alive

What do you know about final/finally/finalize?

final
It is keyword, we can use with local variable, field, method and class.
If we use final modifier with method local variable and field then it is considered as
constant.
If we use final modifier with method then we can not override/redefine method inside sub
class
If we use final modiifer with class then we can not extend it.
finally
It is a block that we can use with try/catch.
If we want to close local resources then we should use finally block.

public static void main(String[] args) {

Scanner sc = null; //Method local variable
try{
 sc = new Scanner( [Link] );
//TODO
}catch( Exeption ex ){
[Link]();
}finally{
[Link](); //Releasing local resource
}
}

finalize
It is non final method of [Link] class.
If we want to release class level( which is declared as field ) resources then we should
use finalize method.

class Sample{
private Scanner sc; //Field
public Sample( ) {
[Link] = new Scanner( [Link]);
}
//TODO
@Override
protected void finalize() throws Throwable {
[Link]();
}
}
public class Program {
public static void main(String[] args) {
Sample sample = null;
sample = new Sample();
[Link]();
sample = null;
[Link]
}
}

Thread Creation in Java

In Java, we can create thread using 2 ways:
By implementing Runnable interface
By extending Thread class.
Thread Creation in by implementing Runnable interface
If we create Thread instance but do not call start() method on it then is considered in NEW state.

Runnable target = new Task(); //Upcasting

Thread th = new Thread(target); //NEW
To start execution of thread we should start() method.
If we call start() method on thread instance then thread is considered in RUNNABLE state.

Runnable target = new Task(); //Upcasting

Thread th = new Thread(target); //NEW
[Link](); //RUNNABLE

If we call start() method on already started thread then start() method throws
IllegalThreadStateException

Runnable target = new Task(); //Upcasting

Thread th = new Thread(target); //NEW
[Link](); //RUNNABLE
[Link](); //IllegalThreadStateException

When control come out of run method then thread gets terminated. In this case thread is considered
in TERMINATED state.
In following cases, control can come out of run method and thead can terminate:
Successful completion of run method.
Getting exception during execition of run method.
Execution of jump statement( return statement ) inside run method.
If we want to suspend execution of running thread then we should use sleep() method. It is a static
method of [Link] class.

public static void sleep(long millis) throws InterruptedException

millis - the length of time to sleep in milliseconds

1000 millisecond = 1 second
Usage:

[Link]( 250 )

Following methods calls are considered as blocking calls:

sleep()
suspend()
join()
wait()
Input operations in run method
Generally we should use blocking calls very carefully.
If we want to group functionally realated threads together then we should use ThreadGroup.

public static void main(String[] args) {

Runnable target = new Task();

ThreadGroup threadGroup = new ThreadGroup("acts");

Thread th1 = new Thread(threadGroup, target);

[Link]("User Thread#1");
[Link]();

Thread th2 = new Thread(threadGroup, target);

[Link]("User Thread#2");
[Link]();
}

Thread creation using Runnable

class Task implements Runnable{

private Thread thread;
public Task( String name ) {
[Link] = new Thread(this, name);
[Link]();
}

@Override
public void run() {
//TODO: Business Logic
}
}
public class Program {
public static void main(String[] args) {
Task th1 = new Task("User Thread#1");
Task th2 = new Task("User Thread#2");
}
}
 what is the relation between start and run method?

start() method do not call run() method.

If we call start() method on java thread instance then it is considered as request to the JVM to
get thread from operating system and to map it with java thread instance.
Schedular is responsible for picking thread from queue and assiging CPU to it. When schedular
assign CPU to the OS thread then JVM invoke run method on instance who has implemented
[Link] interface.
Thread Creation in by extending Thread class

class Task extends Thread{

public Task( String name ) {
super(name);
[Link]();
}
@Override
public void run() {
//TODO : Business logic
}
}
public class Program {
public static void main(String[] args) {
Task th1 = new Task("User Thread#1");
}
}

What will happen if we call run method instead of start method on thread instance
class Task extends Thread{
public Task( String name ) {
super( name );
}
@Override
 public void run() {
[Link]("Inside run method :
"+[Link]().getName());
}
}
public class Program {
public static void main(String[] args) {
Thread thread = new Task( "Thread#1");
//[Link](); //Inside run method : Thread#1
[Link]();//Inside run method : main
}
}

If we call start() method on thread instance then JVM starts execution of new Thread. But if we call
run() method on thread instance then JVM do not start execution of new Thread. In above code, main
therad is calling main method and main method is calling run() method. In directly main thread is
calling run() method.
What is the difference between creating thread using Runnable and Thread class
Runnable
Consider Thread creation using Runnable interface:

class A implements Runnable{

private Thread thread;
public A( ){
[Link] = new Thread( this);
[Link]();
}
@Override
public void run( ){
//TODO: Write business logic here
}
}

Here class can still extend another class.

Let us try to create sub class of class A

class B extends A{
public B( ){
}
@Override
public void run( ){
//TODO: Write business logic here
}
}
 class C extends B{
public C( ){
}
@Override
public void run( ){
//TODO: Write business logic here
}
}

class D extends C{
public D( ){
}
@Override
public void run( ){
//TODO: Write business logic here
}
}

If create instance of class B then first A class and then B class constructor will call. In class A, Thread
registration process will start and when OS thread will get CPU then B class run method will call.
Same is the case of class C and D. In simple words, If class implement Runnable interface then that
class and all its sub classes must participate in Threading behavior.
Thread
Consider Thread creation by extending Thread class:

class A extends Thread{

public A( ){
[Link]();
}
@Override
public void run( ){
//TODO: Write business logic here
}
}

In Java, class can extend more than one class. So here we can not extend another class / if
class already sub class of another class then we can not extend Thread.
Let us try to create sub class of class A

class B extends A{
public B( ){
}
 @Override
public void run( ){
//TODO: Write business logic here
}
}

class C extends B{
public C( ){
}
@Override
public void run( ){
//TODO: Write business logic here
}
}

class D extends C{
public D( ){
}
@Override
public synchronized void start() {
//Keep Empty
}
}

In above code class A, B and C must participate into Threading behavior. But by overriding
start( ) method class D can come out of threading behavior.
Types of Thread in java:
User Thread
It is also called as non daemon thread.
If we create any thread from main method / another user thread then it is by default considered
as user thread.
Default Properties of main thead:
Type: User Thread
Priority: 5
Thread group: main
Daemon Thread
It is also called as background thread.
If we create any thread from finalze method / another deamon thread then it is by default
considered as daemon thread.
Default Properties of GC thead:
Type: Daemon Thread
Priority: 8
Thread group: system
 Using "public final boolean isDaemon()" method we can check type of thread.
Using "public final void setDaemon(boolean on)" method we can marks thread as either a daemon
thread or a user thread.

Thread th = new Thread( target, name );

[Link]( true ); //Not thread will be considered as Daemon
thread.
[Link]();

What is the difference between User Thread and Daemon Thread

User threads have higher priority than daemon threads, which means that the JVM will keep them
running as long as the application is running. Daemon threads, on the other hand, have lower priority,
and the JVM will stop them as soon as all user threads have terminated.

interrupt() / interrupted() / isInterrupted()

An interrupt() is a notification sent to a thread to request that it should stop what it's doing and do
something else.

public void interrupt()

class Task implements Runnable {

@Override
public void run() {
for (int count = 1; count <= 100; ++count) {
[Link]("Count : " + count);
if( count == 50 )
 [Link]().interrupt();
}
}
}

When the interrupt signal is sent to the thread, it will set an interrupted flag on the thread. We can
check that flag using isInterrupted() method.

public boolean isInterrupted();

for (int count = 1; count <= 100; ++count) {

if( ![Link]().isInterrupted()) {
[Link]("Count : " + count);
if( count == 50 ) {
[Link]().interrupt();
}
}
}

isInterrupted() method only check interrupted status but do not reset the status.
Using interrupted() method we can check interrupted status but it reset interrupted status. In other
words, if this method were to be called twice in succession, the second call would return false

public static boolean interrupted()

class Task implements Runnable {

@Override
public void run() {
for (int count = 1; count <= 100; ++count) {
if (![Link]().isInterrupted()) {
[Link]("Count : " + count);
if (count == 50) {
[Link]().interrupt();
}
}
}

while (![Link]()) {
for (int count = 100; count <= 120; ++count)
[Link]("Count : " + count);
}
}
}
 public class Program {
public static void main(String[] args) throws Exception {
Thread thread = new Thread(new Task());
[Link]();
}
}

Thread Priority
OS schedular is responsible for assigning CPU to the thread.
On the basis of thread priority schedular assign CPU to the thread.
Thread priorities of Java and OS are different.
Thread priorities in Java:
Thread.MIN_PRIORITY = 1;
Thread.NORM_PRIORITY = 5;
Thread.MAX_PRIORITY = 10;
How will you read thread priority in Java?

public static void main(String[] args) {

Thread thread = [Link]();
int priority = [Link]();
[Link]("Priority of "+[Link]()+" is
"+priority);
}

How will you set thread priority in Java?

public static void main(String[] args) {

Thread thread = [Link]();
[Link]([Link]() + 2);
[Link]("Priority of "+[Link]()+" is
"+[Link]());
//Priority of main is 7
}

public static void main(String[] args) {

Thread thread = [Link]();
[Link]([Link]() + 6);
//IllegalArgumentException
[Link]("Priority of "+[Link]()+" is
"+[Link]());
}
 Default priority of any thread depends on priority of its parent thread.
Consider following code:

class Task implements Runnable{

private Thread thread;
public Task(){
[Link] = new Thread( this );
[Link]( Thread.MAX_PRIORITY); //OK
[Link]();
}
public void run( ){
//TODO
}
}

If we set priority of a thread in Java then OS map it differently on differnt system. Hence Same Java
application produces different behavior on different OS.
Which features of Java makes Java application platform dependent:
Abstract Window Toolkit(AWT) Components
AWT components implicitly use peer classes and these classes has been written into
C++ which are OS specific.
Thread priorities
Thread Join
If we call join method on thread instance then it blocks execution of all other threads
 Consider following code:

class Task extends Thread{

public Task( String name ) {
super( name );
[Link]();
}
@Override
public void run() {
[Link]("Start of run method");
try {
for( int count = 1; count <= 10; ++ count ) {
[Link]([Link]()+" : Count : "+count);
[Link](250);
}
} catch (InterruptedException cause) {
throw new RuntimeException( cause );
}
[Link]("End of run method");
}
}
public class Program {
public static void main(String[] args) throws InterruptedException
{
Thread th1 = new Task("Thread#01");
[Link]();

Thread th2 = new Task("Thread#02");

[Link]();

Thread th3 = new Task("Thread#03");

[Link]();

Thread th4 = new Task("Thread#04");

[Link]();

Thread th5 = new Task("Thread#05");

[Link]();
}
}

Race Condition
A race condition is a situation that occurs in a concurrent system when two or more threads or
processes access a shared resource or variable in an uncontrolled order, resulting in unpredictable
and often incorrect behavior.
To prevent race conditions, concurrency control mechanisms such as locks, semaphores, and
monitors can be used to ensure that only one thread at a time can access and modify a shared
resource.
In Java,we can use synchronized keyword with block/method to avoid race condition.
 If threads are waiting to get monitor object associated with shared resource then it is consider in
BLOCKED state.

Inter Thread Communication

Synchronization is the process of controlling the access of multiple threads to a shared resource.
Inter-thread communication is a mechanism that allows threads in a multi-threaded application to
communicate with each other and coordinate their actions.

In Java, inter-thread communication is achieved using the wait(), notify() and notifyAll() methods,
which are defined in the Object class.
wait() : This method causes the current thread to wait until another thread invokes the notify()
or notifyAll() method for the same object. The thread will release the lock it holds on the object
and wait until it's notified by another thread.
notify() : This method wakes up a single thread that is waiting on the object. If there are
multiple threads waiting, only one thread will be awakened. The awakened thread will not be
 able to proceed until it regains the lock on the object.
notifyAll() : This method wakes up all the threads that are waiting on the object. All the threads
will then compete for the lock on the object.
The JVM throws the IllegalMonitorStateException when a thread attempts to call the wait(), notify(),
or notifyAll() methods on an object without holding the object's monitor.

class TickTock{
public void tick() throws InterruptedException {
synchronized( this ) {
[Link]("Tick ");
[Link]();
[Link]( 1000 ); //To avoid deadlock pass time
}
}
public void tock() throws InterruptedException {
synchronized( this ) {
[Link](" Tock");
[Link]();
[Link]( 1000 ); //To avoid deadlock pass time
}
}
}

class Task implements Runnable{

Thread thread;
public Task( String name) {
[Link] = new Thread(this, name);
[Link]();
}
private static TickTock tt = new TickTock();
@Override
public void run() {
try {
if( [Link]().getName().equals("TickThread")) {
for( int count = 1; count <= 5; ++ count ) {
[Link]();
[Link](250);
}
}else {
for( int count = 1; count <= 5; ++ count ) {
[Link]();
[Link](250);
}
}
} catch (InterruptedException cause) {
throw new RuntimeException( cause );
}
}
}
 public class Program {
public static void main(String[] args)throws Exception{
Task t1 = new Task("TickThread");

Task t2 = new Task("TockThread");

}
}

Why wait/notify/notifyAll methods are declared in [Link] class?

The wait(), notify(), and notifyAll() methods are designed to work with monitors, which are associated
with objects rather than threads.
When a thread calls wait() on an object, it releases the monitor associated with that object and enters
a waiting state until another thread notifies it by calling notify() or notifyAll() on the same object.
Therefore, it makes sense for these methods to be declared in the [Link] class.

public class Program {

public void print( String str ) throws InterruptedException {
synchronized( this ) {
[Link](str);
//[Link](1000); //IllegalMonitorStateException
[Link]( 1000 );
}
}
public static void main(String[] args)throws Exception{
Program p = new Program();
[Link]("Hello");
}
}

The Producer-Consumer problem

It is a classic synchronization problem in computer science where there are two threads - a producer
and a consumer - sharing a common resource.
Consider a problem can be seen in a fast-food restaurant's kitchen:
the kitchen is the common resource
the chef is the producer who produces the food
waiter is the consumer who serves the food to the customers.
We will try to solve this problem using synchronization mechanisms like wait(), notify(), and
notifyAll().
Consider code for Kitchen class:
 import [Link];
public class Kitchen {
private LinkedList<String> orders = new LinkedList<>();
private int maxOrders = 10;

public synchronized void addOrder(String order) throws

InterruptedException {
while ([Link]() == maxOrders) {
wait();
}
[Link](order);
[Link]("Order added: " + order);
notifyAll();
}

public synchronized String getOrder() throws InterruptedException {

while ([Link]() == 0) {
wait();
}
String order = [Link]();
[Link]("Order removed: " + order);
notifyAll();
return order;
}
}

Consider code for Chef class:

public class Chef implements Runnable {

private Kitchen kitchen;

public Chef(Kitchen kitchen) {

[Link] = kitchen;
}

@Override
public void run() {
try {
while (true) {
String order = "Burger"; // produce food
[Link](order);
[Link](1000);
}
} catch (InterruptedException e) {
[Link]();
}
}
}

Consider code for Waiter class:

 public class Waiter implements Runnable {
private Kitchen kitchen;
public Waiter(Kitchen kitchen) {
[Link] = kitchen;
}

@Override
public void run() {
try {
while (true) {
String order = [Link]();
serve(order); // consume food
[Link](1000);
}
} catch (InterruptedException e) {
[Link]();
}
}
private void serve(String order) {
[Link]("Serving " + order);
}
}

Consider code for Waiter class:

public class Restaurant {

public static void main(String[] args) {
Kitchen kitchen = new Kitchen();
Thread chefThread = new Thread(new Chef(kitchen));
Thread waiterThread = new Thread(new Waiter(kitchen));
[Link]();
[Link]();
}
}

Volatile Fields:
Computers with multiple processors can temporarily hold memory values in registers or local memory
caches. As a consequence, threads running in different processors may see different values for the
same memory location.

Consider following code:

class SharedInstance{
int counter = 0;
}

Here we assume that there are two threads are working on SharedInstance.
If these two threads run on different processors then each thread will have its own local copy
of counter.
If we modifies value of one thread, then its value might not reflect in the original one in the
main memory instantly. It is totally depends on the write policy of cache.
Now the other thread is not aware of the modified value which leads to data inconsistency.

If the counter variable is not declared volatile there is no guarantee about when the value of the
counter variable is written from the CPU cache back to main memory. This means, that the
counter variable value in the CPU cache may not be the same as in main memory.
volatile is a keyword in Java which is applicable only for fields.

Access_Modifier volatile Data_Type variableName;

 volatile keyword in Java guarantees that value of the volatile variable will always be read from main
memory and not from Thread's local cache.
The volatile keyword tells the computer that a variable may be accessed by multiple threads at the
same time. This means that any changes made to the variable are immediately visible to all other
threads. It works like a special type of variable that is shared among all threads and stored in main
memory, so every time a thread wants to access it, it reads the updated value from main memory and
writes any changes directly back to main memory. Any change to a volatile variable is visible to all
other threads immediately after it happens.
Thread life cycle:
[Link] is nested enum declared in [Link] class.

public enum State {

NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED;
}

Accessing enum in Java

 The life cycle of a thread in Java consists of several states, which are as follows:

A thread can be in only one state at a given point in time.

These states are virtual machine states which do not reflect any operating system thread states.
New: The thread is in the new state when it is created but has not yet started executing. The
thread remains in this state until the start() method is called.
Runnable: The thread is in the runnable state when it is ready to run, but the thread scheduler
has not selected it to run yet. When the thread scheduler selects the thread, it moves to the
running state.
Running: The thread is in the running state when its run() method is being executed.
Blocked: The thread is in the blocked state when it is waiting for a monitor lock to be released,
so it can enter a synchronized block or method.
Waiting: The thread is in the waiting state when it is waiting for some other thread to perform a
particular action before it can continue executing.
Timed Waiting: The thread is in the timed waiting state when it is waiting for a specific amount
of time for some other thread to perform a particular action before it can continue executing.
Terminated: The thread is in the terminated state when its run() method has completed
execution.
String Handling
 Consider String in C/C++ language:

"DAC";
//{'D','A','C','\0'}

In Java, String is collection of character instances which do not end with '\0' character.
If we want to manipulate String in Java then we can use following classes:
[Link]
[Link]
[Link]
[Link]
[Link]
[Link]
[Link]
[Link]

public final class String

extends Object
implements Serializable, Comparable<String>, CharSequence

String is final class declared in [Link] package.

It is sub class of [Link] class and it implements Serializable, Comparable, CharSequence
In Java, String is not primitive data type. Since it is a class, it is considered as non primitive /
reference type.
Even though String is non primitive type, we can create its instance with and without new operator.

String s1 = new String("CDAC");

//s1 : String reference
//new String("CDAC"); : String instance

If we create String instance using new operator then it gets space on heap section.

String s1 = "CDAC";
//s1 : String reference
//"CDAC" : String literal

If we create String without new operator the it gets space on String literal on method area.
 String s1 = "CDAC";
//char[] data = {'C','D','A','C'};
//String s1 = new String( data );

In Java, String do not ends with '\0' character. Using illegal index, if we try to access character from
String then String methods throws StringIndexOutofBoundsException.

public static void main(String[] args){

String str = "CDAC";
char ch = [Link](4); //StringIndexOutOfBoundsException
}

Strings are constant; their values cannot be changed after they are created. In other words, String
instances are immutable.
Consider following code:

String str = "CDAC,";

str = str + "ACTS";
[Link]( str ); //CDAC,ACTS
 public static void main(String[] args) {
String s1 = "CDAC,";
[Link]("ACTS");
[Link](s1); //CDAC,

[Link]([Link]("ACTS")); //CDAC,ACTS

String s2 = [Link]("ACTS");
[Link](s2); //CDAC,ACTS
}

The Java language provides special support for the string concatenation operator ( + ), and for
conversion of other objects to strings.
Using + operator, we can contact any(primitive/non primitive) value to the String but using
concat method we can concat onluy String.

int number = 123;

String s1 = "Number : "+number;
String s2 = "Date : "+new Date();

int number = 123;

String s1 = "Number : ".conact( number ); //Compiler error
String s1 = "Number : ".conact( [Link](number) ); //OK
Constructor Summary of String class
public String()

String s1 = new String();

public String(byte[] bytes)

byte[] bs = new byte[ ]{ 65, 66, 67 };

String s1 = new String( bs ); //ABC

public String(char[] value)

char[] data = new char[ ]{ 'A','B','C'};

String s1 = new String( data ); //ABC

public String(String original)

String s1 = new String("ABC");

public String(StringBuffer buffer)

StringBuffer buffer = new StringBuffer("CDAC");

String s1 = new String( buffer );

public String(StringBuilder builder)

StringBuilder builder = new StringBuilder("ACTS");

String s1 = new String( builder );

Method Summary of String class:

public char charAt(int index)
public String concat(String str)
public boolean contains(CharSequence s)
public boolean equalsIgnoreCase(String anotherString)
public static String format(String format, Object... args)
public byte[] getBytes()
public int indexOf(int ch)
public int lastIndexOf(int ch)
 public int indexOf(String str)
public int lastIndexOf(String str)
public String intern()
public int length()
public boolean matches(String regex)
public String[] split(String regex)
public boolean startsWith(String prefix)
public boolean endsWith(String suffix)
public char[] toCharArray()
public String toUpperCase()
public String toLowerCase()
public String trim()
public static String valueOf(Object obj)
String twisters

public class Program {

public static void main(String[] args){
String s1 = new String("CDAC");
String s2 = new String("CDAC");
if( s1 == s2 )
[Link]("Equal");
else
[Link]("Not Equal");
//Output: Not Equal
}
}
public static void main(String[] args){
String s1 = new String("CDAC");
String s2 = new String("CDAC");
if( [Link](s2) )
[Link]("Equal");
else
[Link]("Not Equal");
//Output: Equal
}

public static void main(String[] args){

String s1 = "CDAC";
String s2 = new String("CDAC");
if( s1 == s2 )
[Link]("Equal");
else
[Link]("Not Equal");
//Output: Not Equal
}

public static void main(String[] args){

String s1 = "CDAC";
String s2 = new String("CDAC");
if( [Link](s2))
[Link]("Equal");
else
[Link]("Not Equal");
 //Output: Equal
}

public static void main(String[] args){

String s1 = "CDAC";
String s2 = "CDAC";
if( s1 == s2 )
[Link]("Equal");
else
[Link]("Not Equal");
//Output: Equal
}

public static void main(String[] args){

String s1 = "CDAC";
String s2 = "CDAC";
if( [Link](s2) )
[Link]("Equal");
else
[Link]("Not Equal");
//Output: Equal
}

public static void main(String[] args) {

String s1 = "CDAC,"+"ACTS";
//String s1 = "CDAC,ACTS";
String s2 = "CDAC,ACTS";
if( s1 == s2 )
[Link]("Equal");
else
[Link]("Not Equal");
 //Output: Equal
}

Constant expressions always gets evaluated at compile time. Hence "CDAC,"+"ACTS" will be
considered as "CDAC,ACTS" at compile time.

public static void main(String[] args) {

String s1 = "CDAC,"+"ACTS";
//String s1 = "CDAC,ACTS";
String s2 = "CDAC,ACTS";
if( [Link](s2) )
[Link]("Equal");
else
[Link]("Not Equal");
//Output: Equal
}

public static void main(String[] args) {

String s1 = "CDAC,ACTS";
String str = "ACTS";
String s2 = "CDAC,"+str;

if( s1 == s2 )
[Link]("Equal");
else
[Link]("Not Equal");
//Output: Not Equal
}
public static void main(String[] args) {
String s1 = "CDAC,ACTS";
String str = "ACTS";
String s2 = "CDAC,"+str;

if( [Link](s2) )
[Link]("Equal");
else
[Link]("Not Equal");
//Output: Equal
}

public static void main(String[] args) {

String s1 = "CDAC,ACTS";
String str = "ACTS";
String s2 = ( "CDAC,"+str ).intern();

if( s1 == s2 )
[Link]("Equal");
else
[Link]("Not Equal");
//Output: Equal
}
 intern() method returns reference of the String from String pool.

public static void main(String[] args) {

String s1 = "CDAC,ACTS";
String str = "ACTS";
String s2 = ( "CDAC,"+str ).intern();

if( [Link](s2) )
[Link]("Equal");
else
[Link]("Not Equal");
//Output: Equal
}

A Strategy for Defining Immutable Objects

Don't provide "setter" methods — methods that modify fields or objects referred to by fields.
Make all fields final and private.
Don't allow subclasses to override methods. The simplest way to do this is to declare the class as
final.
If the instance fields include references to mutable objects, don't allow those objects to be changed
Reference: [Link]
Day 21
Collection Framework
Consider following example:

class Date{ }
class Addresss{ }
class Person{
private String name = new String();
private Date birthDate = new Date();
private Address currentAddress = new Address();
}
class Program{
public static void main(String[] args) {
Person p = new Person( );
}
}

In Java, instance do not get space inside another instance. Rather instance contains reference of
another instance.

Library
In Java, .jar file is a library file.
It can contain, menifest file, resources, packages.
Package can contain sub package, interface, class, enum, exception, error, annotation types
Example: [Link]
Framework
framework = collection of libraries + tools + rules/guidelines
It is a development platform which contain reusable partial code on the top of it we can develop
application.
Examples:
 JUnit: Unit testing framework which is used to write test case.
Apache Log4j2: Logging framework which is used to record activities.
AWT/Swing/Java-FX: GUI framework.
JNI: Framework to access native code
Struts: Readymade MVC based web application framework.
Hibernate: ORM based automatic persistence framework
Spring: Enterprise framework
Collection
Any instance which contains multiple elements is called as collection.
In java, data structure is also called as collection.
Collection Framework
Collection framework is a library of data structure classes on the top of it we can develop Java
application.
In Java, collection framework talk about use not about implementation.
In Java, when we use collection to store instance then it doesnt contain instance rather it contains
reference of the instance.
To use collection framework, we should import [Link] package.

Iterable
It is interface declared in [Link] package.
It is introduced in jDK 1.5.
Implementing this interface allows an object to be the target of the "for-each loop" statement.
Methods:
Iterator iterator()
default Spliterator spliterator()
default void forEach(Consumer<? super T> action)
Collection
Reference: [Link]
Value stored inside any collection( Array, Stack, Queue, LinkedList etc.) is called as element.
It is interface declared in [Link] package.
It is root interface in the collection framework interface hierarchy.
The JDK does not provide any direct implementations of Collection interface.
Direct implementation classes of Collection interface are AbstractList, AbstractQueue, AbstractSet.
List, Queue, Set are sub interfaces of [Link] interface.
Abstract methods of [Link] interface:
boolean add(E e)
boolean addAll(Collection<? extends E> c)
void clear()
boolean contains(Object o)
boolean containsAll(Collection<?> c)
boolean isEmpty()
boolean remove(Object o)
boolean removeAll(Collection<?> c)
boolean retainAll(Collection<?> c)
int size()
Object[] toArray()
T[] toArray(T[] a)
Default methods of [Link] interface:
default Stream stream()
default Stream parallelStream()
default boolean removeIf(Predicate<? super E> filter)
List

This interface is a member of the Java Collections Framework and introduced in JDK 1.2
 It is sub interface of Collection interface. It means that all the methods of Collection interafce will be
inherited into List interface.
Direct implementation classes of List interfaces are AbstractList, ArrayList, Vector, Stack, LinkedList.
These collection classes are called as List collections.
Inside List collection we can store data in sequential fashion.
We can store duplicate elements inside any List collection.
We can store multiple null values inside List collection.
With the help of integer index, we can access elements from List collection.
We can traverse elements of any List collection using Iterator as well as ListIterator.
This interface is a member of the Java Collections Framework.
Abstract methods of [Link] interface:
void add(int index, E element)
boolean addAll(int index, Collection<? extends E> c)
E remove(int index)
E get(int index)
E set(int index, E element)
int indexOf(Object o)
int lastIndexOf(Object o)
ListIterator listIterator()
ListIterator listIterator(int index)
List subList(int fromIndex, int toIndex)
Default methods of [Link] interface:
default void sort(Comparator<? super E> c)
default void replaceAll(UnaryOperator operator)
Note: If we want to manage elements of non final type inside any List collection then we should
override at least equals methods inside non final type.
ArrayList
Array is collection of fixed elements. ArrayList is resizeable array.
Implementation of ArrayList is based of array.
ArrayList is List collection.
Since ArrayList is List collection we can store elements sequentially.
Since ArrayList is List collection, we can store duplicate elements as well as null elements inside
ArrayList.
Since ArrayList is List collection, we can access its elements using integer index.
Since ArrayList is List collection, we can traverse its elements using Iterator as well as ListIterator.
ArrayList implementation is unsynchronized. Using [Link]() method we can
make it synchronized.
If ArrayList is full then its capacity gets increased by half of existing capacity.
This class is a member of the Java Collections Framework and introduced in JDK 1.2.
Constructor Summary of ArrayList class:
public ArrayList()

ArrayList<Intger> list = new ArrayList();

public ArrayList(int initialCapacity)

ArrayList<Intger> list = new ArrayList( 15 );

public ArrayList(Collection<? extends E> c)

Collection<Integer> c = new ArrayList<>( );

[Link]( 10 );
[Link]( 20 );
[Link]( 30 );

ArrayList<Integer> list = new ArrayList<>( c );

Method Summary of ArrayList class:

public void ensureCapacity(int minCapacity)
protected void removeRange(int fromIndex, int toIndex)
public void trimToSize()
Instantiation:
 public static void main(String[] args){
Collection<Integer> collection = new ArrayList<>(); //OK:
Upcasting
List<Integer> list = new ArrayList<>(); //OK: Upcasting
ArrayList<Integer> arrayList = new ArrayList<>(); //OK
}

How to add single element inside ArrayList?

public static void main(String[] args) {

List<Integer> list = new ArrayList<>();
[Link](10);
[Link](20);
[Link](40);
[Link](50);
[Link](2, 30);
[Link]( [Link]());
}

public static List<Integer> getList( ){

List<Integer> list = new ArrayList<>();
[Link](10);
[Link](20);
[Link](30);
[Link](40);
[Link](50);
return list;
}
public static void main(String[] args) {
List<Integer> list = [Link]();
[Link]( [Link]()); //[10, 20, 30, 40, 50]
}

public static List<Integer> getList( ){

List<Integer> list = new ArrayList<>();
[Link](10);
[Link](20);
[Link](30);
[Link](40);
[Link](50);
return list;
}
public static void main(String[] args) {
List<Integer> list = [Link]();
Integer element = null;
for( int index = 0; index < [Link](); ++ index ) {
 element = [Link]( index );
[Link](element);
}
}

public static List<Integer> getList( ){

List<Integer> list = new ArrayList<>();
[Link](10);
[Link](20);
[Link](30);
[Link](40);
[Link](50);
return list;
}
public static void main(String[] args) {
int[] arr = new int[ ] { 10, 20, 30 };
//int element = arr[ [Link] ];
//ArrayIndexOutOfBoundsException

String str = "CDAC";

//char ch = [Link]([Link]());
//StringIndexOutOfBoundsException

List<Integer> list = [Link]();

Integer element = [Link]( [Link]() );
//IndexOutOfBoundsException
}

public static List<Integer> getList( ){

List<Integer> list = new ArrayList<>();
[Link](10);
[Link](20);
[Link](30);
[Link](40);
 [Link](50);
return list;
}
public static void main(String[] args) {
List<Integer> list = [Link]();
Integer element = null;
Iterator<Integer> itr = [Link]();
while( [Link]()) {
element = [Link]();
[Link](element);
}
}

public static List<Integer> getList( ){

List<Integer> list = new ArrayList<>();
[Link](10);
[Link](20);
[Link](30);
[Link](40);
[Link](50);
return list;
}
public static void main(String[] args) {
List<Integer> list = [Link]();
for( Integer element : list )
[Link]( element );
}

public static void main(String[] args) {

List<Integer> list = [Link]();
/* Consumer<Integer> action = [Link]::println;
[Link](action); */
[Link]( [Link]::println );
}

public static List<Integer> getList( ){

List<Integer> list = new ArrayList<>();
[Link](10);
[Link](20);
[Link](30);
[Link](40);
[Link](50);
return list;
}
public static void main(String[] args) {
List<Integer> list = [Link]();
ListIterator<Integer> itr = [Link]();
 Integer element = null;
while( [Link]()) {
element = [Link]();
[Link]( element+" ");
}
[Link]();
while( [Link]()) {
element = [Link]();
[Link]( element+" ");
}
}

//Object[] elementData;
private static int capacity(List<Integer> list) throws Exception{
Class<?> c = [Link]();
Field field = [Link]("elementData");
[Link](true);
Object[] elementData = (Object[]) [Link](list);
return [Link];
}
public static void main(String[] args) {
try {
List<Integer> list = [Link]();
[Link]("Size : "+[Link]()); //5

int capacity = [Link]( list );

[Link]("Capacity : "+capacity);
} catch (Exception e) {
[Link]();
}
}

How to add multiple elements inside ArrayList?

public static void main(String[] args){

Collection<Integer> collection = new ArrayList<>();
[Link](30);
[Link](40);
[Link](50);

//List<Integer> list = new ArrayList<>( collection ); //OK

List<Integer> list = new ArrayList<>( );
[Link](10);
[Link](20);
[Link](collection);
[Link](list);
}
 public static void main(String[] args) {
Collection<Integer> collection = new ArrayList<>();
[Link](30);
[Link](40);
[Link](50);

List<Integer> list = new ArrayList<>( );

[Link](10);
[Link](20);
[Link](60);
[Link](70);
[Link](2, collection);
[Link](list);
}

How will you search single element inside ArrayList?

public static List<Integer> getList( ){

List<Integer> list = new ArrayList<>();
for( int count = 1; count <= 10; ++ count )
[Link]( count * 10 );
return list;
}
public static void main(String[] args) {
List<Integer> list = [Link](); //[10, 20, 30, 40, 50, 60,
70, 80, 90, 100]
Integer key = new Integer(500);
if( [Link](key)) {
int index = [Link](key);
[Link]( key+" found at index : "+index);
}else
[Link](key+" not found.");
}

How will you search and remove multiple elements

public static List<Integer> getList( ){

List<Integer> list = new ArrayList<>();
for( int count = 1; count <= 10; ++ count )
[Link]( count * 10 );
return list;
}
public static void main(String[] args) {
List<Integer> list = [Link](); //[10, 20, 30, 40, 50, 60,
70, 80, 90, 100]
Collection<Integer> keys = new ArrayList<>( );
[Link](30);
[Link](50);
[Link](70);
 if( [Link](keys)) {
[Link](keys); //[10, 20, 40, 60, 80, 90, 100]
//[Link](keys); //[30, 50, 70]
[Link]( list );
}else
[Link](keys+" not found.");
}

How will you search and remove single element from ArrayList?

public static List<Integer> getList( ){

List<Integer> list = new ArrayList<>();
for( int count = 1; count <= 10; ++ count )
[Link]( count * 10 );
return list;
}
public static void main(String[] args) {
List<Integer> list = [Link](); //[10, 20, 30, 40, 50, 60,
70, 80, 90, 100]
Integer key = new Integer(50);
if( [Link](key)) {
//[Link](key);
int index = [Link](key);
[Link](index);
[Link]( list ); //[10, 20, 30, 40, 60, 70, 80, 90,
100]
}else
[Link](key+" not found.");
}

How will you sort ArrayList?

public static void main(String[] args) {

List<Integer> list = new ArrayList<>();
[Link](50);
[Link](10);
[Link](30);
[Link](20);
[Link](40);

[Link](list); //[50, 10, 30, 20, 40]

//[Link]( list );
[Link](null);
[Link](list); //[10, 20, 30, 40, 50]
}

How will you convert ArrayList into array?

 public static void main(String[] args) {
List<Integer> list = new ArrayList<>();
[Link](50);
[Link](10);
[Link](30);
[Link](20);
[Link](40);

//Object[] arr = [Link]();

Integer[] arr = new Integer[ [Link]() ];

[Link](arr);

[Link]( [Link](arr)); //[50, 10, 30, 20, 40]

}

Using [Link]() method

public static void main(String[] args) {

List<Integer> list = [Link](10, 20, 30, 40, 50 );
[Link]( [Link]().getName());
//[Link]$ArrayList
[Link]( list ); //[10, 20, 30, 40, 50]
}

Which collection classes are by default synchronized in Java?

 [Link]
[Link]
[Link]
[Link]
Vector

Vector is a class declared in [Link] package.

Vector is List collection whose implementation is based on array.
Since Vector is List collection, it is ordered/sequential collection.
Since Vector is List collection, it can contain duplicate elements as well as null elements
Since Vector is List collection, we can traverse its elements using Iterator as well as ListIterator.
We can traverse elements of Vector using [Link] , [Link] as well as
ListIterator.
Vector is Synchronized collection.
Default capacity is 10 elements. Once Vector is full it gets double capacity.
It was introduced in JDK 1.0. Hence it is also called as legacy class.
Travsering using Enumeration
Enumeration is interface declared in [Link] package.
It was introduced in JDK 1.0.
Methods of Enumeration I/F:
 boolean hasMoreElements()
E nextElement()
Using Enumeration we can traverse limited collections. For Example: Vector, Hashtable etc.
Using Enumeration, we can traverse collection only forward direction. During traversing we can not
add, set or remove elements from underlying collection.

public static void main(String[] args){

Vector<Integer> v = new Vector<>();
for( int count = 1; count <= 10; ++ count )
[Link](count);

Integer element = null;

Enumeration<Integer> e = [Link]() ;
while( [Link]()) {
element = [Link]();
[Link](element);
}
}

Travsering using Iterator

Iterator is interface declared in [Link] package.
This interface is a member of the Java Collections Framework.
Methods of Iterator interface:
boolean hasNext()
boolean hasNext()
default void remove()
default void forEachRemaining(Consumer<? super E> action)
Iterator takes the place of Enumeration in the Java Collections Framework. Iterators differ from
enumerations in two ways:
Iterators allow the caller to remove elements from the underlying collection during the iteration.
Method names have been improved.

public static void main(String[] args){

Vector<Integer> v = new Vector<>();
for( int count = 1; count <= 10; ++ count )
[Link](count);

Integer element = null;

Iterator<Integer> itr = [Link]();
while( [Link]()) {
element = [Link]();
[Link](element);
 }
}

Travsering using ListIterator

It is subinterface of Iterator interface which is declared in [Link] package.
We can use it to traverse only List collections( ArrayList, Vector, Stack, LinkedList etc.)
We can use ListIterator to traverse collection in bidirection. During travsering, using iterator we can
add/set/remove element from collection.
Method Summary
void add(E e)
void set(E e)
void remove()
boolean hasNext()
E next()
boolean hasPrevious()
E previous()
int nextIndex()
int nextIndex()
This interface is a member of the Java Collections Framework.
It is introduced in JDK 1.2

public static void main(String[] args){

Vector<Integer> v = new Vector<>();
for( int count = 1; count <= 10; ++ count )
[Link](count);

Integer element = null;

ListIterator<Integer> itr = [Link]();
//ListIterator<Integer> itr = [Link]( 4 );
//ListIterator<Integer> itr = [Link]( [Link]() );
while( [Link]()) {
element = [Link]();
[Link](element+" ");
}
[Link]();
while( [Link]()) {
element = [Link]();
[Link](element+" ");
}
}
Day 22
Collection Framework
Consider following example:

class Date{ }
class Addresss{ }
class Person{
private String name = new String();
private Date birthDate = new Date();
private Address currentAddress = new Address();
}
class Program{
public static void main(String[] args) {
Person p = new Person( );
}
}

In Java, instance do not get space inside another instance. Rather instance contains reference of
another instance.

Library
In Java, .jar file is a library file.
It can contain, menifest file, resources, packages.
Package can contain sub package, interface, class, enum, exception, error, annotation types
Example: [Link]
Framework
framework = collection of libraries + tools + rules/guidelines
It is a development platform which contain reusable partial code on the top of it we can develop
application.
Examples:
 JUnit: Unit testing framework which is used to write test case.
Apache Log4j2: Logging framework which is used to record activities.
AWT/Swing/Java-FX: GUI framework.
JNI: Framework to access native code
Struts: Readymade MVC based web application framework.
Hibernate: ORM based automatic persistence framework
Spring: Enterprise framework
Collection
Any instance which contains multiple elements is called as collection.
In java, data structure is also called as collection.
Collection Framework
Collection framework is a library of data structure classes on the top of it we can develop Java
application.
In Java, collection framework talk about use not about implementation.
In Java, when we use collection to store instance then it doesnt contain instance rather it contains
reference of the instance.
To use collection framework, we should import [Link] package.

Iterable
It is interface declared in [Link] package.
It is introduced in jDK 1.5.
Implementing this interface allows an object to be the target of the "for-each loop" statement.
Methods:
Iterator iterator()
default Spliterator spliterator()
default void forEach(Consumer<? super T> action)
Collection
Reference: [Link]
Value stored inside any collection( Array, Stack, Queue, LinkedList etc.) is called as element.
It is interface declared in [Link] package.
It is root interface in the collection framework interface hierarchy.
The JDK does not provide any direct implementations of Collection interface.
Direct implementation classes of Collection interface are AbstractList, AbstractQueue, AbstractSet.
List, Queue, Set are sub interfaces of [Link] interface.
Abstract methods of [Link] interface:
boolean add(E e)
boolean addAll(Collection<? extends E> c)
void clear()
boolean contains(Object o)
boolean containsAll(Collection<?> c)
boolean isEmpty()
boolean remove(Object o)
boolean removeAll(Collection<?> c)
boolean retainAll(Collection<?> c)
int size()
Object[] toArray()
T[] toArray(T[] a)
Default methods of [Link] interface:
default Stream stream()
default Stream parallelStream()
default boolean removeIf(Predicate<? super E> filter)
List

This interface is a member of the Java Collections Framework and introduced in JDK 1.2
 It is sub interface of Collection interface. It means that all the methods of Collection interafce will be
inherited into List interface.
Direct implementation classes of List interfaces are AbstractList, ArrayList, Vector, Stack, LinkedList.
These collection classes are called as List collections.
Inside List collection we can store data in sequential fashion.
We can store duplicate elements inside any List collection.
We can store multiple null values inside List collection.
With the help of integer index, we can access elements from List collection.
We can traverse elements of any List collection using Iterator as well as ListIterator.
This interface is a member of the Java Collections Framework.
Abstract methods of [Link] interface:
void add(int index, E element)
boolean addAll(int index, Collection<? extends E> c)
E remove(int index)
E get(int index)
E set(int index, E element)
int indexOf(Object o)
int lastIndexOf(Object o)
ListIterator listIterator()
ListIterator listIterator(int index)
List subList(int fromIndex, int toIndex)
Default methods of [Link] interface:
default void sort(Comparator<? super E> c)
default void replaceAll(UnaryOperator operator)
Note: If we want to manage elements of non final type inside any List collection then we should
override at least equals methods inside non final type.
ArrayList
Array is collection of fixed elements. ArrayList is resizeable array.
Implementation of ArrayList is based of array.
ArrayList is List collection.
Since ArrayList is List collection we can store elements sequentially.
Since ArrayList is List collection, we can store duplicate elements as well as null elements inside
ArrayList.
Since ArrayList is List collection, we can access its elements using integer index.
Since ArrayList is List collection, we can traverse its elements using Iterator as well as ListIterator.
ArrayList implementation is unsynchronized. Using [Link]() method we can
make it synchronized.
If ArrayList is full then its capacity gets increased by half of existing capacity.
This class is a member of the Java Collections Framework and introduced in JDK 1.2.
Constructor Summary of ArrayList class:
public ArrayList()

ArrayList<Intger> list = new ArrayList();

public ArrayList(int initialCapacity)

ArrayList<Intger> list = new ArrayList( 15 );

public ArrayList(Collection<? extends E> c)

Collection<Integer> c = new ArrayList<>( );

[Link]( 10 );
[Link]( 20 );
[Link]( 30 );

ArrayList<Integer> list = new ArrayList<>( c );

Method Summary of ArrayList class:

public void ensureCapacity(int minCapacity)
protected void removeRange(int fromIndex, int toIndex)
public void trimToSize()
Instantiation:
 public static void main(String[] args){
Collection<Integer> collection = new ArrayList<>(); //OK:
Upcasting
List<Integer> list = new ArrayList<>(); //OK: Upcasting
ArrayList<Integer> arrayList = new ArrayList<>(); //OK
}

How to add single element inside ArrayList?

public static void main(String[] args) {

List<Integer> list = new ArrayList<>();
[Link](10);
[Link](20);
[Link](40);
[Link](50);
[Link](2, 30);
[Link]( [Link]());
}

public static List<Integer> getList( ){

List<Integer> list = new ArrayList<>();
[Link](10);
[Link](20);
[Link](30);
[Link](40);
[Link](50);
return list;
}
public static void main(String[] args) {
List<Integer> list = [Link]();
[Link]( [Link]()); //[10, 20, 30, 40, 50]
}

public static List<Integer> getList( ){

List<Integer> list = new ArrayList<>();
[Link](10);
[Link](20);
[Link](30);
[Link](40);
[Link](50);
return list;
}
public static void main(String[] args) {
List<Integer> list = [Link]();
Integer element = null;
for( int index = 0; index < [Link](); ++ index ) {
 element = [Link]( index );
[Link](element);
}
}

public static List<Integer> getList( ){

List<Integer> list = new ArrayList<>();
[Link](10);
[Link](20);
[Link](30);
[Link](40);
[Link](50);
return list;
}
public static void main(String[] args) {
int[] arr = new int[ ] { 10, 20, 30 };
//int element = arr[ [Link] ];
//ArrayIndexOutOfBoundsException

String str = "CDAC";

//char ch = [Link]([Link]());
//StringIndexOutOfBoundsException

List<Integer> list = [Link]();

Integer element = [Link]( [Link]() );
//IndexOutOfBoundsException
}

public static List<Integer> getList( ){

List<Integer> list = new ArrayList<>();
[Link](10);
[Link](20);
[Link](30);
[Link](40);
 [Link](50);
return list;
}
public static void main(String[] args) {
List<Integer> list = [Link]();
Integer element = null;
Iterator<Integer> itr = [Link]();
while( [Link]()) {
element = [Link]();
[Link](element);
}
}

public static List<Integer> getList( ){

List<Integer> list = new ArrayList<>();
[Link](10);
[Link](20);
[Link](30);
[Link](40);
[Link](50);
return list;
}
public static void main(String[] args) {
List<Integer> list = [Link]();
for( Integer element : list )
[Link]( element );
}

public static void main(String[] args) {

List<Integer> list = [Link]();
/* Consumer<Integer> action = [Link]::println;
[Link](action); */
[Link]( [Link]::println );
}

public static List<Integer> getList( ){

List<Integer> list = new ArrayList<>();
[Link](10);
[Link](20);
[Link](30);
[Link](40);
[Link](50);
return list;
}
public static void main(String[] args) {
List<Integer> list = [Link]();
ListIterator<Integer> itr = [Link]();
 Integer element = null;
while( [Link]()) {
element = [Link]();
[Link]( element+" ");
}
[Link]();
while( [Link]()) {
element = [Link]();
[Link]( element+" ");
}
}

//Object[] elementData;
private static int capacity(List<Integer> list) throws Exception{
Class<?> c = [Link]();
Field field = [Link]("elementData");
[Link](true);
Object[] elementData = (Object[]) [Link](list);
return [Link];
}
public static void main(String[] args) {
try {
List<Integer> list = [Link]();
[Link]("Size : "+[Link]()); //5

int capacity = [Link]( list );

[Link]("Capacity : "+capacity);
} catch (Exception e) {
[Link]();
}
}

How to add multiple elements inside ArrayList?

public static void main(String[] args){

Collection<Integer> collection = new ArrayList<>();
[Link](30);
[Link](40);
[Link](50);

//List<Integer> list = new ArrayList<>( collection ); //OK

List<Integer> list = new ArrayList<>( );
[Link](10);
[Link](20);
[Link](collection);
[Link](list);
}
 public static void main(String[] args) {
Collection<Integer> collection = new ArrayList<>();
[Link](30);
[Link](40);
[Link](50);

List<Integer> list = new ArrayList<>( );

[Link](10);
[Link](20);
[Link](60);
[Link](70);
[Link](2, collection);
[Link](list);
}

How will you search single element inside ArrayList?

public static List<Integer> getList( ){

List<Integer> list = new ArrayList<>();
for( int count = 1; count <= 10; ++ count )
[Link]( count * 10 );
return list;
}
public static void main(String[] args) {
List<Integer> list = [Link](); //[10, 20, 30, 40, 50, 60,
70, 80, 90, 100]
Integer key = new Integer(500);
if( [Link](key)) {
int index = [Link](key);
[Link]( key+" found at index : "+index);
}else
[Link](key+" not found.");
}

How will you search and remove multiple elements

public static List<Integer> getList( ){

List<Integer> list = new ArrayList<>();
for( int count = 1; count <= 10; ++ count )
[Link]( count * 10 );
return list;
}
public static void main(String[] args) {
List<Integer> list = [Link](); //[10, 20, 30, 40, 50, 60,
70, 80, 90, 100]
Collection<Integer> keys = new ArrayList<>( );
[Link](30);
[Link](50);
[Link](70);
 if( [Link](keys)) {
[Link](keys); //[10, 20, 40, 60, 80, 90, 100]
//[Link](keys); //[30, 50, 70]
[Link]( list );
}else
[Link](keys+" not found.");
}

How will you search and remove single element from ArrayList?

public static List<Integer> getList( ){

List<Integer> list = new ArrayList<>();
for( int count = 1; count <= 10; ++ count )
[Link]( count * 10 );
return list;
}
public static void main(String[] args) {
List<Integer> list = [Link](); //[10, 20, 30, 40, 50, 60,
70, 80, 90, 100]
Integer key = new Integer(50);
if( [Link](key)) {
//[Link](key);
int index = [Link](key);
[Link](index);
[Link]( list ); //[10, 20, 30, 40, 60, 70, 80, 90,
100]
}else
[Link](key+" not found.");
}

How will you sort ArrayList?

public static void main(String[] args) {

List<Integer> list = new ArrayList<>();
[Link](50);
[Link](10);
[Link](30);
[Link](20);
[Link](40);

[Link](list); //[50, 10, 30, 20, 40]

//[Link]( list );
[Link](null);
[Link](list); //[10, 20, 30, 40, 50]
}

How will you convert ArrayList into array?

 public static void main(String[] args) {
List<Integer> list = new ArrayList<>();
[Link](50);
[Link](10);
[Link](30);
[Link](20);
[Link](40);

//Object[] arr = [Link]();

Integer[] arr = new Integer[ [Link]() ];

[Link](arr);

[Link]( [Link](arr)); //[50, 10, 30, 20, 40]

}

Using [Link]() method

public static void main(String[] args) {

List<Integer> list = [Link](10, 20, 30, 40, 50 );
[Link]( [Link]().getName());
//[Link]$ArrayList
[Link]( list ); //[10, 20, 30, 40, 50]
}

Which collection classes are by default synchronized in Java?

 [Link]
[Link]
[Link]
[Link]
Vector

Vector is a class declared in [Link] package.

Vector is List collection whose implementation is based on array.
Since Vector is List collection, it is ordered/sequential collection.
Since Vector is List collection, it can contain duplicate elements as well as null elements
Since Vector is List collection, we can traverse its elements using Iterator as well as ListIterator.
We can traverse elements of Vector using [Link] , [Link] as well as
ListIterator.
Vector is Synchronized collection.
Default capacity is 10 elements. Once Vector is full it gets double capacity.
It was introduced in JDK 1.0. Hence it is also called as legacy class.
Travsering using Enumeration
Enumeration is interface declared in [Link] package.
It was introduced in JDK 1.0.
Methods of Enumeration I/F:
 boolean hasMoreElements()
E nextElement()
Using Enumeration we can traverse limited collections. For Example: Vector, Hashtable etc.
Using Enumeration, we can traverse collection only forward direction. During traversing we can not
add, set or remove elements from underlying collection.

public static void main(String[] args){

Vector<Integer> v = new Vector<>();
for( int count = 1; count <= 10; ++ count )
[Link](count);

Integer element = null;

Enumeration<Integer> e = [Link]() ;
while( [Link]()) {
element = [Link]();
[Link](element);
}
}

Travsering using Iterator

Iterator is interface declared in [Link] package.
This interface is a member of the Java Collections Framework.
Methods of Iterator interface:
boolean hasNext()
boolean hasNext()
default void remove()
default void forEachRemaining(Consumer<? super E> action)
Iterator takes the place of Enumeration in the Java Collections Framework. Iterators differ from
enumerations in two ways:
Iterators allow the caller to remove elements from the underlying collection during the iteration.
Method names have been improved.

public static void main(String[] args){

Vector<Integer> v = new Vector<>();
for( int count = 1; count <= 10; ++ count )
[Link](count);

Integer element = null;

Iterator<Integer> itr = [Link]();
while( [Link]()) {
element = [Link]();
[Link](element);
 }
}

Travsering using ListIterator

It is subinterface of Iterator interface which is declared in [Link] package.
We can use it to traverse only List collections( ArrayList, Vector, Stack, LinkedList etc.)
We can use ListIterator to traverse collection in bidirection. During travsering, using iterator we can
add/set/remove element from collection.
Method Summary
void add(E e)
void set(E e)
void remove()
boolean hasNext()
E next()
boolean hasPrevious()
E previous()
int nextIndex()
int nextIndex()
This interface is a member of the Java Collections Framework.
It is introduced in JDK 1.2

public static void main(String[] args){

Vector<Integer> v = new Vector<>();
for( int count = 1; count <= 10; ++ count )
[Link](count);

Integer element = null;

ListIterator<Integer> itr = [Link]();
//ListIterator<Integer> itr = [Link]( 4 );
//ListIterator<Integer> itr = [Link]( [Link]() );
while( [Link]()) {
element = [Link]();
[Link](element+" ");
}
[Link]();
while( [Link]()) {
element = [Link]();
[Link](element+" ");
}
}

What is the difference between Enumeration and Iterator

 Using Enumeration we can traverse collection only in forward direction. During traversing, using
Enumeration, we can not add/set/remove element from underlying Collection. Using Iterator we can
traverse collection only in forward direction. During traversing, using Iterator, we can not add/set
element but we can remove element from underlying Collection.
We can use Enumeration for few Collections only but we can use Iterator for any collection that
implements Iterable interface.
Enumeration method names are long bur Iterator methods names are short.
Enumeration was introduced in JDK 1.0 whereas Iterator was introduced in JDK1.2.
What is the difference between Iterator and ListIterator
Using Iterator we can traverse any Collection which implements Iterable interface but Using
ListIterator we can traverse any List collection.
Using Iterator we can traverse collection only in forward direction whereas using ListIterator we can
traverse collection in bidirection.
During traversing, using iterator, we can not add/set element from underlying collection but we can
remove element. During traversing, using ListIterator, we can add/set/remove element from
underlying collection.
What do you know about fail-fast and not fail-fast( i.e. fail-safe) iterator
or What do you know about ConcurrentModificationException?
During traversing, without iterator, if we try to make changes in underlying collection and if we get
ConcurrentModificationException then such iterator is called as fail-fast Iterator.

public static void main(String[] args){

Vector<Integer> v = new Vector<>();
for( int count = 1; count <= 10; ++ count )
[Link](count);

Integer element = null;

Iterator<Integer> itr = [Link]();
while( [Link]()) {
element = [Link]();
[Link](element);
if( element == 10 )
[Link](11); //ConcurrentModificationException
}
}

During traversing, without iterator, if we try to make changes in underlying collection and if we do not
get ConcurrentModificationException then such iterator is called as fail-safe Iterator. Such iterators
works by creating copy of the Collection.

public static void main1(String[] args){

Vector<Integer> v = new Vector<>();
 for( int count = 1; count <= 10; ++ count )
[Link](count);

Integer element = null;

Enumeration<Integer> e = [Link]() ;
while( [Link]()) {
element = [Link]();
[Link](element);
if( element == 10 )
[Link](11); //OK
}
[Link](v);
}

What is the difference between ArrayList and Vector?

Synchronization: ArrayList collection in unsynchronized whereas Vector is collection synchronized.
Capacity: Incase of arrayList, capacity gets increased by half of existing capacity. In case of vector,
capacity get increased by existing capacity.
Traversing: We can traverse elements of ArrayList using Iterator and ListIterator whereas we can
traverse elements of vector using Enumeration, Iterator and ListIterator.
Legacy: ArrayList collection is introduced in JDK 1.2 whereas Vector collection is introduced in JDK
1.0.
Stack
It is sub class of [Link] class.
IN Java, Stack is synchronized collection.
If we want to perform operations in Last In First Out(LIFO) order/manner then we should use Stack.
Method Summary Stack:
public boolean empty()
public E push(E item)
public E peek()
public E peek()
public int search(Object o)

public static void main(String[] args) {

Stack<Integer> stk = new Stack<>();
[Link](10);
[Link](20);
[Link](30);
[Link](40);
[Link](50);

Integer element = null;

while( ![Link]()) {
element = [Link]();
[Link]("Removed element is : "+element);
 [Link]();
}
}

If we want, unsynchronized implementation of Stack then we should use Deque implementation

public static void main(String[] args) {

Deque<Integer> stk = new ArrayDeque<>();
[Link](10);
[Link](20);
[Link](30);
[Link](40);
[Link](50);

Integer element = null;

while( ![Link]()) {
element = [Link]();
[Link]("Removed element is : "+element);
[Link]();
}
}

LinkedList

It is a class declared in [Link] package. Its implementation is based on Doubly LinkedList.

LinkedList class implements List as well as Deque interface.
Since it is List collection, It stored elements in sequential manner.
Since it is List collection, It can contain duplicate elements as well as null elements
Since it is List collection, We can access its elements using integer index.
Since it is List collection, We can traverse its elements using Iterator and ListIterator
LinkedList collection is unsynchronized. Using [Link]() method we can make it
synchronized.
 This class is a member of the Java Collections [Link] is introduced in JDK 1.2
Queue

It is sub interface of Collection interface.

If we want to perform operations in First In First Out order then we should use Queue implementation.
This interface is a member of the Java Collections Framework.
It is introduced in JDK 1.5
Method Summary of Queue interface:
boolean add(E e)
boolean offer(E e)
E remove()
E poll()
E element()
E peek()
Consider following code:

public static void main(String[] args) {

Queue<Integer> que = new ArrayDeque<>();
[Link](10);
[Link](20);
[Link](30);
[Link](40);
[Link](50);
//[Link](null); //Not Allowed

Integer element = null;

while( ![Link]() ) {
element = [Link]();
[Link]("Removed element is : "+element);
[Link]();
}
}
 Consider following code:

public static void main(String[] args) {

Queue<Integer> que = new ArrayDeque<>();
[Link](10);
[Link](20);
[Link](30);
[Link](40);
[Link](50);
//[Link](null); //Not Allowed

Integer element = null;

while( ![Link]() ) {
element = [Link]();
[Link]("Removed element is : "+element);
[Link]();
}
}

Deque
It is sub interface of Queue interface.
The name deque is short for "double ended queue" and is usually pronounced "deck".
This interface is a member of the Java Collections Framework.
It is introduced in JDK 1.6
Set
 It is sub interface of [Link] interface.
HashSet, LinkedHashSet, TreeSet, EnumSet are Set collections.
Set Collections do not contain duplicate elements.
This interface is a member of the Java Collections Framework.
It is introduced in JDK 1.2
Method names of Collection and Set interface are same. No new method is added in Set interafce.
What is the difference between List and Set?
ArrayList, Vector, LinkedList are List Collections and HashSet, LinkedHashSet, TreeSet are Set
collections
List collections can contain duplicate elements but Set collections do not contain duplicate elements.
List collections can contain null elements but not all Set collections contain null elements.
We can traverse elements of List collection using ListIterator as well as Iterator but we can we can
traverse elements of Set collection using Iterator only.
All List collections are sequential collections but we can not give gurantee of order of elements in Set
collection.
TreeSet
It is a Set collection.
It can not contain duplicate elements.
It can not contain null elements.
It contains data in sorted order.
TreeSet implementation is based on TreeMap<K,V>.
It is unsynchronized collection. Using [Link]() method we can make it
synchronized.
This class is a member of the Java Collections Framework.
It is introduced in JDK 1.2
Note: If we want to use TreeSet to store elements of non final type then non final type should
implement Comparable interface.
How to create instance of TreeSet

public static void main(String[] args) {

TreeSet<Integer> treeSet = new TreeSet<>();

Set<Integer> set = new TreeSet<>(); //Upcasting

Collection<Integer> collection = new TreeSet<>(); //Upcasting

}

How will you add elements inside TreeSet?

public static void main(String[] args) {

Set<Integer> set = new TreeSet<>(); //Upcasting
[Link](50);
[Link](10);
[Link](30);
[Link](20);
[Link](40);
[Link]( set ); //[10, 20, 30, 40, 50]
}

Can we add duplicate elements inside TreeSet

public static void main(String[] args) {

Set<Integer> set = new TreeSet<>(); //Upcasting
[Link](50);
[Link](10);
[Link](30);
[Link](20);
[Link](40);

[Link](50);
 [Link](10);
[Link](30);
[Link](20);
[Link](40);

[Link]( set ); //[10, 20, 30, 40, 50]

}

Can we add null element inside TreeSet?

public static void main(String[] args) {

Set<Integer> set = new TreeSet<>(); //Upcasting
[Link](50);
[Link](10);
[Link](30);
[Link](20);
[Link](40);
[Link](null); //NullPointerException

[Link]( set );
}

Can we convert TreeSet into ArrayList?

Set<Integer> set = new TreeSet<>(); //Upcasting

[Link]( 10 );
[Link]( 20 );
[Link]( 30 );
List<Integer> list = new ArrayList( set );

Algorithm
In Computer science algorithm and data structure are two different branches.
Data structure describes 2 things:
How to organize data inside RAM?
Which operations should be used to organize data inside RAM.
Data structure can be linear / non linear.
Well defined set of statements that we can use to solve real world common problems is called as
algorithms.
In the context of data structure algorithms can be searching / sorting algorithms.
Searching
Searching refers to the process of finding location( index / reference ) of an element in Collection.
The collection of data may be in array, list, database, or any other data structure.
There are several searching algorithms, each with its own strengths and weaknesses:
 Linear search
Binary search
Hashing
Interpolation search
Exponential search
Linear Search
Linear search is a simple searching algorithm that sequentially searches each element in a collection
until the desired item is found.
Consider following code:

public static int linearSearch(int[] arr, int key) {

if( arr != null ){
for (int index = 0; index < [Link]; index++) {
if (arr[ index ] == key)
return index;
}
}
return -1;
}

Pros of linear search:

Simplicity: Linear search is easy to understand and implement, making it a good choice for
small collections.
Flexibility: Linear search can be used with any type of collection, including arrays and linked
lists.
No requirement for sorted data: Unlike some other search algorithms, linear search does not
require the data to be sorted.
Cons of linear search:
Time complexity: The worst-case time complexity of linear search is O(n), where n is the
number of elements in the collection.
Inefficiency with large collections: Linear search is inefficient for large collections, as it requires
checking every element in the collection
Not suitable for complex data structures: For complex data structures, such as trees or graphs
Binary search
Binary search is a searching algorithm used to search for a specific element in a sorted array.
The basic idea of binary search is to divide the array into halves repeatedly until the desired element
is found.
Consider following exaple:
 public static int binarySearch(int[] arr, int key) {
int left = 0;
int right = [Link] - 1;
while (left <= right) {
int mid = (left + right) / 2;
if (arr[mid] == key)
return mid;
else if (arr[mid] < key)
left = mid + 1;
else
right = mid - 1;
}
return -1;
}

Pros of Binary Search:

Efficient: Binary search is an efficient algorithm, with a time complexity of O(log n) for a sorted
array of size n. This is much faster than linear search, which has a time complexity of O(n).
If the array is already sorted, it can be a very efficient way to search for an element.
Cons of Binary Search:
Requires Sorted Array: As mentioned, binary search requires the array to be sorted in advance.
If the array is unsorted or frequently updated, then binary search may not be the best choice.
Requires Random Access: Binary search requires random access to the array elements, which
is not available in some data structures such as linked lists.
Limited Applicability: Binary search is limited to searching for an element in a one-dimensional
sorted array. It cannot be used to search for an element in a multidimensional array or a
database table.
Hashing
Consider numbers, 29,54,42,18,73,69,93 and insert it into array.

Hashing is a technique used to store and retrieve data in a fast and efficient manner.
Hashing searching is based on hash code.
Hashcode is not an index / address / reference. It is a logical integer number that can be generated by
processing state of the instance.
To generate hash code we should use hash function. Consider following example

public int hashCode( int element) {

final int prime = 31;
int result = 17;
result = prime * result + element;
return result;
}

In the context of hashing, a slot refers to a location in the hash table where a key-value pair can be
stored.
In other words, hash code is required to generate index which is called as slot in hashing.

By Processing state of the instance, if we get same slot then it is called as collision.

To avoid collision, we should use collision resolution techniques:

Separate Chaining / Open Hashinng
Open Addressing /Close Hashing
Linear Probing
Qudratic Probing
Double Hashing
Separate Chaining

To avoid collision, we can maintain one collection(LinkedList/BST) per slot. It is called as bucket.
Note: If we want to store any element of non primitive type inside Hashcode based collection then we
should override equals and hashCode method inside non primitive type.
Pros of Hashing
Fast retrieval: Hashing allows for constant-time retrieval of data, regardless of the size of the
data set. This makes it a very efficient searching algorithm.
Flexibility: Hashing can be used to search for any type of data, including strings, numbers, and
custom objects.
Easy to implement
Supports dynamic resizing: Hash tables can be resized dynamically to accommodate more
data, without having to recreate the entire data structure.
Cons of Hashing:
Hash collisions: Hash collisions occur when two different keys are mapped to the same hash
value. This can result in slower lookup times and may require additional processing to resolve
the collision.
Memory usage: Hash tables can consume a lot of memory, particularly if the data set is large.
This can lead to performance issues if the available memory is limited.
Hash functions: The efficiency of hashing depends on the quality of the hash function used.
Poor hash functions can lead to more collisions, slower retrieval times, and other issues.
equals and hashCode are non final methods of [Link] class.
If we do not override equals method then super class's equals method will call. equals method of
Object class do not compare state of instances. It compares state of references.
Consider equals method definition of Object class:

public boolean equals(Object obj) {

return (this == obj);
 }

hashCode is non final but native method of [Link] class.

Syntax:

public native int hashCode( );

hashCode() method of [Link] class convert memory address of instance into integer value.
Hence even though state of the instances are same we get different hashCode. If we want hashCode
based on state of the instance then we should override hashCode method inside class.
Consider implementation:

@Override
public int hashCode() {
int prime = 31;
int result = 1;
result = result * prime + [Link];
return result;
}

HashSet
It is hashCode based collection whose implementation is based on Hashtable.
In HashSet elements get space according its hash code hence It doesn't give any gurantee about
order of the elements.
Since it is Set collection, it doesn't contain duplicate elements.
HashSet can contain null element.
It is unsynchronized collection. Using [Link]() method we can consider it
synchronized.
This class is a member of the Java Collections Framework.
It is introduced in JDK 1.2
If we want to use any element of non final type inside HashSet then non final type should override
equals() and hashCode() method.
Instantiation of HashSet:

public static void main(String[] args) {

//HashSet<Integer> set = new HashSet<>();
 Set<Integer> set = new HashSet<>();
}

How will you add element inside HashSet?

public static void main(String[] args) {

Set<Integer> set = new HashSet<>();
[Link](101);
[Link](125);
[Link](13);
[Link](314);
[Link](215);
[Link](set); //[101, 215, 314, 125, 13]
}

Is it possible to store duplicates and null elements?

public static void main(String[] args) {

Set<Integer> set = new HashSet<>();
[Link](101);
[Link](125);
[Link](13);
[Link](314);
[Link](215);
[Link](null);

[Link](101);
[Link](125);
[Link](13);
[Link](314);
[Link](215);
[Link](null);
[Link](set); //[null, 101, 215, 314, 125, 13]
}

LinkedHashSet
It is hashCode based collection whose implementation is based on Hashtable and LinkedList.
During traversing it maintains order of lements.
Since it is Set collection, it doesn't contain duplicate elements.
HashSet can contain null element.
It is unsynchronized collection. Using [Link]() method we can consider it
synchronized.
This class is a member of the Java Collections Framework.
It is introduced in JDK 1.4
If we want to use any element of non final type inside HashSet then non final type should override
equals() and hashCode() method.
Dictionary<K,V>
Dictionary<K,V> is abstract class declared in [Link] package.
We can use it store elements in key value pair format.
Hashtable is sub class of Dictionary<K,V> class.
It was introduced in JDK 1.0
Method Summary
public abstract V put(K key, V value)
public abstract int size()
public abstract V get(Object key)
public abstract V remove(Object key)
public abstract boolean isEmpty()
public abstract Enumeration keys()
public abstract Enumeration elements()
Consider example of Dictionary class:

import [Link];
import [Link];
import [Link];
public class Program {
public static Dictionary<Integer, String> getDictionary( ){
Dictionary<Integer, String> d = new Hashtable<>(); //Upcasting
[Link](1,"PreDAC");
[Link](2,"DAC");
[Link](3,"DMC");
[Link](4,"DIVESD");
[Link](5,"DESD");
[Link](6,"DBDA");
return d;
}
private static void countAndPrintEntries(Dictionary<Integer, String>
d) {
[Link]("Count of entries : "+[Link]());
}
private static void printKeys(Dictionary<Integer, String> d) {
Enumeration<Integer> keys = [Link]();
Integer key = null;
while( [Link]()) {
key = [Link]();
[Link]( key );
}
}
private static void printValues(Dictionary<Integer, String> d) {
Enumeration<String> values = [Link]();
String value = null;
while( [Link]()) {
value = [Link]();
[Link](value);
}
}
private static void printValue(Dictionary<Integer, String> d, int
 courseId) {
Integer key = new Integer( courseId );
String value = [Link](key);
if( value != null )
[Link](key+" "+value);
else
[Link]("Invalid key");
}
private static void removeEntry(Dictionary<Integer, String> d, int
courseId) {
Integer key = new Integer( courseId );
String value = [Link](key);
if( value != null )
[Link](key+" "+value+" is removed");
else
[Link]("Invalid key");
}
public static void main(String[] args) {
Dictionary<Integer, String> d = [Link]();
//[Link]( d );
//[Link]( d );
//[Link]( d );
//[Link]( d, 2 );
[Link]( d, 200);
}
}

This class is obsolete. New implementations should implement the Map interface, rather than
extending this class.
Map<K,V>

It is Key/Value pair interface which is declared in [Link] packgae.

 It is member of Collection framework but it doesn't extend Collection interface.
This interface takes the place of the Dictionary class, which was a totally abstract class rather than
an interface.
Hashtable<K,V>, HashMap<K,V>, LinkedHashMap<K,V>, TreeMap<K,V> etc. are map collections.
If we want to insert any element/value inside mau collection then we should provide key for it.
In map collection we can insert duplicate value but we can not insert duplicate key.
This interface is a member of the Java Collections Framework.
It was introduced in JDK 1.2
[Link]<K,V> is nested interface of Map interface.
(key-value pair) instance is also called as entry.
Methods of [Link]<K,V> interface
K getKey()
V getValue()
V setValue(V value)
Method Summary of Map<K,V> interface
boolean isEmpty()
V put(K key, V value)
void putAll(Map<? extends K,? extends V> m)
int size()
boolean containsKey(Object key)
boolean containsValue(Object value)
V get(Object key)
V remove(Object key)
void clear()
Set keySet()
Collection values()
Set<[Link]<K,V>> entrySet()
Hashtable<K,V>
It is a sub class of Dictionary<K,V> class and it implements Map<K,V>
Since it is Map collection, we can not insert duplicate keys but we can insert duplcate value.
In Hashtable key and value can not be null.
It is synchronized collection.
It is introduced in JDK 1.0.
If we want to use any element of non primitive type inside Hashtable then non primitive type should
override equals and hashCode method.

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

public class Program {

private static Map<Integer, String> getMap() {
Map<Integer, String> map = new Hashtable<>();
[Link](1, "DAC");
[Link](2, "DMC");
[Link](3, "DESD");
[Link](4, "DBDA");
[Link](5, "DIVESD");
return map;
}
private static void printAndCountEntries(Map<Integer, String> map) {
[Link]("Entries Count : "+[Link]());
}
private static void printKeys(Map<Integer, String> map) {
Set<Integer> keys = [Link]();
for (Integer key : keys) {
[Link](key+" ");
}
[Link]();
}
private static void printValues(Map<Integer, String> map) {
Collection<String> values = [Link]();
for (String value : values) {
[Link](value+" ");
}
[Link]();
}
private static void printEntries(Map<Integer, String> map) {
Set<Entry<Integer, String>> entries = [Link]();
for (Entry<Integer, String> entry : entries) {
[Link]([Link]()+" "+[Link]());
}
}
private static void printEntry(Map<Integer, String> map, int id) {
Integer key = new Integer(id);
if( [Link](key)) {
String value = [Link](key);
[Link]( key+" "+value);
}else
[Link](key+" not found");
}
private static void removeEntry(Map<Integer, String> map, int id) {
Integer key = new Integer(id);
if( [Link](key)) {
String value = [Link](key);
[Link]( key+" "+value+" is removed");
}else
[Link](key+" not found");
}
public static void main(String[] args) {
Map<Integer, String> map = [Link]( );
//[Link]( map );
 //[Link]( map );
//[Link]( map );
//[Link]( map );
//[Link]( map, 3 );
//[Link]( map, 3 );

List<String> list = new ArrayList<>([Link]());

[Link](list);
}
}