Java Tutorial

 Java is a high-level programming language originally developed

by Sun Microsystems and released in 1995. Java runs on a
variety of platforms, such as Windows, Mac OS, and the various
versions of UNIX. This tutorial gives a complete understanding
on Java.
 This reference will take you through simple and practical
approach while learning Java Programming language.

Prerequisites
 Before you start doing practice with various types of examples
given in this reference, I'm making an assumption that you are
already aware about what is a computer program and what is a
computer programming language.
 Where It Is Used
According to Sun, 3 billion devices run Java. There are many
devices where Java is currently used. Some of them are as follows:
1. Desktop Applications such as acrobat reader, media player,
antivirus etc.
2. Web Applications such as irctc.co.in
3. Enterprise Applications such as banking applications.
4. Mobile
5. Embedded System
6. Smart Card
7. Robotics
8. Games etc.
 Types Of Java Applications
There are mainly 4 type of applications that can be created using Java:
1) Standalone Application
It is also known as desktop application or window-based
application. An application that we need to install
on every machine such as media player, antivirus etc. AWT and Swing
are used in Java for creating
standalone applications.
2) Web Application
An application that runs on the server side and creates dynamic
page, is called web application. Currently,
servlet, jsp, struts, jsf etc. technologies are used for creating web
applications in Java.
 Cont..
3) Enterprise Application
An application that is distributed in nature, such as banking
applications etc. It has the advantage of high
level security, load balancing and clustering. In Java, EJB is used for
creating enterprise applications.
4) Mobile Application
An application that is created for mobile devices. Currently
Android and Java ME are used for creating mobile
applications.
 Java Overview
 Java programming language was originally developed by Sun
Microsystems, which was initiated by James Gosling and released in
1995 as core component of Sun Microsystems Java platform (Java
1.0 [J2SE]).
 As of December 08 the latest release of the Java Standard Edition is
6 (J2SE).
 With the advancement of Java and its wide spread popularity,
multiple configurations were built to suite various types of
platforms.
 Ex: J2EE for Enterprise Applications, J2ME for Mobile Applications.
 Features of Java

I. Simple
2. Object-oriented
3. Platform independent 9.Interpreted
4.Secured 10.High Performance
5. Robust 11. Multithreaded
6. Architecture neutral 12.Distributed
7. Portable
8. Dynamic
 Features Of Java
 Object Oriented : In java everything is an Object. Java can be
easily extended since it is based on the Object model.
 Platform independent: Unlike many other programming
languages including C and C++ when Java is compiled, it is not
compiled into platform specific machine, rather into platform
independent byte code. This byte code is distributed over the web
and interpreted by virtual Machine (JVM) on whichever platform it is
being run.
 Features Of Java Cont..
 Simple :Java is designed to be easy to learn. If you understand
the basic concept of OOP java would be easy to master.
 Secure : With Java's secure feature it enables to develop virus-
free, tamper-free systems. Authentication techniques are based on
public-key encryption.
 Architectural- neutral :Java compiler generates an architecture-
neutral object file format which makes the compiled code to be
executable on many processors, with the presence Java runtime
system.
 Features Of Java Cont..
 Portable :being architectural neutral and having no
implementation dependent aspects of the specification makes Java
portable. Compiler and Java is written in ANSI C with a clean
portability boundary means We may carry the Java byte code to
any platform.
 Robust : Robust simply means strong. Java uses strong memory
management. There are lack of pointers that avoids security
problem. There is automatic garbage collection in Java. There is
exception handling and type
 checking mechanism in Java. All these points makes Java robust.
 Multi-threaded : With Java's multi-threaded feature it is possible
to write programs that can do many tasks simultaneously. This
design feature allows developers to construct smoothly running
interactive applications.
 Features Of Java Cont..
 Interpreted :Java byte code is translated on the fly to native
machine instructions and is not stored anywhere. The development
process is more rapid and analytical since the linking is an
incremental and light weight process.
 High Performance: With the use of Just-In-Time compilers Java
enables high performance.
 Distributed :Java is designed for the distributed environment of
the internet.
 Dynamic : Java is considered to be more dynamic than C or C++
since it is designed to adapt to an evolving environment. Java
programs can carry extensive amount of run-time information that
can be used to verify and resolve accesses to objects on run-time.
 My First Java Programme

public class MyFirstJavaProgram {

public static void main(String []args) {
System.out.println("Hello World");
}
}
 Understanding first java program
 class is used to declare a class in Java.
 public is an access modifier which represents visibility, it means it
is visible to all.
 static is a keyword, if we declare any method as static, it is known
as static method. The core advantage of static method is that
there is no need to create object to invoke the static method. The
main method is executed by the JVM, so it doesn't require to
create object to invoke the main method.So it saves memory.
 void is the return type of the method, it means it doesn't return
any value, main represents startup of the program.
 String[] args is used for command line argument. We will learn it
later. System.out.println() is used print statement.
What happens at compile
time?
At compile time, Java file is compiled by Java
Compiler (It does not interact with OS) and
converts the Java code into bytecode.
 What happens at runtime?

Classloader: is the subsystem of JVM that is used to load class files.

Bytecode Verifier: checks the code fragments for illegal code that
can violate accesss right to objects.
Interpreter: read bytecode stream then execute the instructions.
 Questions
 Can you save a java source file by other name than the class
name?
 Can you have a empty java file?
 What if no one class have main function?
 How to print “Hello World” without main function?
 Can you have multiple classes in a java source file?
 Java is an Object Oriented Language
As a language that has the Object Oriented feature Java supports the following
fundamental concepts:
1)Classes
2)Objects
3)Encapsulation
4)Abstraction
5)Inheritance
6)Polymorphism
 Objects
 Let us now look deep into what are objects. If we consider the
real-world we can find many objects around us, Cars, Dogs,
Humans etc. All these objects have a state and behavior.
 An object is an instance of a class. The relationship is such that
many objects can be created using one class. Each object has its
own data but its underlying structure (i.e., the type of data it
stores, its behaviors) are defined by the class.
 Classes

 A class--the basic building block of an object-oriented language

such as Java
 A class is a blue print from which individual objects are created.
 A class specifies the design of an object. It states what data an
object can hold and the way it can behave when using the data.
 Class is a template that describes the data and behavior
associated with instances of that class.
 The data associated with a class or object is stored in variables.
 The behavior associated with a class or object is implemented
with methods.(Methods are similar to the functions or
procedures in procedural languages such as C).
 Class Example
public class Book {
private String title;
private String author;
private String publisher;
public Book(String bookTitle, String
authorName, String publisherName) {
title = bookTitle;
author = authorName;
publisher = publisherName;
}
//all getter and setter methods
}
 Object Example
An instance of this class will be a book object:
Book firstBook = new Book(“Complete
Reference",“ABC",“XYZ");
Objects can be created by using new keyword in java.
As mentioned previously a class provides the blueprints
for objects. So basically an object is created from a class.
In java the new key word is used to create new objects.
There are three steps when creating an object from a
class:
 Declaration . A variable declaration with a variable name
with an object type. Like Book firstBook
 Instantiation . The 'new' key word is used to create the
object.
 Initialization . The 'new' keyword is followed by a call to a
More Details Of Class
 A class can contain any of the following variable
types.
1)Local variables
2)Instance variables
3)Class variables
 Local Variable
Local variable are variables defined inside methods,
constructors or blocks.
The variable will be declared and initialized within the method
and the variable will be destroyed when the method has completed.
Eg.

Public void setTitle(String title){

this.title=title;
}
 Rules For Local Variable

 Local variables are declared in methods, constructors, or blocks.

 Local variables are created when the method, constructor or
block is entered and the variable will be destroyed once it exits
the method, constructor or block.
 Access modifiers cannot be used for local variables.
 Local variables are visible only within the declared method,
constructor or block.
 Local variables are implemented at stack level internally.
 There is no default value for local variables so local variables
should be declared and an initial value should be assigned before
the first use.
Example Of Local Variable
Problem With Local Variable
Following example uses age without initializing it, so it would give an error at the
time of compilation.
 Instance variables
Instance variables are variables within a class but outside
any method. These variables are instantiated when the class is
loaded. Instance variables can be accessed from inside any
method, constructor or blocks of that particular class.

Eg.
private String title;
private String author;
private String publisher;
 Rules For Instance Variable

 Instance variables are declared in a class, but outside a method,

constructor or any block.
 When a space is allocated for an object in the heap a slot for
each instance variable value is created.
 Instance variables are created when an object is created with
the use of the key word 'new' and destroyed when the object is
destroyed.
 Instance variables hold values that must be referenced by more
than one method, constructor or block, or essential parts of an
object. state that must be present through out the class.
 Instance variables can be declared in class level before or after
use.
 Rules For Instance Variable

 Access modifiers can be given for instance variables.

 The instance variables are visible for all methods, constructors and
block in the class. Normally it is recommended to make these
variables private (access level).However visibility for subclasses
can be given for these variables with the use of access modifiers.
 Instance variables have default values. For numbers the default
value is 0, for Booleans it is false and for object references it is
null. Values can be assigned during the declaration or within the
constructor.
 Instance variables can be accessed directly by calling the variable
name inside the class. However within static methods and different
class ( when instance variables are given accessibility) the should
be called using the fully qualified
name .ObjectReference.VariableName.
Example Of Instance Variable
 Class variables

Class variables are variables declared with in a class,

outside any method, with the static keyword.
Eg.

private static int count=0;

 Rules For Class/Static Variable

 Class variables also known as static variables are declared with

the static keyword in a class, but outside a method, constructor
or a block.
 There would only be one copy of each class variable per class,
regardless of how many objects are created from it.
 Static variables are rarely used other than being declared as
constants. Constants are variables that are declared as
public/private, final and static. Constant variables never change
from their initial value.
 Static variables are stored in static memory. It is rare to use
static variables other than declared final and used as either
public or private constants.
 Static variables are created when the program starts and
destroyed when the program stops.
 Rules For Class/Static Variable

 Visibility is similar to instance variables. However, most static

variables are declared public since they must be available for users
of the class.
 Default values are same as instance variables. For numbers the
default value is 0, for Booleans it is false and for object references
it is null. Values can be assigned during the declaration or within
the constructor. Additionally values can be assigned in special
static initializer blocks.
 Static variables can be accessed by calling with the class
name . ClassName.VariableName.
 When declaring class variables as public static final, then variables
names (constants) are all in upper case. If the static variables are
not public and final the naming syntax is the same as instance and
local variables.
Example Of Class/Static Variable
 A class can have any number of methods to access the value of
various kind of methods.
Like Book Class can have
bookIssue()
addBook()
deleteBook()
updateBook()
 Source file declaration rules
 There can be only one public class per source file.
 A source file can have multiple non public classes.
 The public class name should be the name of the source file as
well which should be appended by .java at the end. For example :
The class name is . public class Employee{} Then the source file
should be as Employee.java.
 If the class is defined inside a package, then the package
statement should be the first statement in the source file.
 If import statements are present then they must be written
between the package statement and the class declaration. If
there are no package statements then the import statement
should be the first line in the source file.
 Import and package statements will imply to all the classes
present in the source file. It is not possible to declare different
import and/or package statements to different classes in the
 A Simple Case Study
 For our case study we will be creating two classes. They are
Employee and EmployeeTest.
 First open notepad and add the following code. Remember this is
the Employee class and the class is a public class. Now save this
source file with the name Employee.java.
 The Employee class has four instance variables name, age,
designation and salary. The class has one explicitly defined
constructor which takes a parameter.
A Simple Case Study
A Simple Case Study
How To Run
Java Keywords
Java Basic Datatypes

There are two data types available in Java:

 Primitive Data Types
 Reference/Object Data Types
 Primitive Datatypes
Data type Bytes Min Value Max Value Literal Values

byte 1 -27 27 – 1 123

short 2 -215 215 – 1 1234

int 4 -231 231 – 1 12345, 086, 0x675

long 8 -263 263 – 1 123456

float 4 - - 1.0

double 8 - - 123.86
char 2 0 216 – 1 ‘a’, ‘\n’
boolean - - - true, false
 Reference Data Types
 Reference variables are created using defined constructors of the
classes. They are used to access objects. These variables are
declared to be of a specific type that cannot be changed. For
example, Employee, Puppy etc.
 Class objects, and various type of array variables come under
reference data type.
 Default value of any reference variable is null.
 A reference variable can be used to refer to any object of the
declared type or any compatible type.
 Example : Animal animal = new Animal("giraffe");
 Java Modifier Types
 Modifiers are keywords that you add to those definitions to
change their meanings. The Java language has a wide variety of
modifiers, including the following:
 Java Access Modifiers
 Non Access Modifiers
To use a modifier, you include its keyword in the definition of
a class, method, or variable. The modifier precedes the rest of the
statement, as in the following examples (Italic ones)
 Java Modifiers
Modifier Class Class Methods Method
Variables Variables
public   
private  
protected  
default   
final    
abstract  
strictfp  
transient 
synchronized 
native 
volatile 
static   
Modifier Example
 Access Control Modifiers
Java provides a number of access modifiers to set access
levels for classes, variables, methods and constructors. The four
access levels are:
 Default:-Visible to the package. No modifiers are needed.
 Private:-Visible to the class only .
 Public:-Visible to the world.
 Protected:-Visible to the package and all subclasses.
 Non Access Modifiers
Java provides a number of non-access modifiers to achieve
many other functionality.
 The static modifier for creating class methods and variables
 The final modifier for finalizing the implementations of classes,
methods, and variables.
 The abstract modifier for creating abstract classes and
methods.
 The synchronized and volatile modifiers, which are used for
threads.
 Naming convention
A naming convention is a rule to follow as you decide what to
name your identifiers (e.g. class, package,variable, method, etc.),
but it is not mandatory to follow that is why it is known as
convention not rule.
Advantage:
By using standard Java naming conventions they make their
code easier to read for themselves and for other programmers.
Readability of Java code is important because it means less time is
spent trying to figure out what the code does.
Class Name should begin with uppercase letter and be a noun
e.g.String,System,Thread etc.
Interface Name should begin with uppercase letter and be an adjective
(whereever possible), e.g.Runnable,ActionListener etc.

Method Name should begin with lowercase letter and be a verb.

e.g.main(),print{),println(),
actionPerformed() etc.
Variable Name should begin with lowercase letter e.g.
firstName,orderNumber etc.
Package Name should be in lowercase letter, e.g. java.lang.sql.util etc.

Constant Name should be in uppercase letter, e.g.

RED,YELLOW,MAX_PRIORITY etc.
 Method Overloading
Method overloading means when two or more
methods have the same name but a different signature.
Signature of a method is nothing but a combination
of its name and the sequence of its parameter types.
Advantages of method overloading
It allows you to use the same name for a group of
methods that basically have the same purpose.
Method overloading increases the readability of the
program.
 Method Overloading
Different ways to overload the method
There are two ways to overload the method in Java
 1. By changing number of arguments
 2. By changing the data type
Note: In Java, Methood Overloading is not possible
by changing return type of the method.
 Questions
Que) Why Method Overloaing is not possible by changing
the return type of method?
Que) Can we overload main() method?
Method Overloading and Type Promotion
Example
Example
Example
 Constructor
 Constructor is a special type of method that is used to
initialize the state of an object/initialize a value to
instance variable.
 Constructor is invoked at the time of object creation. It
constructs the values i.e. data for the object that is why
it is known as constructor.
 Constructor is just like the instance method but it does
not have any explicit return type.
Characteristics or Rules for Constructor

1. Constructor name must be same as its class name

2. Constructor must have no explicit return type.
3.Constructor can have arguments
4.Constructor Can be overloaded.
5.Constructor should be public but it can have other
access specifier too.
5.Constructor will automatically invoke when you create
object of class using new keyword.
6.Constructor cannot be call explicitly.
7.Constructor cannot be inherited.
 Types Of Constructor
 There are two types of constructors:
 1) default constructor (no-arg constructor)
2) parameterized constructor
Remember Point:-
1)If you don’t provide any constructor in your class compiler
will provide default constructor.
2)moment add any constructor in class u will loose to get
default constructor from compiler.
3)Your class should have default constructor in case of
Inheritance
4)Same constructor can be call to other constructor using this
and derived class constructor using super
keyword
 Questions
 What If there is no constructor in a class, is compiler
automatically creates a default constructor?
 What default constructor do.
 What the use of parametrize constructor
 What the difference between constructor and methods.
 Does constructor can have void return type?
 Does copy constructor is available in java.
 What the alternative of copy constructor in java?
 Can constructor perform other tasks instead of
initialization?
 Static
 The static keyword is used in Java mainly for memory
management. We may apply static keyword with variables,
methods and blocks. The static keyword belongs to the class
rather than instance of the class.

The static can be:

1.variable (also known as class variable)

2.method (also known as class method)
3.block
 Static Variable
 If you declare any variable as static, it is known static
variable
 It is a variable which belongs to the class and not to object
instance.
 The static variable can be used to refer the common
property of all objects (that is not unique for
 each object) e.g. company name of employees,college name
of students etc.
 The static variable gets memory only once in class area at
the time of class loading.
 It can be initialize at the time of Object creation.
 Static Variable

 Static variables are initialized only once , at the start of the

execution . These variables will be initialized first, before the
initialization of any instance variables.
 A single copy to be shared by all instances of the class
 A static variable can be accessed directly by the class
name and doesn’t need any object.
 Syntax : <class-name>.<variable-name>.
 Static variable can be final to make constant.
 Syntax: public static final double RATE_OF_INT=15.5;
Static Variable Memory Diagram
 Static Method

 If you apply static keyword with any method, it is known as

static method.
 A static method belongs to the class rather than object of a
class.
 A static method can be invoked without the need for creating
an instance of a class.
 static method can access static data member and can change
the value of it.
 It is a method which belongs to the class and not to
the object(instance)
 A static method can access only static data. It can not
access non-static data (instance variables)
 Static Method

 A static method can call only other static methods and

can’t call a non-static method from it.
 A static method can be accessed directly by the class
name and doesn’t need any object but can be call by object.
 Syntax : <class-name>.<method-name>
 A static method cannot refer to “this” or “super” keywords in
anyway.
 main method is static , since it must be accessible for an
application to run , before any instantiation takes place.
 Static Block
The static block, is a block of statement inside a
Java class that will be executed when a class is first
loaded in to the JVM
class Test{
static {
//Code goes here
}
}
A static block helps to initialize the static data
members, just like constructors help to initialize instance
members
Questions

Que)Can we execute a program without main() method?

 This reference in java
 this keyword in Java is a special keyword which can be
used to represent current object or instance of any class in
Java.
 “this” can also call constructor of same class in Java and
used to call overloaded constructor.
 if used than it must be first statement in constructor
 this() will call no argument constructor.
 and this(parameter) will call one argument constructor
with appropriate parameter.
 Example continue in next slide
example
If member variable and local variable name conflict
than this can be used to refer member variable.
here is an example of this with member variable:

Here local variable interest and member variable

interest conflict which is easily resolve by referring
member variable as this.interest
this is a final variable in Java and you can not
assign value to this. this will result in compilation

you can call methods of class

by using this keyword as shown in
below example.
• this can be used to return object. this is a valid return
value.here is an example of using as return value.

• "this" keyword can not be used in static context i.e.

inside static methods or static initializer block.
if use this inside static context you will get compilation
error as shown in below example:
 this can also be passed as method parameters since it
represent current object of class.
 Java This can be used to get the handle of the current
class
Class className = this.getClass();
Though this can also be done by, Class className =
ABC.class; // here ABC refers to the class name and you
need to know that!
 Java - String Class

Strings, which are widely used in Java programming, are a

sequence of characters. In the Java programming language,
strings are objects.
The Java platform provides the String class to create and
manipulate strings.
Creating Strings:
The most direct way to create a string is to write:
String greeting = "Hello world!";
 String greeting = "Hello world!";
Whenever it encounters a string literal in your code, the
compiler creates a String object with its value in this case, "Hello
world!'.
As like any other object, you can create String objects by
using the new keyword and a constructor.
The String class has eleven constructors that allow you to
provide the initial value of the string using different sources
Note: The String class is immutable, so that once it
is created a String object cannot be changed. If
there is a necessity to make a lot of modifications to
Strings of characters then you should use String
Buffer & String Builder Classes.
Cont….
String Length:
Methods used to obtain information about an object are
known as accessor methods. One accessor method that you
can use with strings is the length() method, which returns the
number of characters contained in the string object.

String palindrome = "Dot saw I was Tod";

int len = palindrome.length();
System.out.println( "String Length is : " +
len );
o/p:- String Length is : 17
Concatenating Strings:
The String class includes a method for concatenating
two strings:
1) method concat
2) + operator

1) string1.concat(string2);
1) "My name is ".concat("Zara");
2) "Hello," + " world" + "!"
char charAt(int index)
Returns the character at the specified index.
int compareTo(Object o)
Compares this String to another Object.
int compareTo(String anotherString)
Compares two strings lexicographically.
int compareToIgnoreCase(String str)
Compares two strings lexicographically, ignoring case
differences.
String concat(String str)
Concatenates the specified string to the end of this string.
boolean contentEquals(StringBuffer sb)
Returns true if and only if this String represents the same
sequence of characters as the specified StringBuffer.
static String copyValueOf(char[] data)
Returns a String that represents the character
sequence in the array specified.
static String copyValueOf(char[] data, int offset, int
count)
Returns a String that represents the character
sequence in the array specified.
boolean endsWith(String suffix)
Tests if this string ends with the specified suffix.
boolean equals(Object anObject)
Compares this string to the specified object.

boolean equalsIgnoreCase(String anotherString)

Compares this String to another String, ignoring case
considerations.
byte getBytes()
Encodes this String into a sequence of bytes using the
platform's default charset, storing the result into a new
byte array.
byte[] getBytes(String charsetName
Encodes this String into a sequence of bytes using the
named charset, storing the result into a new byte
array.
int hashCode()
Returns a hash code for this string.
int indexOf(int ch)
Returns the index within this string of the first
occurrence of the specified character.
int indexOf(int ch, int fromIndex)
Returns the index within this string of the first
occurrence of the specified character, starting the
search at the specified index.
int indexOf(String str)
Returns the index within this string of the first
occurrence of the specified substring.
int indexOf(String str, int fromIndex)
Returns the index within this string of the first
occurrence of the specified substring, starting at the
specified index.
int lastIndexOf(int ch, int fromIndex)
Returns the index within this string of the last
occurrence of the specified character, searching
backward starting at the specified index.
int lastIndexOf(int ch, int fromIndex)
Returns the index within this string of the last
occurrence of the specified character, searching
backward starting at the specified index.
int lastIndexOf(String str)
Returns the index within this string of the rightmost
occurrence of the specified substring.
int lastIndexOf(String str, int fromIndex)
Returns the index within this string of the last
occurrence of the specified substring, searching
backward starting at the specified index.
int length()
Returns the length of this string.
boolean matches(String regex) :-Tells whether or not
this string matches the given regular expression.
String replace(char oldChar, char newChar) :-Returns a
new string resulting from replacing all occurrences of
oldChar in this string with newChar.
String replaceAll(String regex, String replacement
Replaces each substring of this string that matches the
given regular expression with the given replacement.
String replaceFirst(String regex, String replacement)
Replaces the first substring of this string that matches
the given regular expression with the given
replacement.
String[] split(String regex) :-Splits this string around
matches of the given regular expression.
boolean startsWith(String prefix) :-Tests if this string
starts with the specified prefix.
boolean startsWith(String prefix, int toffset) :-Tests if
this string starts with the specified prefix beginning a
specified index.
String substring(int beginIndex) :-Returns a new string
that is a substring of this string.
String substring(int beginIndex, int endIndex) :-Returns
a new string that is a substring of this string.

char[] toCharArray() :-Converts this string to a new

character array.
String toLowerCase() :-Converts all of the characters in
this String to lower case using the rules of the default
locale.
String toString() :-This object (which is already a
string!) is itself returned.
String toUpperCase() :-Converts all of the characters in
this String to upper case using the rules of the default
locale.
String trim() :-Returns a copy of the string, with
leading and trailing whitespace omitted.
static String valueOf([int][float][…….] x) :-Returns the
string representation of the passed data type
argument.

Continue with more details about

String later
 Inheritance

 Inheritance can be defined as the process where one object

acquires the properties of another.
 Inheritance is a mechanism in which one object
 acquires all the properties and behaviours of parent
 object.
 The idea behind inheritance is that you can create new
classes that are built upon existing classes.
 When you inherit from an existing class, you reuse (or inherit)
methods and fields.
 Inheritance represents the IS-A relationship.
 extends keyword is used to achieve inheritance.
 Inheritance Example

Animal is the superclass of Mammal class.

Animal is the superclass of Reptile class.
Mammal and Reptile are subclasses of Animal
class.
Dog is the subclass of both Mammal and Animal
classes.
 IS-A Relationship

Mammal IS-A Animal

Reptile IS-A Animal
Dog IS-A Mammal
Hence : Dog IS-A Animal as well
 Instanceof Operator
 The instanceof operator compares an object to a specified
type.
 You can use it to test if an object is an instance of a class,
an instance of a subclass, or an instance of a class that
implements a particular interface.
 The instanceof operator is also known as type
 comparison operator because it compares the instance with
type.
 It returns either true or false.
 If we apply the instanceof operator with any variable that
have null value, it returns false.
Instanceof Operator Example
 Types of Inheritance
 There exists basically three types of inheritance.
 Single Inheritance
 Multilevel inheritance
 Multiple inheritance
 Hierarchical inheritance
In single inheritance, one class extends one class
only.
In multilevel inheritance, the ladder of single
inheritance increases.
In multiple inheritance, one class directly extends more
than one class.
In hierarchical inheritance one class is extended by more
than one class.
Single Inheritance
Multilevel Inheritance
Multilevel Inheritance
 Multiple Inheritance
 In multiple inheritance, one class extends multiple classes.
Java does not support multiple inheritance but C++
supports. The above program can be modified to illustrate
multiple inheritance. The following program does not work.
class Aves { }
class Bird { }
class Parrot extends Aves, Bird { }
Note:-Java supports multiple inheritance partially through
interfaces.
Hierarchical Inheritance
 Disadvantages of Inheritance
 Both classes (super and subclasses) are tightly-coupled.
 As they are tightly coupled (binded each other strongly with
extends keyword), they cannot work independently of each
other.
 Changing the code in super class method also affects the
subclass functionality.
 If super class method is deleted, the code may not work as
subclass may call the super class method with super keyword.
Now subclass method behaves independently.-
 Aggregation In Java
 If a class have an entity reference, it is known as
Aggregation. Aggregation represents HAS-A relationship
 Consider a situation, Employee object contains many
informations such as id, name, emailld etc. It contains one
more object named address, which contains its own
informations such as city, state, country, zipcode etc. as
given below.
 Aggregation In Java
class Employee{
int id;
String name;
Address address;//Address is a class
}
In such case, Employee has an entity reference address, so
relationship is Employee HAS-A address.
Why use Aggregation?
Ans:-For Code Reusability.
 When use Aggregation?
♦ Code reuse is also best achieved by aggregation when there
is no is-a relationship.
♦ Inheritance should be used only if the relationship is-a is
maintained throughout the lifetime of the
objects involved; otherwise, aggregation is the best choice.
 Overriding
 In the previous chapter, we talked about super classes and
sub classes.
 If a class inherits a method from its super class, then there
is a chance to override the method provided that it is not
marked final.
 The benefit of overriding is: ability to define a behavior that's
specific to the subclass type which means a subclass can
implement a parent class method based on its requirement.
 In object-oriented terms, overriding means to override the
functionality of an existing method.
 Rules for method overriding:
 The argument list should be exactly the same as that of the
overridden method.
 The return type should be the same or a subtype of the return
type declared in the original overridden method in the
superclass.
 The access level cannot be more restrictive than the
overridden method's access level. For example: if the
superclass method is declared public then the overridding
method in the sub class cannot be either private or protected.
 Instance methods can be overridden only if they are inherited
by the subclass.
 Rules for method overriding:
 A method declared final cannot be overridden.
 A method declared static cannot be overridden but can be re-
declared.
 If a method cannot be inherited, then it cannot be overridden.
 A subclass within the same package as the instance's
superclass can override any superclass method that is not
declared private or final.
 A subclass in a different package can only override the non-
final methods declared public or protected.
 Rules for method overriding:
 An overriding method can throw any uncheck exceptions,
regardless of whether the overridden method throws
exceptions or not.
 However the overriding method should not throw checked
exceptions that are new or broader than the ones declared by
the overridden method. The overriding method can throw
narrower or fewer exceptions than the overridden method.
 Constructors cannot be overridden.
 Questions
1) Can we override static method?
No, static method cannot be overridden. It can be proved
by runtime polymorphism so we will learn it later.
2) Why we cannot override static method?
because static method is bound with class whereas
instance method is bound with object. Static belongs to class
area and instance belongs to heap area.
Compare Overloading and Overriding

Method Overloading Method Overriding

Method overloading is used Method overriding is used to
to provide the specific
increase the readability of implementation
the of the method that is already
program. provided by its super class.
method overlaoding is Method overriding occurs in
performed two classes that have IS-A
within a class. relationship.
In case of method In case of method overriding
overloading parameter must be same.
parameter must be
different.
Applying access modifier with method overriding

If you are overriding any method, overriden method (i.e. declared

in subclass) must not be
 more restrictive.
Access Levels are in sequence of
1)Private
2)Default
3)Protected
4)Public
Example
Cont.. Next page
 Covariant Return Type
 The covariant return type specifies that the return type may
vary in the same direction as the subclass.
 Before Java5, it was not possible to override any method by
changing the return type.
 But now, since Java5,it is possible to override method by
changing the return type if subclass overrides any method
whose return type is Non-Primitive but it changes its return
type to subclass type.
Let's take a simple example:
 super keyword
 The super is a reference variable that is used to refer
immediate parent class object.
 Whenever you create the instance of subclass, an instance of
parent class is created implicitely because it is referred by
super reference variable.
Usage of super Keyword:-
1. super is used to refer immediate parent class instance
variable.
2. super() is used to invoke immediate parent class
constructor.
3. super is used to invoke immediate parent class
method.
Restricting Inheritance

Parent

Inherited
capability

Child
Final Members: A way for Preventing Overriding of
Members in Subclasses

 All methods and variables can be overridden by default in

subclasses.
 This can be prevented by declaring them as final using the keyword
“final” as a modifier. For example:
 final int marks = 100;
 final void display();
 This ensures that functionality defined in this method cannot be
altered any. Similarly, the value of a final variable cannot be
altered.
Final Classes: A way for Preventing Classes being
extended

 We can prevent an inheritance of classes by other classes by

declaring them as final classes.
 This is achieved in Java by using the keyword final as follows:
final class Marks
{ // members
}
final class Student extends Person
{ // members
}
 Any attempt to inherit these classes will cause an error.
 Abstract Classes
 When we define a class to be “final”, it cannot be extended.
In certain situation, we want to properties of classes to be
always extended and used. Such classes are called Abstract
Classes.
 An Abstract class is a conceptual class.
 An Abstract class cannot be instantiated – objects cannot be
created.
 Abstract classes provides a common root for a group of
classes, nicely tied together in a package:
 Abstract Class Syntax
abstract class ClassName{
...
abstract Type MethodName1();
…
Type Method2()
{
// method body
}
}
 When a class contains one or more abstract methods,
it should be declared as abstract class.
 The abstract methods of an abstract class must be
defined in its subclass.
 We cannot declare abstract constructors or abstract
static methods.
 Abstract Class -Example
 Shape is a abstract class.

Shape

Circle Rectangle
 The Shape Abstract Class

public abstract class Shape {

public abstract double area();
public void move() { // non-abstract method
// implementation
}
}

 Is the following statement valid?

 Shape s = new Shape();
 No. It is illegal because the Shape class is an abstract
class, which cannot be instantiated to create its
objects.
 Abstract Classes
public Circle extends Shape {
protected double r;
protected static final double PI =3.1415926535;
public Circle() { r = 1.0; )
public double area() { return PI * r * r; }
…
}
public Rectangle extends Shape {
protected double w, h;
public Rectangle() { w = 0.0; h=0.0; }
public double area() { return w * h; }
}
 Abstract Classes Properties
 A class with one or more abstract methods is automatically
abstract and it cannot be instantiated.
 A class declared abstract, even with no abstract methods
can not be instantiated.
 A subclass of an abstract class can be instantiated if it
overrides all abstract methods by implementation them.
 A subclass that does not implement all of the superclass
abstract methods is itself abstract; and it cannot be
instantiated.
 Summary
 If you do not want (properties of) your class to be extended or
inherited by other classes, define it as a final class.
 Java supports this is through the keyword “final”.
 This is applied to classes.
 You can also apply the final to only methods if you do not want
anyone to override them.
 If you want your class (properties/methods) to be extended by
all those who want to use, then define it as an abstract class
or define one or more of its methods as abstract methods.
 Java supports this is through the keyword “abstract”.
 This is applied to methods only.
 Subclasses should implement abstract methods; otherwise,
they cannot be instantiated.
 Interface
 Since we have a good understanding of the extends keyword
let us look into how the implements keyword is used to get
the IS-A relationship.
 The implements keyword is used by classes by inherit from
interfaces. Interfaces can never be extended by the classes.
 An interface in the Java programming language is an abstract
type that is used to specify an interface that classes must
implement.
 Interface is a conceptual entity similar to a Abstract class.
 Can contain only constants (final variables) and abstract
method (no implementation) - Different from Abstract classes.
 Use when a number of classes share a common interface.
 Each class should implement the interface.
 Interface
 An interface is basically a kind of class—it contains methods
and variables, but they have to be only abstract classes and
final fields/variables.
 Therefore, it is the responsibility of the class that
implements an interface to supply the code for methods.
 A class can implement any number of interfaces, but cannot
extend more than one class at a time.
 Therefore, interfaces are considered as an informal way of
realising multiple inheritance in Java.
 Interface Example

<<Interface>>
Speaker
speak()

Politician Priest Lecturer

speak() speak() speak()
Interfaces Definition

• Syntax (appears like abstract class):

interface InterfaceName {
// Constant/Final Variable Declaration
• Example: // Methods Declaration – only method
body
}

interface Speaker {
public void speak( );
}
 Implementing Interfaces
• Interfaces are used like super-classes who properties are
inherited by classes. This is achieved by creating a class
that implements the given interface as follows:

class ClassName implements InterfaceName [, InterfaceName2, …]

{
// Body of Class
}
Implementing Interfaces Example
class Politician implements Speaker {
public void speak(){
System.out.println(“Talk politics”);
}
}
class Priest implements Speaker {
public void speak(){
System.out.println(“Religious Talks”);
}
}
class Lecturer implements Speaker {
public void speak(){
System.out.println(“Talks Object Oriented
Design and Programming!”);
}
}
 Extending Interfaces
• Like classes, interfaces can also be extended. The new sub-
interface will inherit all the members of the superinterface in
the manner similar to classes. This is achieved by using the
keyword extends as follows:

interface InterfaceName2 extends InterfaceName1 {

// Body of InterfaceName2
}
 Inheritance and Interface
Implementation
• A general form of interface implementation:

class ClassName extends SuperClass implements

InterfaceName [, InterfaceName2, …]
{
// Body
• This shows of Class
a class can extended another class while implementing
} or more interfaces. It appears like a multiple inheritance (if we
one
consider interfaces as special kind of classes with certain
restrictions or special features).
 Interface Cont..
 Interfaces are declared using the interface keyword.
 Interface may only contain method signature and constant
declarations (variable declarations that are declared to be
both static and final).
 An interface may never contain method definitions.
 Interfaces cannot be instantiated, but rather are implemented.
 A class that implements an interface must implement all of the
methods described in the interface, or be an abstract class.
 Interface Cont..
 Object references in Java may be specified to be of an
interface type.
 One benefit of using interfaces is that they simulate multiple
inheritance.
 All classes in Java must have exactly one base class because
multiple inheritance of classes is not allowed.
 A Java class may implement n number of interface.
 Interface may extends n number of interface.
Interface Example
Interface Example
 Polymorphism
 Polymorphism is the ability of an object to take on many
forms.
 The most common use of polymorphism in OOP occurs when
a parent class reference is used to refer to a child class
object.
 Any Java object that can pass more than one IS-A test is
considered to be polymorphic.
 In Java, all Java objects are polymorphic since any object will
pass the IS-A test for their own type and for the class Object.
 Polymorphism
 It is important to know that the only possible way to access an
object is through a reference variable.
 A reference variable can be of only one type.
 Once declared, the type of a reference variable cannot be
changed.
 The reference variable can be reassigned to other objects
provided that it is not declared final.
 The type of the reference variable would determine the
methods that it can invoke on the object.
 Polymorphism
 A reference variable can refer to any object of its declared
type or any subtype of its declared type.
 A reference variable can be declared as a class or interface
type.
refer example from next slide.
Polymorphism
 Method Overriding Cont..
1.Sub class can override the methods defined by the super class.
2.Overridden Methods in the sub classes should have same name,
same signature , same return type and may have either the same or
higher scope than super class method.
3.Java implements Run Time Polymorphism/ Dynamic Method
Dispatch by Method Overriding. [Late Binding]
4.Call to Overridden Methods is Resolved at Run Time.
5.Call to a overridden method is not decided by the type of reference
variable Rather by the type of the object where reference variable is
pointing.
6.While Overriding a Method, the sub class should assign either same
or higher access level than super class method.
class A EXAMPLE METHOD OVERRIDING
{
void show()
{
System.out.println("Hello This is show() in A");
}// End of show() Method
} // End of class A B class overrides show()
class B extends A method from super class A
{
void show()
{
System.out.println("Hello This is show() in B");
}// End of show() Method class override
} // End of class B {
public static void main(String args[])
{
Call to
// super class reference variable
show() of A
// can point to sub class object
class
A a1 = new A();
a1.show();
Call to a1 = new B();
show() of B a1.show();
class }
}
 Is this Method
class A Overriding class override1
{ {
void show(int a) public static void
NO
{ main(String args[])
System.out.println("Hello This {
is show() in A"); /*
} A a1 = new B();
} a1.show(); */
class B extends A
{ A a1 = new A();
void show() a1.show(10);
{
System.out.println("Hello This B b1 = new B();
is show() in B"); b1.show(10);
} b1.show(); }
}
OUTPUT
Hello This is show() in A
Hello This is show() in A
Hello This is show() in B
 Dynamic Method Dispatch

1.Super class reference variable can refer to a sub class

object.
2.Super class variable if refers to sub class object can
call only overridden methods.
3.Call to an overridden method is decided by the type of object
referred to.

A
A a1 = new B();
a1.show(); // call to show() of B
a1 = new C();
a1.show(); // call to show() of C B C D
a1 = new D();
a1.show(); // call to show() of D Assume show()
Method is
Overridden by sub
class A
{ DYNAMIC METHOD DISPATCH
void show() class C extends A
{ {
System.out.println("He void show()
llo This is show() in {
A"); System.out.println("H
} ello This is show() in
} C");
class B extends A }
{ }
void show() class D extends A
{ {
System.out.println("He void show()
llo This is show() in {
B"); System.out.println("H
} ello This is show() in
} D");
} CONTINUED…..
class override2
{
public static void main(String
args[])
{ Hello This is show() in A
A a1 = new A(); Hello This is show() in B
a1.show(); Hello This is show() in C
a1 = new B(); Hello This is show() in D
a1.show();
a1 = new C();
a1.show();
a1 = new D();
a1.show();
}
}
class override3
{
public static void main(String args[])
{
A a1 = new B();
B b1 = (B) a1;

/*
A a1 = new B();
C c1 = (C) a1;

Exception in thread "main"

java.lang.ClassCastException: B
at override3.main(override3.java:39)
*/
}
}
 Examples Overriding

class A A a1 = new B();

{ a1.show() ; // Valid
void show() { …. } // a1.show(10); // Invalid
} //a1.print(); // Invalid
class B extends A
{
void show() { …. }
void show(int x) { … }
void print() { … }
}
When a super class variable points to a sub
class object, then it can only call overridden
methods of the sub class.
class A
{
protected void show()
{
System.out.println("Hi"); D:\Java1>javac AB.java
} AB.java:10: show() in B
} cannot override show()
class B extends A in A; attempting to
{ assign weaker
void show() access privileges; was
{ protected
System.out.println("Hi"); void show()
} ^
} 1 error
 IS THIS METHOD
class A{
OVERRIDING
private void show(){
System.out.println("Hi");
}
}

class B extends A{ NO
int show(){
System.out.println("Hi"); CODE WILL
return 10; COMPILE & RUN
} SUCESSFULLY
}
class A{ What’s Wrong Here
static int show(){
System.out.println("class A");
return 0;
}
}
sample.java:12: show()
class B extends A{ in B cannot override
void show(){ show() in A; overridden
System.out.println("class B");method is static
} void show()
} ^
1 error
 Nested Classes
Java programming language allows you to
define a class within another class
Enclosing
class OuterClass Class OR
{ ... Outer Class
A nested class is a member
class NestedClass { ... of
} its enclosing class

}
Nested
Class
1.Nested has access to other members of the
enclosing class,even if they are declared private
2. Can be private, public, protected or friendly
access
 Nested Class Types
Static nested classes
1.Static keyword applied for class declaration
2.Static nested class can use the instance fields/methods
of the outer class only through object reference.
3.Static nested class can be accessed
OuterClass.StaticNestedClass
4. To create an object for the static nested class, use this
syntax:
OuterClass.StaticNestedClass nestedObject = new
OuterClass.StaticNestedClass();
 Nested Class Types cont..
• Non-Static nested classes
1.These nested classes do not have static keyword
applied
2.Non-Static nested class can use the instance
fields/methods of the outer class directly.
3. To create an object for the non-static nested class, use
this syntax:
OuterClass.NestedClass nestedObject =
Outerobjectreference. new innerclass();

Inner class instance

can
only exists inside
Outer class instance.
 Example 1 [Non-static Nested Class]

class A class B
{ {
private int a;Outer Class int b; Nested
A(int a) B(int b) class with
{ { friendly
this.a =a; int c = b+10;
access
} this.b = c;
void print() }
{ void show()
System.out.println( {
"a="+a); print();
}
Call to System.out.println("b="+b);
print() of }
outer class } // End of class B
} // End of class A
 Example 1 [Non-static Nested Class]
cont….
class innertest1
{
Inner class Name
public static void main(String args[])
{ Outer class Reference
A a1 = new A(10);
To create an inner class
A.B b1 = a1.new B(100); instance for non-static classes
you need an outer class
b1.show();
reference.
} Inner class Reference
}
Outer class Name

If class B is Private then it is not visible in

main().
A.B b1 = a1.new B(100); is WRONG/INVALID
Example 2
class A
{ Outer class
private int a;
private int b=10; Nested Inner class
class B [Non-static Type]
A(int a)
{
{
this.a=a;
private int b; Instance Field of B
B(int b)
}
{
this.b =b;
} Outer Class A’s a
void show()
{
int b=20;
System.out.println("a="+a);
Local b System.out.println("b="+b);
B’s instance System.out.println("this.b="+this.b);
System.out.println("Outer b="+A.this.b);
A’sField b
instance Field b }
} // End of B inner class
void show()
{
B b1 = new B(30);
b1.show();
}
} // End of Outer class A
class innerTest
{
public static void main(String args[])
{
// Create an inner class B's instance
// Call show() method

// STEP 1
// Create an Outer Instance first

A a1 = new A(20); a=20

A.B b1 = a1.new B(-30); b=20
b1.show(); this.b=-30
Outer b=10
// inner class object instantiation thru anonymous outer
// reference
A.B b2 = new A(30).new B(-40);
b2.show(); a=30
} b=20
} this.b=-
40
Outer
 Static Inner class / Static Nested class Example

static class B
class A {
{ int b;
private int a; B(int b)
A(int a) Static inner
{
{ class
int c = b+10;
this.a =a; this.b = c;
} }
void print() void show()
{ {
System.out.println( // print(); INVALID
"a="+a); A a1 = new A(10);
} a1.print();
Static nested class can System.out.println("b="+b);
refere to outer } } // End of class B
members only through } // End of class A
outer reference
 Example cont….

class innertest10
{
public static void main(String
args[])
{
A.B b1 = new A.B(100);
Instance of
b1.show();
static Inner
}
class
}
 Static Nested class
class A{
private int a;
Example 2
protected static int b=10;
A(int a){
this.a=a;
}
public void show()
{
System.out.println("a="+a);
display();
}
public static void display()
{
System.out.println("b="+b);
}
}
 Example 2 cont….
static class B {
private int a;
protected static int b=100;
B(int a){
this.a=a;
}
void show(){
// A.this.show(); // Won't work show() is non-static in outer
display(); // Will work as method is static in outer
System.out.println("a="+a);
// System.out.println("a="+A.this.a);
// Won't work a is non-static in outer
System.out.println("b="+b); // Will refer to its own b
System.out.println("A'sb="+A.b); // will refer to outer class B
new A(40).show();
// This is how you can call non static methods of outer
}
} // End of inner class B
} // End of class A
 Example 2 cont….
class innerTest1
{
public static void main(String args[])
{
A.B b1 = new A.B(-30);
b1.show();
} D:\jdk1.3\bin>java innerTest1
} b=10
a=-30
b=100
A'sb=10
a=40
b=10
 Local Inner classes [ Classes Within
method body]Class declared within a
method body.
Here method is show()
class A Local inner classes Can not be
{ declared as public,private or
private int a; protected
protected static int b=10;
A(int a)
1.Class B is visible only in method
{
show().
this.a=a;
2.It can be used within this show()
}
method only
void show()
3.Local inner classes can only use final
{
variables from its enclosing method.
class B
4.However inner classes can refer to
{}
its fields of enclosing class.
}
}
class A
{ D:\jdk1.3\bin>javac
private int a; innerTest2.java
protected static int b=10; innerTest2.java:23: local
A(int a) variable x is accessed from
{ within inner class;
this.a=a; to be declared final
}
System.out.println("x="+x);
void show()
{
^
int x=10; 1 error
class B
{
private int b;
B(int b)
{ Reference for A’s a
this.b=b;
} Reference for B’s b
void display()
{ Reference is wrong /
System.out.println("a="+a); errorneous
System.out.println("b="+b); ‘x’ is local variable inside
System.out.println("x="+x); the local method. Local
} classes can use only final
} // End of class B fields from enclosing
method
} // End of show() method
class innertest class A
{ {
public static void private int a;
private int b;
main(String args[]) int c;
{ A(int a)
final int a1=10; {
this.a =a;
new A(20).show();
b = a+20;
print();
c = a+40;
}// End of main
}
static void print()
void show()
{
{
/*
System.out.println("a1="+a1);
A a1 = new A(30);
System.out.println("a="+a);
a1.show();
System.out.println("b="+b);
*/
System.out.println("c="+c);
System.out.println("Hello"
}
);
} //End of A
}
}
OUTPUT

E:\oop>java
innertest
a1=10
a=20
b=40
c=60
Hello
 Anonymous Inner classes

 Another category of local inner classes

 Classes without any name i.e classes having no name
 Can either implements an interface or extends a class.
 Can not have more than one instance active at a time.
 Whole body of the class is declared in a single statement ending
with ;
 Cont…
 Syntax [ If extending a class]
 [variable_type_superclass =] new
superclass_name() {
 // properti
es and methods
} [;]
 Syntax [ If implementing an interface]
 [variable_type_reference =] new
reference_name() {
 // properti
es and methods
} [;]
 Anonymous Inner Class
class A Example
{
private int a;
A(int a)
{
this.a =a;
}
void show()
{
System.out.println("a="+a);
} // End of show()
}// End of class A
class innertest1
{
public static void main(String args[])
{
Anonymous inner class extending super class A
A a1 = new A(20){
public void show()
{
super.show();
System.out.println("Hello");
}
public void display()
{
System.out.println("Hi");
}
};
a1.show();
// a1.display();
} Calling show from
} inner class
interface X{
int sum(int a,int b);
int mul(int x,int y);
}
class innertest2{
public static void main(String args[]){

X x1 = new X()
{ Anonymous inner class implementing an
public int sum(int a,int b)
interface
{
return a+b;
}
public int mul(int a,int b)
{
return a*b;
}
};
System.out.println(x1.sum(10,20));
System.out.println(x1.mul(10,20));
}// End of main
}// End of innertest2