Learn Java

www.shareittips.com
 OOPS

Object Oriented Programming Structure

Features of OOPS
Objects / Instance
Classes
Inheritance
Polymorphism
● Overloading / Static Polymorphism / Compile-time
polymorphism
● Overriding / Dynamic polymorphism / Run-time
polymorphism
Encapsulation
Abstraction
 OOPS

Objects – Real time entity

Classes – Blueprint of an object. It gives structure
to the objects
Inheritance – Deriving base class properties and
behaviour to the child class
Polymorphism - One object in different forms
Encapsulation - Hiding the irrelevant details to the
irrelevant entity
Abstraction – Revealing the relevant details to the
relevant entity.
 Structure of Java Compiler

Type Class File

Source File Parser Checker Writer
Class
class C {
@NonNull

File
Object field;

C(@NonNull
Object p) {
field = p;
}

@NonNull
Object get() {

}
return field;
Comments
}

Error
 History of Java

The original name of Java was Oak, and it was

developed as a part of the Green project at Sun
Microsystems.
Java was conceived by James Gosling, Patrick
Naughton, Chris Warth, Ed Frank, and Mike
Sheridon at Sun Microsystems in 1991.
Sun formally announced the Java SunWorld in
1995.
 Features of JAVA

Object Oriented Programming language

Platform Independent
Robust
Portable
Scalable
Multithreaded
Architecturally neutral
Secured
 Components of Java

JDK – Java Development Kit

JRE – Java Run-time Environment
JVM - Java Virtual Machine
 Java Virtual Machine

Ø The Java Virtual Machine provides a platform-

independent way of executing code, by abstracting the
differences between operating systems and CPU
architectures.
Ø JVM is Write Once-Run Anywhere (WORA) software.
Ø JVM forms part of large system JRE.
Ø JVM's main job is interpreting java byte code and
translating this into actions or OS calls.
Ø JVM is OS dependent which makes java source code as
machine independent.
JRE and JVM
Purpose of Features of OOPS

Classes - Classification
Encapsulation - maintainability, flexibility and extensibility.
Polymorphism – one method will behave differently.
Inheritance – Reusability, Easier updates, Do not break
what is already working.
 Structure of JAVA Program

Package declaration;
Import statements
Class declaration
{
Variable declaration/ definition;
method declaration / definition;
}
 Main method

class <classname>
{
public static void main(String[] args)
{
// Object instantiation
<classname> m = new <classname>();
}
}
 CamelCase Convention

Variables - myVariable
Method - myMethod()
Class - MyClass
Package - mypackage
Constants - MYCONSTANT
 Types of Variable

Local variable (variable inside method or block)

Class Variable (Static Variable)
Instance Variable ( variable inside the class)

Note:
Local variables require explicit initialization.
Instance variables are initialized automatically.
 Variable Initialization
Variable Value
byte 0
short 0
int 0
long 0L
float 0.0F
double 0.0D
char '\u0000'
boolean false
All reference types null
 Constructor

It is a Spl. Method
Purpose: To initialize the class members
Features:
Same name as that of the class name
No return type including VOID
Can have access specifier
Can be overloaded
Constructors are NOT inherited
Invoked automatically whenever the object is
created.
The no. of time of invocation depends on no. of
object created
 Arrays

Group data objects of the same type, in a

contiguous block of memory.
An array is an object; it is created with new.
Can be declared as a primitive type or Class type.
Array index starts with 0.
You cannot resize an array.
You can use the same reference variable to refer
to an entirely new array.
 Array Declaration and
Instantiation
Array declaration
<element type>[] <array name>;

int[] myArray;
• Constructing an array
<array name> =
new <element type> [<array size>];

myArray = new int[5];

 Initializing an Array

Explicit initialization in one line.

<element type>[] <array name> =
{ <array initialize list> };

Primitive array:
*****************
int[] myArray = { 1 , 2 , 3 , 4 , 5 } ;

Reference Array:
********************
Object[] objArr = { new Pizza(), new Pizza(), null };
 Initializing an Array

Explicit initialization can also be done using array

subscripts.
int[] myArray = new int[3];
myArray [0] = 10;
myArray [1] = 20;
myArray [2] = 30;
 Inheritance
Deriving the parent class properties and methods
to the child class.
Types of inheritance:
Single level inheritance
- one super and one sub class
Multilevel inheritance
- The sub class of one level forms the super
class of another level
Multiple inheritance [ not supported by java]
- many super and one sub class
Hierarchical inheritance
- one super and many sub classes
Hybrid inheritance
- multiple and multi level combined.
 Inheritance

Two important concepts

Generalization - Up the hierarchy
Specialization - Down the hierarchy
Purpose : Reusability (without changing its
identity)
Syntax:
<modifier> class <name> extends <superclass> {
<declaration>*
}
 IS-A & HAS-A relationship

When you want to know if one thing should extend

another, use the IS-A test.
Eg : Triangle IS-A Shape
Do not apply inheritance if the subclass and super
class do not pass the IS-A test.
Is-a relationship can be described in Java keyword
extends.
The IS-A relationship – Unidirectional
 IS-A & HAS-A relationship

When two classes are related, but not through

inheritance, (for example, one class has a
reference to another class) then you say that the
two classes are joined by HAS-A relationship.
Has-a relationship can be described in Java code
as member fields.
Note:
Code reuse is also best achieved by aggregation
when there is no is-a relationship
 IS-A & HAS-A relationship

class Car
{
}
class BMW extends Car => IS-A R/S
{
boolean auto_gear = “true” => Has-A R/S
}
 Polymorphism

Polymorphism (from Greek, meaning “many

forms”) is a feature that allows one interface to be
used for a general class of actions that is one
interface with multiple methods.
Types:
Overloading => Ad-Hoc Polymorphism
- Same method name with different set of
parameters.
- Early Binding
Overriding => True polymorphism
- Same method name with same set of parameters.
- Late Binding
 Types of Overloading

Function Overloading
Constructor Overloading
NO operator Overloading in Java

Rules :
No. of parameter should change
Datatype of the parameter should change
Sequence of passing the paramter should change.
 Overriding
The overridden method in the superclass is NOT inherited by the
subclass, and the new method in the subclass must uphold the
following rules of method overriding:
The new method definition must have the same method
signature (i.e., method name and parameters) and the same
return type.
Overridden Methods Cannot Be Less Accessible.
A subclass cannot override fields of the superclass, but it can
hide them.
Works only with inheritance.
Constructors cant be Overridden.
Super keyword is used to invoke an overridden method in the
superclass.
 this() and super() call for
constructor
this() construct is used to implement local chaining of
constructors in the class when an instance of the class is
created.
The this() call invokes the constructor with the
corresponding parameter list.
super() method is used to invoke the IMMEDIATE base
class constructor. This allows the subclass to influence the
initialization of its inherited state when an object of the
subclass is created.
this() and super() call must occur as the first statement in
a constructor.
Example : this() and super()
class GParent
{
int a,b,c;
GParent() {
System.out.println("From gparent");
}

GParent(int a,int b) {
//this(a,b,100);
this();
System.out.println("a= "+a+" b = "+ b);
}

GParent(int a,int b,int c) {

this.a=a;
this.b=b;
this.c=c;
System.out.println("a= "+a+" b = "+ b + " c= "
Example : this() and super()

class Parent extends GParent

{
int x,y;
Parent()
{
System.out.println("From parent");
}

Parent(int x,int y)
{
super(x,y);
this.x=x;
this.y = y;
System.out.println("x= "+x+" y = "+ y);
}
Example : this() and super()

class Child extends Parent

{
Child()
{
super(23,343);
System.out.println("From child");
}

}
class SuperEx
{
public static void main(String[] a)
{
//Parent p = new Parent(12,23);
Child d = new Child();

}
 instanceof operator

Use instanceof to test the type of an object.

Restore full functionality of an object by casting.
Example:
public void doSomething(Employee e) {
if ( e instanceof Manager )
{
Manager m = (Manager) e;
}
// rest of operation
}
 Static Keyword

It’s a Access Modifier

The static keyword is used as a modifier on
variables, methods, and nested classes.
The static keyword declares the attribute or
method is associated with the class as a whole
rather than any particular instance of that class.
Thus static members are often called class
members, such as class attributes or class
methods.
 Static Keyword

A static method can access only the static

variable. But the normal variable can access both
static and normal variable.
Static members will get loaded into the memory
only once.
Static members are subjected to change common
for all the instance.
NO NEED FOR OBJECT to access the static
member.
 Static Variable Example
class StatEx
{
int i=10;
static int j = 20;

public void normalMethod()

{
System.out.println("Instance var = " + i++);
System.out.println("Static var = " + j++);
}

public static void main(String arg[])

{
StatEx s1 = new StatEx();
StatEx s2 = new StatEx();
s1.normalMethod();
s2.normalMethod();
}
}
 Static Method Example
class StatEx
{
int i=10;
static int j = 20;

public static void staticMethod()

{
//System.out.println("Instance var = " + i++); //illegal
System.out.println("Static var = " + j++);
}

public static void main(String arg[])

{
staticMethod();
staticMethod();
}
}
 Static Initializer Example

class StatEx1
{
static int counter;

//static initializer
static
{
counter=10;
System.out.println("Static block invoked
"+counter);
}
public static void sMethod()
{
System.out.println("Static method" +
counter++);
}
 Static Initializer Example

class StatEx
{
public static void main(String arg[])
{
System.out.println("from main");
StatEx1.sMethod();
StatEx1.sMethod();
}
}
 Final Keyword

Variable become Constant

Method cant be Overridden
Class cant be inherited

Note:
All final variable need Explicit initialization
 Wrapper Class

Conversion of primitive types to the object

equivalent done through wrapper classes.
Allow objects to be created from primitive types.
Wrapped values are immutable (Cant modify) . To
wrap another value, you need to create another
object.
Wrapper class are present in java.lang package
All the wrapper classes are declared final.
 Primitive Data Types and
Corresponding Wrapper
Primitive Data Classes
Wrapper Constructor
Type Class Arguments
boolean Boolean boolean or String

byte Byte byte or String

char Character char

short Short short or String

int Integer int or String

long Long long or String

float Float double or float or String

double Double double or String

All the wrapper classes except Boolean and

Character are subclasses of an abstract class
called Number, whereas Boolean and
Character are derived directly from the Object
class.
 Boxing and Unboxing

Converting a value type to a reference type is

known as Boxing.
Converting a reference type to a value type is
known as UnBoxing.

int x=10;
Integer n = new Integer(x); //Boxing
int y = n.intValue(); //UnBoxing
AutoBoxing and
AutoUnboxing

Example:

int x=10;
Integer n = x; //AutoBoxing
int y = n; //AutoUnBoxing
 Methods to Extract the
Wrapped Values
Method Class

public boolean booleanValue() Boolean

public char charValue() Character

public byte byteValue() Byte, Short, Integer, Long, Float,

Double
public short shortValue() Byte, Short, Integer, Long, Float,
Double
public int intValue() Byte, Short, Integer, Long, Float,
Double
public long longValue() Byte, Short, Integer, Long, Float,
Double
public float floatValue() Byte, Short, Integer, Long, Float,
Double
public double doubleValue() Byte, Short, Integer, Long, Float,
Double
 Methods to Convert Strings
to Primitive Types
Wrapper Method Signature Method Arguments
Class

Boolean static boolean parseBoolean(…) String

Character Not available
Byte static byte parseByte(…) String, or String and radix
Short static short parseShort(..) String, or String and radix
Integer static int parseInt(…) String, or String and radix
Long static long parseLong(…) String, or String and radix
Float static float parseFloat(…) String
Double static double parseDouble(…) double or String
Wrapper Conversion methods

Primitive xxxValue()
To convert Wrapper to primitive

• Primitive parseXxx(String)
To convert a String to a primitive

• Wrapper valueOf(String)
To convert a String to a Wrapper
 Object Class

Root class of Java => Object

equals() method = > Check only values
toString() method =>Check value & reference
hashCode() => return the address of the object

Object Class is in java.lang package.

 Abstract Class
Class which have a abstract method (method
without definition) is abstract class.
Can have normal method and variable
Cant be instantiated
Methods may or may not be implemented by the
child class.
Use abstract keyword to declare a class as
abstract.
Abstract method cannot be private or final
A class can inherit only one abstract class.
NEED RELATIONSHIP between classes
 Interface
Interface is to support multiple inheritance in Java.
Interfaces should be implemented by the child
class
Can have only abstract method.
Interface contain only constants.NO Variables.
All the fields are public static final in nature.
Interfaces cant be instantiated
A class can implement many interfaces.
All the methods should be implemented by the
child class.
NO NEED FOR RELATIONSHIP
 enum

Assigning a integral constant to a symbolic name

=> enum
Use enum when you want a variable to hold only a
predetermined set of values.
You use the keyword enum and not class to
declare an enum.
Just like a class, an enum can have constructors,
methods, and fields.
An enum cannot be declared within a method.
You cannot instantiate an enum with the new
operator.
 enum

The enums do not participate in class hierarchy:

they cannot extend and they cannot be extended.
You cannot directly call an enum constructor.
An enum may have a main() method and
therefore can be executed by name from the
command line like an application.
 Enum Example1

enum Edge
{
TOP,BOTTOM,LEFT,RIGHT
};

class MyClass
{
public static void main(String[] a)
{
Edge e = Edge.TOP;
int i = e.ordinal();
System.out.println(e);
System.out.println(i);
}
}
 Enum Example2

enum Edge
{
TOP,BOTTOM,LEFT,RIGHT;

public static void main(String[] a)

{
Edge e = Edge.TOP;
int i = e.ordinal();
System.out.println(e);
System.out.println(i);
}
}
 Enum Example3
public enum Day
{

MONDAY(8,true),
TUESDAY(8,true),
WEDNESDAY(8,true),
THURSDAY(8,true),
FRIDAY(8,true),
SATURDAY(4,false),
SUNDAY(0,false);

private int hours;

private boolean weekday;
 Enum Example3

Day(int whours,boolean wday)

{
hours=whours;
wday=weekday;
}

public int getHours()

{
return hours;
}

public boolean isWeekDay()

{
return weekday;
}
 Enum Example3

public static void showDay(Day d)

{
if(d.isWeekDay())
{
System.out.println(d +" is a weekday and has "+
d.getHours() +" hours working hours");
}
else
{
System.out.println(d +" is a not weekday and has
"+ d.getHours() +" hours working hours");
}
}
 Enum Example3

public static void main(String[] ar)

{
Day day;
day = Day.SUNDAY;
showDay(day);
}

}
 Inner Class
A class that is declared within another class or
interface, is called a nested class.
There are four categories of nested classes
Regular class - class within the class
Method-local class – class within the method of
the outer class
Static nested class - inner classes marked with
the static modifier (top-level nested class)
Anonymous class - part of a method argument.
All inner classes are nested classes, but not all
nested classes are inner classes.
 Example for Regular
InnerClass
class MyOuter
{
int x =7;
class MyInner
{
public void InnerMethod()
{
System.out.println("x == " + x);
}
}
public void OuterMethod()
{
MyInner inn = new MyInner();
inn.InnerMethod();
}
Example for Regular
InnerClass
public static void main(String[] a)
{
MyOuter mo = new MyOuter();
MyOuter.MyInner mi = mo.new MyInner();
mi.InnerMethod();
mo.OuterMethod();
//mi.OuterMethod(); illegal
//mo.InnerMethod(); illegal

}
 Method-local inner class

A method-local inner class can be instantiated

only within the method where the inner class is
defined.
Can access the outer class level variable.
CANT access the variable inside the method in
which the inner class is created except a final
variable.
Method-local inner class can be declared abstract
and final.
method-local inner class can't use any access
specifiers.
 Method-local inner class
class MouterClass
{
int x =10;
public void OuterMethod()
{
final int j=90;
class MinnerClass
{
public void minnerMethod()
{
System.out.println("Hello ..." + x + j);
}
}
MinnerClass mic = new MinnerClass();
mic.minnerMethod();
}
public static void main(String[] a)
{
 Static nested class

Static nested classes are inner classes marked

with the static modifier.
A static nested class is not an inner class, it's a
top-level nested class.
A static nested class cannot access non-static
members of the outer class.
 Static nested class

class OuterClass
{
static int i =10;
public void method()
{
System.out.println("i == " + ++i);
}
static class InnerClass
{
public void display()
{
System.out.println("i == " + i);
}
}
 Static nested class

public static void main(String[] a)

{
OuterClass.InnerClass ic = new
OuterClass.InnerClass();
ic.display();

OuterClass oc = new OuterClass();

oc.method();
}
}
 Anonymous Inner Classes

Anonymous inner classes have no name.

Anonymous inner classes cannot have
constructor.
 Anonymous Inner Classes
import java.awt.*;
import java.awt.event.*;
class FrameExample
{
private Frame f;
public FrameExample()
{
f = new Frame("Hello .....!");
}
public void launchFrame()
{
f.setSize(170,170);
f.setBackground(Color.blue);
f.setVisible(true);
 Anonymous Inner Classes

// Add a window listener

f.addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent evt)
{
System.exit(0);
}
}); //Anonymous Inner Classes

public static void main(String args[])

{
FrameExample f = new FrameExample();
f.launchFrame();
}
}
 Exception Handling
An exception in Java is a signal that indicates the
occurrence of some important or unexpected
condition during execution.
Error Types:
happens due to problems originating from the
execution environment. (Error Class)
happens due to problems originating inside the
application itself. (Exception Class)

• Exception Should be Handled or Thrown to the

exception handler.
 Exceptions

Errors (represented by subclasses of Error) occur

in the Java virtual machine (JVM) and not in the
application itself.
The exceptions (represented by subclasses of
Exception), on the other hand, generally originate
from within the application.
Types:
Checked Exception
Unchecked Exception
 Checked Exception

Checked exceptions are generally related to how

the program interacts with its environment.
This is the category of exceptions for which the
compiler checks (hence the name checked
exceptions) to ensure that your code is prepared
for them.
The programmer is required to write code to deal
with checked exceptions. The compiler checks
that such code exists.
It MUST be thrown programmatically or Handled.
 Unchecked Exception

Occur due to program bugs.

Runtime exceptions are not checked by the
compiler.
Write the correct code to avoid the runtime
exceptions than write the code to catch them but it
is not illegal to catch them.
Runtime exceptions and errors combined are also
called unchecked exceptions and they are mostly
thrown by the JVM.
 The Exception Class
Hierarchy
Object

Throwable

Exception Error

Others… RuntimeException Others…

Others…
 Exception-handling
mechanism
Contains five keywords:
try - catch – throw - throws – finally
Method throws ExceptionName{
try{
--risky code goes here
}catch(ExceptionClassName ObjectName){
-- Exception handler block code
throw Exception_Instance //Ducking it
}
finally{
-- cleanup your code goes here
}
}
 About try-catch-finally
A try block should be followed by at least one catch block.
The code inside try block is called as protected code.
Can have one or more catch block.
If you have multiple catch block, make sure that the last
catch block contain the super most class in the hierarchy.
You may also write an optional “finally” block. This block
contains code that is ALWAYS executed, either after the “try”
block code, or after the “catch” block code.
The catch block may or may not contain throw keyword.
The try block can also be nested.
 Example 1

class PrintStack
{
public static void main(String args[])
{
int Num1= 30 , Num2 = 0;
try
{
int Num3=Num1/Num2;
}
catch(ArithmeticException obj)
{
System.out.println("Exception"+obj);
obj.printStackTrace();
}
}
}
 Rules in Exception

The Declare or Handle Rule

Handle the exception by using the
try-catch-finally block.
Declare that the code causes an exception by
using the throws clause.
You do not need to declare runtime exceptions or
errors.
You can choose to handle runtime exceptions.
 Passing the exception
In any method that might throw an exception, you
may declare the method as “throws” that
exception, and thus avoid handling the exception
yourself
Example
● public void myMethod throws IOException {
… normal code with some I/O
}
 Throws clause

class UncheckedThrows
{
public void show() throws ArithmeticException
{
System.out.println("Hai I am not handled");
}

public static void main(String[] arg)

{
new UncheckedThrows().show();
}
}
 Method Overriding and
Exceptions
The overriding method can throw:
v

v No exceptions
v One or more of the exceptions thrown by
the
overridden method.
v One or more subclasses of the exceptions
thrown by the overridden method.
v The overriding method cannot throw:
v Additional exceptions not thrown by the
overridden method.
v Super classes of the exceptions thrown by
the overridden method
 User Defined Exception

Create User-Defined Exception as a Class that

EXTENDS Exception Class.
• Instantiate the created Exception and use it in
the catch block as a handler.
 Example 2
import java.io.*;

class MyException extends Exception

{
MyException()
{
System.out.println("UserDefined Error occured");
}

public String toString()

{
return "MyException thrown";
}
}
 Example 2 cont…

class UserExceptions
{
public void valid()
{
try
{
String str1,str2;
BufferedReader br=new BufferedReader(new
InputStreamReader(System.in));
System.out.println("Enter Login id");
str1=br.readLine();
System.out.println("Enter password");
str2=br.readLine();
if(str1.equals(str2))
System.out.println("Hai welcome");
else
throw new MyException();
}
 Example 2 cont …

catch(MyException e)
{
System.out.println("Sorry U r not a valid user" + e);
valid();
}
catch(IOException ioe){}
}

public static void main(String[] arg) throws IOException

{
UserExceptions e1=new UserExceptions();
e1.valid();
}

}
 String Class Facts

An object of the String class represents a string of

characters.
The String class belongs to the java.lang package,
which does not require an import statement.
Like other classes, String has constructors and
methods.
Unlike other classes, String has two operators, +
and += (used for concatenation).
String class is declare final , therefore immutable.
 Literal Strings

are anonymous objects of the String class

are defined by enclosing text in double quotes.
“This is a literal String”
don’t have to be constructed.
can be assigned to String variables.
can be passed to methods and constructors as
parameters.
have methods you can call.
 Literal String Example

//assign a literal to a String variable

String name = “Priya”;

//calling a method on a literal String

char Initial = “Priya”.charAt(0);

//calling a method on a String variable

char Initial = name.charAt(0);
 Immutability

Once created, a string cannot be changed: none

of its methods changes the string.
Such objects are called immutable.
Immutable objects are convenient because
several references can point to the same object
safely: there is no danger of changing an object
through one reference without the others being
aware of the change.
 Advantages Of Immutability

Uses less memory

String word1 = "Java"; String word1 = “Java";
String word2 = word1; String word2 = new String(word1);

word word “Java"

1 1
“Java" word “Java"
2
word
2 Less efficient:
OK wastes memory
 Disadvantages of
Immutability
Less efficient — you need to create a new string
and throw away the old one even for small
changes.

String word = “Java”;

char ch = Character.toUpperCase(word.charAt (0));
word = ch + word.substring (1);

word “java"

“Java"
 Empty Strings

An empty String has no characters. It’s

length is 0.

String word1 = ""; Empty strings

String word2 = new String();
Not the same as an uninitialized String.

private String errorMsg; errorMsg

is null
 Copy Constructors

Copy constructor creates a copy of an existing

String. Also rarely used.
Not the same as an assignment.

Copy Constructor: Each variable points to a different copy of the String.

String word1 = new word1 “Java"

String(“Java”); word2 “Java"
String word2 = new
String(word);
Assignment: Both variables point to the
same String. word1
String word1 = “Java”; “Java"
String word2 = word; word2
 Other Constructors

Most other constructors take an array as a

parameter to create a String.

char[] letters = {‘J’, ‘a’, ‘v’, ‘a’};

String word = new String(letters);//”Java”

String index starts with 0 like arrays.

 Methods in String Class

char charAt(i) => Returns the char at position i.

int length(); => Returns the number of
characters in the string.
String substring() => Returns a substring object
substring(i,k) substring(i)
“television".substring (2,5); “television".substring (2);

television television
i k i
 Methods in String Clas
indexOf() => returns the index position of the
character.
equals()
equalsIgnoreCase()
compareTo()
compareToIgnoreCase()
trim()
replace()
toUpperCase()
toLowerCase()
 StringBuffer Class

String Buffers are mutable strings.

StringBuffer is a final class.
They can be created empty, from a string or with a
capacity. An empty StringBuffer is created with 16-
character capacity.
Can grow dynamically in size without bounds.
 Methods in String Buffer
length()
capacity()
ensureCapacity()
setLength()
charAt()
Append()
setCharAt()
Insert()
deleteCharAt()
replace()
reverse()
 StringBuilder Class
Same like StringBuffer Class
StringBuilder’s methods are not synchronized.
StringBuilder methods should run faster than
StringBuffer methods.
 Collections
A collection allows a group of objects to be treated
as a single unit.
Arbitrary objects can be stored, retrieved, and
manipulated as elements of collections.
Provided in the java.util package.
The collections framework comprises three main
parts.
Interfaces => Collection
Classes => Collections
Algorithms
 The Collections Interfaces
vThe root of the hierarchy of the collections interfaces
is the Collection interface.
v There is another kind of collections called maps,

which are represented by the super interface Map.

Both a Map object and a Set collection cannot contain

duplicates data items.
while a List collection can contain duplicates.
 The Collections Interfaces
A collection has no special order and does
not reject duplicates.
(java.util.Collection)
A list is ordered and accept duplicates.
(java.util.List).
A set has no special order but rejects
duplicates. (java.util.Set)
A map supports searching on a key field,
values of which must be unique.
(java.util.Map)
 Collection Classes

ArrayList, LinkedList, and Vector are the classes

that implement the List interface.
HashMap and HashTable are examples of classes
that implement the Map interface.
HashSet and LinkedHashSet are examples of
classes that implement the Set interface.
 List

import java.util.*;
class ListExample {
public static void main(String[] args) {
List list = new ArrayList();
list.add("one");
list.add("second");
list.add("3rd");
list.add(new Integer(4));
list.add(new Float(5.0F));
list.add("second"); // duplicate, is added
list.add(new Integer(4)); // duplicate, is
added
System.out.println(list);
}
}
 Set

import java.util.*;
class SetExample {
public static void main(String[] args) {
Set set = new HashSet();
set.add("one");
set.add("second");
set.add("3rd");
set.add(new Integer(4));
set.add(new Float(5.0F));
set.add("second"); // duplicate, not
added
set.add(new Integer(4)); // duplicate, not
added
System.out.println(set);
}
}
 Collection API - Storage
The storage associated with any one collection can be
implemented in many ways, but the Collections API
implements the four methods that are most widely used:
Array: supports insertion, deletion, but growing the store
is more difficult.
ArrayList: grow in number of elements. Search is faster.
But not insertion and deletion. Vector(provides
synchronization)
Linked list: supports insertion, deletion, and growing the
store, but makes indexed access slower. Use when
insertions and deletions happen frequently.
Tree: supports insertion, deletion, and growing the list.
Indexed access is slow, but searching is faster.
Hash table: supports insertion, deletion, and growing the
store. Indexed access is slow, but searching is
particularly fast. However, hashing requires the use of
unique keys for storing data elements.
 Set Classes
HashSet :
provides the faster access to a data item.
no guarantee that the items will be ordered.
does not offer synchronization.
Tree Set:
presents sorted data items.
performance is not as good as HashSet.
does not offer synchronization.
LinkedHashSet:
Similar to HashSet that maintains a doubly linked list.
It is an ordered collection, ordered by insertion, but not
sorted.
does not offer synchronization
 Map Classes
HashTable:
implementation is based on the hashtable data structure.
No ordering.
implementation is synchronized
HashMap:
based on the hashtable data structure.
No ordering
allows null and is unsynchronized
LinkedHashMap:
maintains a doubly linked list.
TreeMap:
implements the SortedMap interface
Sorted and unsynchronized.
Class Interface Duplicates Ordered/ Synchronized
Allowed? Sorted

ArrayList List Yes Ordered by index No

Not sorted

LinkedList List Yes Ordered by index No

Not sorted

Vector List Yes Ordered by index Yes

Not sorted
HashSet Set No Not ordered No
Not sorted
LinkedHashSet Set No Ordered by insertionNo
Not sorted

TreeSet Set No Sorted either by No

natural order or by
your comparison
rules
Class Interface Duplicates Ordered/ Synchronized
Allowed? Sorted

HashMap Map No Not ordered No

Not sorted

LinkedHashMap Map No Ordered No

Hashtable Map No Not ordered Yes

Not sorted

TreeMap Map No Sorted either by No

natural order or by
your comparison
rules
 Collection Advantages and
Disadvantages
Advantages
Can hold different types of objects.
Resizable
Disadvantages
Must cast to correct type
Cannot do compile-time type checking.
 Generics

For checking the type of object during the

compilation time.
Enclose the type within angular brackets <>.
 Date Class

The java.text.DateFormat class provides several

methods for formatting the date/time for a default
or a specific location, and yet you can keep your
code completely independent of the locale
conventions for months, days of the week, days of
the months, and so on.
You create a locale object by using the Locale
class
 Process and Thread
A process is a program that is currently executing.
Every process has at least one thread running
within it.
Threads are referred to as lightweight processes.
A thread is a path of code execution through a
program, and each thread has its own local
variables, program counter (pointer to the current
instruction being executed), and lifetime.
 Threads

A thread is not an object

A thread is a flow of control
A thread is a series of executed statements
A thread is a nested sequence of method calls
 MultiThreading and
MultiTasking
Multitasking is a mechanism to run many
Heavyweight processes simultaneously in a
different address space so context switch or
intercommunication between processes is much
expensive.
Multithreading is a mechanism of running various
lightweight processes under single process within
its own space
Multiprocessing there will be more than one
processor and each thread will be handled by a
different processor.
 Creation of a Thread

By extending Thread class

By implementing Runnable interface.
Even a non-multithreaded program has one thread
of execution, called the main thread.
Call the start() method to start the thread.
When a thread is started, it calls the run() method
to make our thread to perform useful work.
 1st Method: Extending the
Thread class
class MyThread extends Thread
{
public void run()
{
// thread body of execution
}
}
Creating thread:
MyThread thr1 = new MyThread();
Start Execution:
thr1.start();
 2nd method: Threads by
implementing Runnable
interface
class ClassName implements Runnable{
public void run()
{
// thread body of execution
}
}
Creating Object:
ClassName myObject = new ClassName();
Creating Thread Object:
Thread thr1 = new Thread( myObject );
Start Execution:
thr1.start();
 Thread scheduling

Thread scheduling is implementation dependent

and cannot be relied on to
act in the same way on every JVM
The two approaches to scheduling are
Preemptive - will be applied for thread with
highest and lowest priority
Time-Sliced (Round-Robin) Scheduling – will be
applied when more than one thread has the same
priority.
 Threads within a process

THREAD
STACK

SHARED
MEMOR
Y
THREAD
DATA
THREAD
TEXT

l All threads are parts of a process hence communication

easier and simpler.
l Independent executables
 Thread States
A thread can in one of several possible states:
1.Running
Currently running
In control of CPU
2.Ready to run
Can run but not yet given the chance
3.Resumed
Ready to run after being suspended or block
4.Suspended
Voluntarily allowed other threads to run
5.Blocked
Waiting for some resource or event to occur
 Thread Priorities

Why priorities?
Determine which thread receives CPU control
and gets to be executed first
Definition:
– Integer value ranging from 1 to 10
– Higher the thread priority → larger chance of
being executed first

– Example:
● Two threads are ready to run
● First thread: priority of 5, already running
● Second thread = priority of 10, comes in while first
thread is running
 Thread Synchronization

Done in two ways

To method
● public synchronized void method()
● { }
To block
● synchronized(this)
● {

● }
Wait() and notify()

Wait() and notify should be used to restrict the

thread before doing an operation without a
notification from the other thread.
Should be used along with the synchronized block
 wait()

When a thread enters a wait state, it does nothing

until it is notified by another thread.
It also gives up it’s lock on the object when wait is
called.
public synchronized blah() {
wait();
… // do something
}
 notify()
To awaken a thread, a different thread which has a
lock on the same object must call notify.
When notify is called, the block that had the lock on
the object continues to have it’s lock it releases it.
Then a thread is awakened from its wait() and can
grab the lock and continue processing.
There are two versions - notify() and notifyAll().
Notify is safe only under 2 conditions:
When only 1 thread is waiting, and thus guaranteed
to be awakened.
When multiple threads are waiting on the same
condition, and it doesn’t matter which one awakens.
In general, use notifyAll()
 Thread Group
You can include thread in a set of threads by
adding it to an instance of ThreadGroup
ThreadGroups can contain not only threads but
also other ThreadGroups.
 Semaphore
Semaphore is a synchronization mechanism,
which implements mutual exclusion among
processes to avoid race condition to access any
shared resource.
Semaphore maintains a counter to implement
locking and unlocking. It avoids busy waiting. If a
critical section is in use, the calling process will be
removed from a run queue and put into a sleep
state.
Java 5 comes with semaphore implementations in
the java.util.concurrent package so you don't have
to implement your own semaphores.
A mutex is really a semaphore with value 1.
 Semaphores
Semaphores have two purposes
Mutex: Ensure threads don’t access critical section
at same time
Scheduling constraints: Ensure threads execute in
specific order
• A semaphore is an IPC mechanism that is
implemented conceptually with at least these two
components
– a counter (int) variable
– a wait queue of processes
• And has at least these two operation
– wait for the semaphore to be free
(p)
– signal that the semaphore is now
free (v)
 Semaphore

The semaphore has at least these possible states:

Free, or available, or not in use
Not free, or unavailable, or in use
Interpretation of the counter variable:
If the counter is positive, then the semaphore is
free.
If the counter is zero (or negative), then the
semaphore is in use (not free).
 Semaphore
• Cases using a semaphore S
1. If a process does a wait (p) on S, and if the
semaphore is free, then S is decremented
(S.counter = S.counter – 1;)
2. If a process does a wait (p) on S and if S is not free,
then the process is blocked and put in S’s wait
queue.
3. If a process does a signal (v) on S and if there is no
process in the wait queue for S, then the semaphore
is set to free by incrementing its counter (to
positive).
4. If a signal (v) on S and there is a process in the S
queue, then the process at the head of the queue is
removed and unblocked (and can continue to
execute)
 IOStreams

Usual Purpose: storing data to ‘nonvolatile‘ devices,

e.g. harddisk
Classes provided by package java.io
Data is transferred to devices by ‘streams‘

output - stream
Program Device

input - stream
Program Device
 keyboard
standard
input
stream
CPU

standar
doutput MEM
stream
monitor
terminal
console

HDD
How does information
travel across?
Streams
 keyboard
standard
input
stream
CPU

standar
doutput MEM
stream
monitor
terminal
console file
input
strea
m
LOAD HDD
How does READ
information travel file
across? files outpu
Streams t
strea
m
SAVE
 IOStreams

JAVA distinguishes between 2 types of streams:

Text – streams, containing ‘characters‘

Binary Streams, containing 8 – bit information

Progra Devic
m I ‘ M A S T R I N G \n e

Progra 0110100 1110110 0000000 Devic

m 1 1 0 e
 IOStreams

Streams in JAVA are Objects, having

2 types of streams (text / binary) and
2 directions (input / output)

Results in 4 base-classes dealing with I/O:

1. Reader: text-input
2. Writer: text-output
3. InputStream: byte-input
4. OutputStream: byte-output
 Binary vs. TextFiles

pro con

Binary Efficient in terms of Preinformation

time and space about data needed
(input to understand
content
&output
stream)
Text(reader Human readable, Not efficient
contains redundant
and writer) information
 Binary vs. TextFiles

When use Text- / BinaryFiles ?

ALWAYS use TextFiles for final results
Binary Files might be used for non-final
interchange between programs
Binary Files are always used for large amount of
data (images, videos etc.)
 Serialization

Serialization: process of saving objects to a

stream i.e. in-memory object to a byte stream.
Each object is assigned a serial number on the
stream
If the same object is saved twice, only serial
number is written out the second time
When reading, duplicate serial numbers are
restored as references to the same object
The objects must be read from the stream in the
same order in which they were written.
 Serialization

Why isn’t everything serializable?

Security reasons – may not want contents of

objects printed out to disk, then anyone can print
out internal structure and analyze it
Could also have temporary variables that are
useless once the program is done running.
 Serialization basics
The requirements for serialization are straightforward:
Only class instances rather than primitive types can
be serialized.
For an object to be serializable, its class or some
ancestor must implement the empty Serializable
interface.
An empty interface is called a marker
interface.
The syntax for serialization is
straightforward:
An object is serialized by writing it to
an ObjectOutputStream.
An object is deserialized by reading it
from an ObjectInputStream.
 Serialization code

=> Writing objects to a file

FileOutputStream out =
new FileOutputStream( “save.txt” );
ObjectOutputStream oos =
new ObjectOutputStream( out );
oos.writeObject( new Date() );
oos.close();
 Deserialization code

=> Reading objects from a file

FileInputStream in =
new FileInputStream( “save.txt” );
ObjectInputStream ois =
new ObjectInputStream( in );
myObject d = (myObject_type) ois.readObject();
ois.close();
 Conditions for serializability

If an object is to be serialized:
The class must be declared as public
The class must implement Serializable
The class must have a no-argument constructor
All fields of the class must be serializable: either
primitive types or serializable objects
The Serializable interface does not define any methods!
Question: What possible use is there for an interface that does not
declare any methods?
Answer: Serializable is used as flag to tell Java it needs to do
extra work with this class
 Object Serialization (cont’d)

writeObject() will throw an Error if the object

passed to it is not Serializable.
You can control serialization by implementing the
Externalizable interface.
readObject() returns something of type Object, so
it needs to be cast.
 Serialization and primitive
types
Technically, primitive types cannot be serialized or
deserialized. However, the
ObjectOutputStream implements the
DataOutput interface, which declares
methods such as writeInt to write
primitive types to streams.
ObjectInputStream implements
DataInput for reading primitive types
 transient and static fields

A field marked as transient is not

impacted by serialization.
During deserialization, transient
fields are restored to their default
values (e.g., transient numeric
fields are restored to zero).
static fields are not impacted by
serialization.
 JDBC

Java DataBase Connectivity

The JDBC ( Java Database Connectivity) API
defines interfaces and classes for writing database
applications in Java by making database
connections.
JDBC provides RDBMS access by allowing you to
embed SQL inside Java code
 JDBC Architecture
ØJava application calls the JDBC library. JDBC
loads a driver which talks to the database. We
can change database engines without changing
database code.
Click to edit Master text styles
Second level
● Third level

● Fourth level

● Fifth level

Ø import the java.sql package.

 Steps in JDBC
To register the Driver:
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
To Get the connecttion:
Connection con = DriverManager.
getConnection("jdbc:odbc:Deepi","sa","pass@123");
To create a SQL statement:
Statement st=con.createStatement();
To execute it:
st.execute(“DDL Query”);
st.executeUpdate(“DML Query”);
st.executeQuery(“select query”);
 Garbage Collector (GC)

Provides automated memory management.

Deletes the unused objects in the memory.
Only the JVM decides when to run the GC, you
can only suggest it.
An object becomes eligible for Garbage Collection
when its last live reference disappears.
 Garbage collection and
Performance
How Memory is allocated:
Object creation
Object is constructed either on a memory heap or on a
stack.

Memory heap
When new keyword is called memory is allocated in the
heap and returned when the reference is made null
Stack
During method calls, objects are created for method
arguments and method variables. These objects are created
on stack.
Such objects are eligible for garbage-collection when they
go out of scope.
 Garbage Collection

Advantages of Garbage Collection :

More productivity
Program Integrity

Disadvantages of Garbage Collection :

program performance
 Finalize() method

Finalize()
Class Object has a finalize() method.
Before gc happens the finalize() method is called
It is called only once
Finalize method can be overridden by the user.
Finalize can be used to make an object not to be garbage
collected
 Classical Algorithms

Three classical algorithms

Mark-sweep
Reference counting
Semispace
Tweaks
Generational garbage collection (JAVA DEFAULT)
Out of scope
Parallel –perform GC in parallel
Concurrent –run GC at same time as app
Real-time–ensure bounded pause times
 Mark-Sweep
Start with roots
Global variables, variables on stack& in registers
Recursively visit every object through pointers
Markevery object we find (set mark bit)
Everything not marked = garbage
Can then sweep heap for unmarked objectsand
free them
 Annotations

Annotations in Java is all about adding meta-data facility

to the Java Elements like
package declarations,
class,
constructors,
methods,
fields,
variables and etc
An annotation indicates that the declared element should
be processed in some special way by a compiler,
development tool, deployment tool, or during runtime.
Annotations are defined using an @ syntax
 Structure of Java5 Compiler
Type Annotation
Class File
Source File Parser Checker Checker Writer
class C {
@NonNull Class
Object field;
File
C(@NonNull
Object p) {
field = p;
}

@NonNull
Object get() {
return field;
}
}

Program
with
annotations Error Error

Annotation
Checker
Plugins
 Annotation Types

Marker
Single-Element
Full-value or multi-value
 Marker

Marker annotations take no parameters. They are used to

mark a Java element to be processed in a particular way.
Example:
public @interface MyAnnotation {
}

Usage:
@MyAnnotation
public void mymethod() {
....
}
 Single-Element

Single-element, or single-value type, annotations provide a single

piece of data only. This can be represented with a data=value pair
or, simply with the value (a shortcut syntax) only, within
parenthesis.

Example:
● public @interface MyAnnotation {
● String doSomething();
● }
Usage:
● @MyAnnotation ("What to do")
● public void mymethod() {
● ....
● }
 Full-value or multi-value
Full-value type annotations have multiple data members.
Example:
public @interface MyAnnotation {
String doSomething();
int count;
String date();
}
Usage:
@MyAnnotation (doSomething=
"What to do",
count=1,
date="09-09-2005")
public void mymethod() {
....
}
 The Built-In Annotations

Java defines seven built-in annotations.

Four are imported from java.lang.annotation
● @Retention,
● @Documented,
● @Target,
● and @Inherited.
Three are included in java.lang.
@Override,
@Deprecated,
and @SuppressWarnings.
 The Target annotation

@Target(ElementType.TYPE)
can be applied to any element of a class
@Target(ElementType.FIELD)
can be applied to a field or property
@Target(ElementType.METHOD)
can be applied to a method level annotation
@Target(ElementType.PARAMETER)
can be applied to the parameters of a method
@Target(ElementType.CONSTRUCTOR)
can be applied to constructors
@Target(ElementType.LOCAL_VARIABLE)
can be applied to local variables
@Target(ElementType.ANNOTATION_TYPE)
indicates that the declared type itself is a
 Reflection
When we have some Annotations defined in the
source code and have a mechanism through
which we can say that to what extent the
Annotations should be retained. The three
possible ways of telling this are,
Retain the Annotation in the Source Code only
Retain the Annotation in the Class file also.
Retain the Annotation Definition during the Run-
time so that JVM can make use of it.
The Annotation that is used to achieve this is
@Retention and it takes a possible values of
SOURCE, CLASS and RUNTIME defined in
RetentionPolicy Enumeration.
 Need of Annotation
Less coding
Easier to change
Smarter development.
Providing information to the Compiler.
Providing information to the tools.
Providing information to the Runtime System
 www.shareittips.com
www.bcahub.shareittips.com