Need for OOP Paradigm

 OOP is an approach to program organization and development,

which attempts to eliminate some of the drawbacks of conventional
programming methods by incorporating the best of structured
programming features with several new concepts.

 OOP allows us to decompose a problem into number of entities

called objects and then build data and methods (functions) around
these entities.

 The data of an object can be accessed only by the

methods
associated with the object.
Introduction
⚫ Object-oriented programming (OOP) is a programming
paradigm that uses “Objects “and their interactions to design
applications.

⚫ It simplifies the software development and maintenance

by
providing some concepts:

⚫ Object
⚫ Class
⚫ Data Abstraction & Encapsulation
⚫ Inheritance
⚫ Polymorphism
⚫ Dynamic Binding
Object
⚫Objects are the basic run time entities in an object-
oriented system. They may represent a person, a place,
a bank account, a table of data or any item that the
program has to handle.
Class
⚫ The entire set of data and code of an object can be made of a
user defined data type with the help of a class.
⚫ In fact, Objects are variables of the type class. Once a class has
been defined, we can create any number of objects belonging to
that class.
⚫ Classes are data types based on which objects are created.
Objects with similar properties and methods are grouped
together to form a Class. Thus a Class represents a set of
individual objects.
⚫ Characteristics of an object are represented in a class as
Properties. The actions that can be performed by objects
become functions of the class and is referred to as
Methods.
⚫
A class is thus a collection of objects of similar type .
for example: mango, apple, and orange are members of
the class fruit . ex: fruit mango; will create an object
mango belonging to the class fruit.
Example for
class
⚫ class Human

⚫{

private:

⚫ EyeColor IColor;

⚫ NAME personname;

⚫ public:

⚫ void SetName(NAME anyName);

⚫ void SetIColor(EyeColor eyecolor);

⚫ };
 Data abstraction
⚫ Abstraction refers to the act of representing essential features
without including the background details or explanations. since the
classes use the concept of data abstraction ,they are known as
abstraction data type(ADT).

For example, a class Car would be made up of an Engine, Gearbox,

Steering objects, and many more components. To build the Car
class, one does not need to know how the different components
work internally, but only how to interface with them, i.e., send
messages to them, receive messages from them, and perhaps make
the different objects composing the class interact with each other.
 An example for abstraction
⚫ Humans manage complexity through abstraction. When you

drive your car you do not have to be concerned with the

exact internal working of your car(unless you are a
mechanic). What you are concerned with is interacting
with your car via its interfaces like steering wheel, brake
pedal, accelerator pedal etc. Various manufacturers of car
has different implementation of car working but its basic
interface has not changed (i.e. you still use steering wheel,
brake pedal, accelerator pedal etc to interact with your car).
Hence the knowledgeyou have of your car is abstract.
 Methods
⚫ A method is a group of instructions that is given a name and can be
called up at any point in a program simply by quoting that name.
⚫ Drawing a Triangle require draw of three straight lines. This
instruction three times to draw a simple triangle.
⚫ We can define a method to call this instruction three times and draw
the triangle(i.e. create a method drawLine() to draw lines and this
method is called repeatedly to achieve the needed task)
⚫ The idea of methods appears in all programming languages, although
sometimes it goes under the name functions and sometimes under
the name procedures.
⚫ The name methods is a throw-back to the language C++, from which
Java was developed.
⚫ In C++, there is an object called a class which can contain methods.
However, everything in Java is enclosed within a class .so the
functions within it are called methods
CLASSES
• Class is blue print or an idea of an Object
• From One class any number of Instances can be created
• It is an encapsulation of attributes and methods

class
FIGUR
Ob1
E
Ob3

CIRCL Ob SQUARE
E 2
RECTANG
LE
syntax of CLASS

class <ClassName>
{
attributes/variables;
Constructors()
; methods();
}
INSTANCE
• Instance is an Object of a class which is an entity with its
own
attribute values and methods.

• Creating an Instance

ClassName

refVariable;
refVariable = new
Constructor();
or
ClassName
refVariable = new
Java Class Hierarchy
• In Java, class “Object” is the base class to all other classes
– If we do not explicitly say extends in a new class
definition,
it implicitly extends Object

– The tree of classes that extend from Object and all of

its subclasses are is called the class hierarchy

– All classes eventually lead back up to Object

– This will enable consistent access of objects of different

classes.
Inheritance
⚫ Methods allows to reuse a sequence of statements

⚫ Inheritance allows to reuse classes by deriving a new class

from an existing one

⚫ The existing class is called the parent class, or superclass, or

base class

⚫ The derived class is called the child class or subclass.

⚫ The child class inherits characteristics of the parent class(i.e

the child class inherits the methods and data defined for the
parent class
Inheritance
⚫ Inheritance relationships are often shown graphically
in a class diagram, with the arrow pointing to the
parent class

Animal
weight : int

+ getWeight() : int

Bird

+ fly() : void
Method Overriding.
 There may be some occasions when we want an object to
respond to the same method but have different behavior
when that method is called.
 That means, we should override the method defined in the
super class. This is possible by defining a method in a sub class
that has the same name, same arguments and same return
type as a method in the super class.
 Then when that method is called, the method defined in the
sub class is invoked and executed instead of the one in the
super class. This is known as overriding.
Exceptions in Java
• Exception is an abnormal condition that arises in the
code sequence.
• Exceptions occur during compile time or run time.
• “throwable” is the super class in exception hierarchy.
• Compile time errors occurs due to incorrect syntax.
• Run-time errors happen when
– User enters incorrect input
– Resource is not available (ex. file)
– Logic error (bug) that was not fixed
 Abstraction in Object-Oriented Programming
Procedural Abstraction
• Procedural Abstractions organize
instructions.

Function Power
Give me two numbers (base & exponent)
I’ll return baseexponent

Implementation
Data Abstraction
• Data Abstractions organize data.

StudentTy
pe
Name (string)

Marks (num)

Grade (char)

Student Number
(num)
Data
Types
⚫ Java defines eight simple types:
1)byte – 8-bit integer type
2)short – 16-bit integer type 3)int
– 32-bit integer type
4)long – 64- bit integer
type
5)float – 32-bit floating-point
type 6)double – 64-bit floating-
point type 7)char – symbols in
a character set
8)boolean – logical values true
 Variable
Declaration
⚫ We can declare several variables at the
same time: type identifier [=value][,
identifier [=value] …];
Examples:
int a, b, c;
int d = 3, e, f
= 5; byte g
= 22;
double pi =
3.14159; char
ch = 'x';
L
2.4
 Variable
⚫
Scope
Scope determines the visibility of program elements
with respect
to other program elements.
⚫ In Java, scope is defined separately for classes and
methods:
1)variables defined by a class have a global scope
2)variables defined by a method have a
local scope A scope is defined by a block:
{
…
}
A variable declared inside the scope is
not visible outside:
{
int n;
}
n = 1;// this is illegal
 Array
s
⚫ An array is a group of liked-typed variables
referred to by a common
⚫ name, with individual variables accessed by
their index.
⚫ Arrays are:
1)declared
2)created
3)initialized
4)used
⚫ Also, arrays can have one or several
dimensions.
Array
Declaration
⚫ Array declaration involves:
1)declaring an array identifier
2)declaring the number of dimensions
3)declaring the data type of the array
elements
⚫ Two styles of array declaration:
type array-variable[];
or
type [] array-variable;
L
2.8
Array Creation
⚫ After declaration, no array actually
exists.
⚫In order to create an array, we
use the new operator:
type array-variable[];
array-variable = new
type[size];
⚫This creates a new array to hold size
elements of type type, which
reference will be kept in the variable
Array
Indexing
⚫ Later we can refer to the elements of this
array through their indexes:
⚫ array-variable[index]
⚫ The array index always starts with zero!
⚫ The Java run-time system makes sure that all
array indexes are in the correct range,
otherwise raises a run- time error.
Array
Initialization
⚫ Arrays can be initialized when they are
declared:
⚫ int monthDays[] =
{31,28,31,30,31,30,31,31,30,31,30,31};
⚫ Note:
1)there is no need to use the new operator
2)the array is created large enough to hold
all specified elements
Operators
Types
⚫ Java operators are used to build value
expressions.
⚫ Java provides a rich set of operators:
1)assignment
2)arithmetic
3)relational
4) logical
5)bitwise

L
2.13
Arithmetic assignments
+= v += expr; v = v + expr ;

-= v -=expr; v = v - expr ;

*= v *= expr; v = v * expr ;

/= v /= expr; v = v / expr ;

%= v %= expr; v = v % expr ;
Basic Arithmetic Operators
+ op1 + op2 ADD

- op1 - op2 SUBSTRACT

* op1 * op2 MULTIPLY

/ op1 / op2 DIVISION

% op1 % op2 REMAINDER

L
2.15
Relational
operator
== Equals to Apply to any type

!= Not equals to Apply to any type

> Greater than Apply to numerical

type

< Less than Apply to numerical

type

>= Greater than or equal Apply to numerical

type

<= Less than or equal Apply to numerical

type
Logical operators
& op1 & op2 Logical AND

| op1 | op2 Logical OR

&& op1 && op2 Short-

circuit
AND
|| op1 || op2 Short-circuit
OR
! ! op Logical NOT

^ op1 ^ op2 Logical XOR

L
2.17
Selection Statements

⚫Java selection statements allow to

control the flow of program’s execution
based upon conditions known only
during run-time.
⚫ Java provides four selection statements:
1)if
2)if-else
3)if-else-if
4)switch
Iteration Statements
⚫ Java iteration statements enable repeated
execution of part of a program until a
certain termination condition becomes true.
⚫ Java provides three iteration statements:
1)while
2)do-while
3)for

L
3.3
Jump Statements

⚫ Java jump statements enable transfer of

control to other parts of program.
⚫ Java provides three jump statements:
1)break
2)continue
3)return
⚫ In addition, Java supports exception
handling that can also alter the control f
low of a program.
 Simple Java Program

⚫ A class to display a simple

message: class MyProgram
{
public static void
main(String[] args)
{
System.out.println(“First
Java program.");
}
}
What is an
Object?
⚫ Real world objects are things that
have:
1)state
2)behavi
or
Example
: your
dog:
⚫state – name, color, breed, sits?,
barks?, wages tail?, runs?
⚫ behavior – sitting, barking, waging
What is a Class?

⚫ A class is a blueprint that defines the

variables and methods common to all
objects of a certain kind.
⚫ Example: ‘your dog’ is a object of the
class Dog.
⚫ An object holds values for the variables
defines in the class.
⚫ An object is called an instance of the Class

L
4.3
Object Creation

⚫A variable is declared to refer to the

objects of type/class String:
String s;
⚫Thevalue of s is null; it does not yet
refer to any object.
⚫A new String object is created in
memory with initial “abc” value:
⚫ String s = new String(“abc”);
⚫ Now s contains the address of this
new object.
Object Destruction

⚫ A program accumulates memory

through its execution.
⚫ Two mechanism to free memory that is no
longer need by the program:
1)manual – done in C/C++
2)automatic – done in Java
⚫ In Java, when an object is no longer
accessible through any variable, it is
eventually removed from the memory by the
garbage collector.
⚫ Garbage collector is parts of the Java
Run-Time Environment.
L
4.5
Class

⚫ A basis for the Java language.

⚫ Each concept we wish to describe in
Java must be included inside a class.
⚫ A class defines a new data type, whose
values are objects:
⚫ A class is a template for objects
⚫ An object is an instance of a class
Class Definition

⚫ A class contains a name, several variable

declarations (instance variables) and several
method declarations. All are called members
of the class.
⚫ General form of a class:
class classname {
type instance-variable-1;
…
type instance-variable-n;
type method-name-1(parameter-list)
{…}
type method-name-2(parameter-list)
{…}
…
type
L
method-name-m(parameter-list)
4.7
 Example: Class Usage
class Box {
double
width;
double
height;
double
depth;
}
class
BoxDemo {
public static
void
main(String
args[]) {
Box mybox = new
Box(); double vol;
mybox.width = 10;
mybox.height = 20;
 Constructor
⚫ A constructor initializes the instance variables of
an object.
⚫ It is called immediately after the object is created
but before the new operator completes.
1)it is syntactically similar to a method:
2)it has the same name as the name of its
class
3)it is written without return type; the
default return type of a class
⚫ constructor is the same classWhen the class has
no constructor, the default constructor
automatically initializes all its instance variables
with zero.
Example: Constructor

class Box {
double
width;
double
height;
double
depth;
Box() {
System.out.
println("Co
nstructing
Box");
width = 10;
height = L
5.2
Parameterized Constructor
class Box {
double
width;
double
height;
double
depth;
Box(double w, double h,
double d) { width = w;
height = h; depth = d;
}
double volume()
{ return width * height *
Methods

⚫ General form of a method

definition: type
name(parameter-list) {
…
ret
ur
n
val
ue;
…
}
⚫ Components:
1)type - type of values returned by the method. If
a method does not return any value, its return
type must be void.
2) name is the
L name of the method
5.4
 Example: Method
⚫Classes declare methods to hide their internal
data structures, as well as for their own
internal use: Within a class, we can
refer directly to its member variables:
class Box {
double width, height, depth;
void volume()
{ System.out.print("Volu
me is ");
System.out.println(width
* height * depth);
Parameterized
Method
⚫Parameters increase generality and
applicability of a method:
⚫ 1) method without parameters
int square() { return 10*10; }
⚫ 2) method with parameters
int square(int i) { return i*i; }
⚫Parameter: a variable receiving value
at the time the method is invoked.
⚫Argument: a value passed to the method
when it is invoked.

L
5.6
 Access Control: Data
Hiding and
• Encapsulation
Java provides control over the visibility
of variables and methods.
• Encapsulation, safely sealing data within
the capsule of the class Prevents
programmers from relying on details of
class implementation, so you can update
without worry
• Helps in protecting against accidental
or wrong usage.
• Keeps code elegant and clean (easier
to maintain)
 Access Modifiers: Public,
Private,
Protected
• Public: keyword applied to a class,
makes it available/visible everywhere.
Applied to a method or variable,
completely visible.
• Default(No visibility modifier is
specified): it behaves like public in its
package and private in other
packages.
• Default Public keyword applied to a
class, makes it available/visible
everywhere. Applied to a method or
variable, completely visible.
L
6.2
⚫ Private fields or methods for a class only
visible within that class. Private members are
not visible within subclasses, and are not
inherited.
⚫ Protected members of a class are visible
within the class, subclasses and also within
all classes that are in the same package as
that class.
 Visibilit
public class Circle {
y
private double x,y,r;

// Constructor
public Circle (double x, double y, double r)
{ this.x = x;
this.y = y; this.r
= r;
}
//Methods to return circumference and area
public double circumference() { return 2*3.14*r;}
public double area() { return 3.14 * r * r; }
}
L
6.4
String Handling
⚫String is probably the most commonly used
class in Java's class library. The obvious
reason for this is that strings are a very
important part of programming.
⚫The first thing to understand about
strings is that every string you create is
actually an object of type String. Even
string constants are actually String
objects.
⚫ For example, in the statement
System.out.println("This is a
String, too");
the string "This is a String, too" is
⚫ Java defines one operator for String
objects: +.
⚫ It is used to concatenate two strings. For
example, this statement
⚫ String myString = "I" + " like "
+ "Java."; results in myString
containing
"I like Java."

L
8.4
⚫ The String class contains several methods that
you can use. Here are a few. You can
⚫ test two strings for equality by using
equals( ). You can obtain the length of a string by
calling the length( ) method. You can obtain the
character at a specified index within a string by
calling charAt( ). The general forms of these
three methods are shown here:
⚫ // Demonstrating some String
methods. class StringDemo2 {
public static void main(String
args[]) { String strOb1 =
"First String";
String strOb2 = "Second
String"; String strOb3 =
strOb1;
System.out.println("Length of strOb1:
"+
System.out.println ("Char at index 3 in
strOb1: " +
strOb1.charAt(3));
if(strOb1.equals(strOb2))

System.out.println("strOb1 ==
strOb2"); else
System.out.println("strOb1 !=
strOb2");
if(strOb1.equals(strOb3))
System.out.println("strOb1 ==
strOb3"); else
System.out.println("strOb1 !=
strOb3");
}}

This program generates the

following output:
Length of strOb1: 12
Char at index 3 in strOb1: s
strOb1 !=
strOb2
Inheritance
⚫ Methods allows a software developer to reuse a
sequence of statements
⚫ Inheritance allows a software developer to
reuse classes by deriving a new class from an
existing one
⚫ The existing class is called the parent class, or
superclass, or base class
⚫ The derived class is called the child class or
subclass.
⚫ As the name implies, the child inherits
characteristics of
the parent
⚫ That is, the child class inherits the methods
and data
defined for the parent class 10
I⚫nInhheerirtaintcae nrelcateionshi
ps are often shown graphically in a
class diagram, with the arrow
pointing to the parent class
Animal
weight : int
Inheritance
+ getWeight() : int
should create
an is-a
relationship,
Bird meaning the
child is a
more specific
+ fly() : void version of
the parent 10
Deriving Subclasses
⚫ In Java, we use the reserved word extends to
establish an inheritance relationship
class Animal
{
// class contents
int weight;
public void int getWeight() {…}
}

class Bird extends Animal

{
// class contents
public void fly() {…};
}

10
Class
⚫
Hierarchy
A child class of one parent can be the parent
of another
child, forming class hierarchies
Animal

Reptile Bird Mammal

Snake Lizard Parrot Horse Bat

 At the top of the hierarchy there’s a default

class 1
Class Hierarchy
⚫ Good class design puts all common features as
high in the hierarchy as reasonable
⚫ inheritance is transitive
⚫ An instance of class Parrot is also an instance of Bird,
an instance of Animal, …, and an instance of class
Object
⚫ The class hierarchy determines how methods
are executed:
⚫ Previously, we took the simplified view that when
variable v is an instance of class C, then a procedure
call v.proc1() invokes the method proc1() defined in
class C
⚫ However, if C is a child of some superclass C’ (and
hence v is both an instance of C and an instance of C’),
the picture becomes more complex, because methods 1
Defining Methods in the Child Class:
Overriding by Replacement
⚫ A child class can override the definition of an inherited
method in
favor of its own
⚫ that is, a child can redefine a method that it inherits from
its parent
⚫ the new method must have the same signature as the
parent's method,
but can have different code in the body

⚫ In java, all methods except of constructors override the

methods of their ancestor class by replacement. E.g.:
⚫ the Animal class has method eat()
⚫ the Bird class has method eat() and Bird extends Animal
⚫ variable b is of class Bird, i.e. Bird b = …
⚫ b.eat() simply invokes the eat() method of the Bird class

⚫ If a method is declared with the final modifier, it

cannot be
overridden 1
Defining Methods in the Child Class:
Overriding by Refinement
⚫ Constructors in a subclass override the definition of an inherited
constructor
method by refining them (instead of replacing them)
- Assume class Animal has constructors
Animal(), Animal(int weight), Animal(int weight, int livespan)
- Assume class Bird which extends Animal has constructors
Bird(), Bird(int weight), Bird(int weight, int livespan)

- Let’s say we createa Bird object, e.g. Bird b = Bird(5)

- This will invoke first theconstructorof the Animal (thesuperclass of
Bird) and
then the constructorof the Bird

⚫ This is called constructor chaining: If class C0 extends C1 and

C1 extends C2 and … Cn-1 extends Cn = Object then when
creating an instanceof object C0 first constructor of Cn is
invoked, then constructors of Cn-1, …, C2, C1, and finally the
constructorof C
- The constructors (in each case) arechosen by theirsignature, e.g.
(), (int), etc…
- If no constructor with matching signature is found in any of the class Ci
for i>0 then the default constructor is executed for that class
- If no constructor with matching signature is found in the class C0 then this
Recap:
⚫
Class Hierarchy
In Java, a class can extend a single other
class
(If none is stated then it implicitly extends an
Animal
Object class)

Reptile Bird Mammal

Snake Lizard Parrot Horse Bat

 Imagine what would happen to method

handling rules if every class could extend
two others… 1
Hierarchical Abstraction
⚫ An essential element of object-oriented
programming is
abstraction.

⚫ Humans manage complexity through abstraction.

For example, people do not think of a car as a
set of tens of thousands of individual parts.
They think of it as a well- defined object with its
own unique behavior.

⚫ This abstraction allows people to use a car

without being overwhelmed by the complexity of
the parts that form the car. They can ignore the
details of how the engine, transmission, and
braking systems work.

⚫ Instead they are free to utilize the object as a

Class
⚫
Hierarchy
A child class of one parent can be the parent
of another child, forming class hierarchies

Animal

Reptile Bird Mammal

Snake Lizard Parrot Horse Bat

 At the top of the hierarchy there’s a default class called Object.

Class Hierarchy
⚫ Good class design puts all common features
as high in the hierarchy as reasonable

⚫ The class hierarchy determines how

methods are
executed

⚫ inheritance is transitive
⚫ An instance of class Parrot is also an
instance of Bird, an instance of Animal, …,
and an instance of class Object
Base Class Object
⚫ In Java, all classes use inheritance.
⚫ If no parent class is specified explicitly, the base class Object is
implicitly inherited.
⚫ All classes defined in Java, is a child of Object class, which provides
minimal functionality guaranteed to e common to all objects.
⚫ Methods defined in Object class are;
1. equals(Object obj): Determine whether the argument object is the
same as the receiver.
2. getClass(): Returns the class of the receiver, an object of type Class.
3. hashCode(): Returns a hash value for this object. Should be
overridden when the equals method is changed.
4. toString(): Converts object into a string value. This method is
also often overridden.
Base class
1)a class obtains variables and methods from another
class
2)the former is called subclass, the latter super-class
(Base class)
3)a sub-class provides a specialized behavior with
respect to its super-class
4)inheritance facilitates code reuse and avoids
duplication of
data

Allows to extend rom only one class
class Two extends One
Extends
f class One
{ int { from another class
 Is a keyword used to inherit a class

a=5; int b=10;

} }
Subclass, Subtype and Substitutability
⚫ A subtype is a class that satisfies the principle of
substitutability.
⚫ A subclass is something constructed using inheritance,
whether or not it satisfies the principle of substitutability.
⚫ The two concepts are independent. Not all subclasses are
subtypes, and (at least in some languages) you can
construct subtypes that are not subclasses.
⚫ Substitutability is fundamental to many of the powerful
software development techniques in OOP.
⚫ The idea is that, declared a variable in one type may hold
the value of different type.
⚫ Substitutability can occur through use of inheritance,
whether using extends, or using implements keywords.
 Subclass, Subtype, and Substitutability
When new classes are constructed using inheritance, the argument
used to justify the validity of substitutability is as follows;
• Instances of the subclass must possess all data fields associated
with its parent class.
• Instances of the subclass must implement, through inheritance
at least, all functionality defined for parent class. (Defining new
methods is not important for the argument.)
• Thus, an instance of a child class can mimic the behavior of the
parent class and should be indistinguishable from an instance of
parent class if substituted in a similar situation.
Subclass, Subtype,
and Substitutability
The term subtype is used to describe the relationship between
types that explicitly recognizes the principle of substitution. A type
B is considered to be a subtype of A if an instances of B can legally
be assigned to a variable declared as of type A.
 The term subclass refers to inheritance mechanism made by
extends keyword.
Not all subclasses are subtypes. Subtypes can also be formed
using interface, linking types that have no inheritance relationship.
Subclass
⚫ Methods allows to reuse a sequenceof statements
⚫ Inheritance allows to reuse classes by deriving a new
class from
an existing one
⚫ The existing class is called the parent class, or
superclass, or base
class
⚫ The derived class is called the child class or subclass.

⚫ As the name implies, the child inherits characteristics

of the parent(i.e the child class inherits the methods
and data defined for the parent class
Subtype
⚫ Inheritance relationships are often shown
graphically in a class diagram, with the
arrow pointing to the parent class
Animal
weight : int

+ getWeight() : int

Bird

+ fly() : void
Substitutability (Deriving
Subclasses)
⚫ In Java, we use the reserved word extends to establish
an
inheritance relationship

class Animal
{
// class contents
int weight;
public void int
getWeight() {…}
}

class Bird extends

Animal
{
// class contents
Defining Methods in the Child Class:
Overriding by Replacement
⚫ A child class can override the definition of an
inherited method in
favorof its own
⚫ that is, a child can redefine a method that it inherits from
its parent
⚫ the new method must have the same signature as the
parent's
method, but can have different code in the body

⚫ In java, all methods except of

constructorsoverridethe methods of their
ancestorclass by replacement. E.g.:
⚫ the Animal class has method eat()
⚫ the Bird class has method eat() and Bird extends
Animal
⚫ variable b is of class Bird, i.e. Bird b = …
⚫ b.eat() simply invokes the eat() method of the Bird class
Construction
⚫ The parent class is used only for its behavior, the child
class has no is-a relationship to the parent.
⚫ Child modify the arguments or names of methods
⚫
⚫ An example might be subclassing the idea of a Set from an
existing List class.
⚫ Child class is not a more specialized form of parent
class; no substitutability
Forms of Inheritance
(- Inheritance for Extension -)
Subclassification for extension occurs when a child class only
adds new behavior to the parent class and does not modify
or alter any of the inherited attributes.
Such subclasses are always subtypes, and substitutability can
be
used.
Example of this type of inheritance is done in the definition of
the class Properties which is an extension of the class HashTable.
Generalization or Extension
⚫ The child class generalizes or extends the parent class by
providing more functionality
⚫ In some sense, opposite of subclassing for specialization
⚫ The child doesn't change anything inherited from
the parent, it simply adds new features
⚫ Often used when we cannot modify existing base
parent
class
⚫ Example, ColoredWindow inheriting from Window
⚫ Add additional data fields
⚫ Override window display methods
The Benefits of Inheritance
⚫ Software Reusability (among projects)
⚫ Increased Reliability (resulting from reuse
and sharing
of well-tested code)
⚫ Code Sharing (within a project)
⚫ Consistency of Interface (among related
objects)
⚫ Software Components
⚫ Rapid Prototyping (quickly assemble from
pre-existing
components)
⚫ Polymorphism and Frameworks (high-level
reusable
The Costs of Inheritance
⚫ Execution Speed

⚫ Program Size

⚫ Message-Passing Overhead

⚫ Program Complexity (in overuse of

inheritance)
 Types of
inheritance
 Acquiring the properties of an existing Object into

newly creating Object to overcome the re-declaration

of properties in deferent classes.
 These are 3 types:
1. Simple Inheritance

SUPE SUPE
R R
exten exten
ds ds
SU SUB SUB
B 1 2
2. Multi 3.
Level Multiple
Inheritanc SUPE Inheritan
e SUPE R1 SUPE
R R2 ce
impleme
exten
nt
ds SUPE SUPE
s R1 R2
SU
SU
B
B
exten impleme
exten
ds nt s
ds
SUB SU
SUB B
The protected
Modifier
⚫ The protected visibility modifier allows a member
of a base
class to be accessed in the child
⚫ protected visibility provides more
encapsulation than
public does
⚫ protected visibility is not as tightly
encapsulated as Book
private visibility protected int pages
+ getPages() : int
+ setPages(): void

Dictionary

+ getDefinitions() : int
+ setDefinitions(): void
+ computeRatios() : double
“super” uses
 ‘super’ is a keyword used to refer to hidden variables of super
class from sub class.
 super.a=a;

 It is used to call a constructor of super class from constructor

of
sub class which should be first statement.
 super(a,b);

 It is used to call a super class method from sub class method

to avoid redundancy of code
 super.addNumbers(a, b);
Super and
⚫ Why is super needed to access super-class members?
Hiding
⚫ When a sub-class declares the variables or methods
with the same names and types as its super-class:
class A
{ int i =
1;
}
class B extends A
{ int i = 2;
System.out.printl
n(“i is “ + i);
}
⚫ The re-declared variables/methods hide those of
the super-class.
Example: Super and
Hiding
class
A
{ int
i;
}
class
B
extend
sA{
int i;
B(int
a, int
b) {
super.
Example: Super and Hiding
⚫ Although the i variable in B hides the i
variable in A, super allows access to the
hidden variable of the super-class:
class UseSuper {
public static void main(String
args[]) { B subOb = new B(1,
2);
subOb.show();
}
}
Polymorphism
⚫ Polymorphism one of three pillars of
is object-
orientation.
⚫ Polymorphism: many different (poly) forms of
objects that share a common interface respond
differently when a method of that interface is
invoked:
1) a super-class defines the common interface

2)sub-classes have to follow this

interface (inheritance), but are also
permitted to provide their own
implementations (overriding)
⚫ A sub-class provides a specialized behaviors
relying on the common elements defined by
Polymorphism
⚫ A polymorphic reference can refer to different
types of
objects at different times
⚫ In java every reference can be
polymorphicexcept of
references to base types and final classes.

⚫ It is the type of the object being referenced, not

the
reference type, that determineswhich method
is invoked
⚫ Polymorphicreferences are therefore
resolved at run- time, not during
compilation; this is called dynamic binding
Method Overriding

⚫ When a method of a sub-class has the same

name and type as a method of the super-
class, we say that this method is
overridden.

⚫ When an overridden method is called from

within
the sub-class:
1)it will always refer to the sub-class
method

2)super-class method is hidden

Example: Hiding with Overriding 1
class
A
{ int
i, j;
A(int a, int
b) { i = a; j
= b;
}
void show()
{
System.out.
println("i
Example: Hiding with Overriding 2
class B
extends A
{ int k;
B(int a, int b, int
c) { super(a, b);
k = c;
}
void show()
{ System.out.println("k
: " + k);
}
}
Example: Hiding with Overriding 3
⚫ When show() is invoked on an object
of type B, the version of show()
defined in B is used:
class Override {
public static void main(String
args[]) { B subOb = new B(1,
2, 3); subOb.show();
}
}
⚫ The version of show() in A is hidden
through overriding.
Overloading vs. Overriding
⚫ Overloading deals ⚫ Overriding deals with
with multiple two methods, one in
methods in the a parent class and
same class with the one in a child class,
same name but that have the same
different signatures signature
⚫ Overloading lets you
define a similar o Overriding lets you
operation in define a similar
different ways for operation in different
different data ways for different
object types