ObjectOriented Programming

Class
Abstraction
Encapsulation
Polymorphism
OO Analysis
Access Modifiers
Creating Objects
this Reference

Recap of day 1
Constructors
Communication Team
A constructor is a special method that is
called to create a new object Calling the
constructor
PolicyHolder policyHolder = new PolicyHolder();

A constructor method
◦ will have the same name as that of the class
◦ will not have any return type, not even void

Constructors (1/5)
 The coder can write a constructor in a class, if
required
 If a user defined constructor is available, it is
called just after the memory is allocated for the
object
 If no user defined constructor is provided for a
class, the implicit constructor initializes the
member variables to its default values
◦ numeric data types are set to 0
◦ char data types are set to null character(‘\0’)
◦ boolean data types are set to false
◦ reference variables are set to null

Constructors (2/5)
 public class PolicyHolder{
//Data Members
public PolicyHolder(){
bonus = 100; User
} defined
//Other Methods Constructor
}

PolicyHolder policyHolder = new PolicyHolder();

//[Link] is initialized to 100

Constructors (3/5)
Two or more methods in a Java class can
have the same name, if their argument
lists are different
Argument list could differ in
◦ No of parameters
◦ Data type of parameters
◦ Sequence of parameters
Thisfeature is known as Method
Overloading

Method Overloading (1/3)

 void print(int i){
[Link](i);
}
void print(double d){
[Link](d);
}
void print(char c){
[Link](c);
}

 Calls to overloaded methods will be resolved during

compile time
◦ Static Polymorphism

Method Overloading (2/3)

 void add (int a, int b)
void add (int a, float b) Overloading method
void add (float a, int b)
void add (int a, int b, float c)
Not Overloading
void add (int a, float b) Compile error
int add (int a, float b)

Method Overloading (3/3)

 Just like other methods, constructors also
can be overloaded

 The constructor without any parameter is

called a default constructor

Overloading the Constructors

 public class PolicyHolder{
//Data Members
public PolicyHolder(){
bonus = 100;
}
public PolicyHolder(int policyNo, double
bonus){
[Link] = policyNo;
[Link] = bonus;
}
//Other Methods
}

 PolicyHolder policyHolder1 = new PolicyHolder();

 //[Link] is 0 and bonus is 100
 PolicyHolder policyHolder = new PolicyHolder(1, 200);
 //[Link] is 1 and bonus is 200

Constructors (5/5)
 Data members of the
class are stored in the
heap along with the
object. Their lifetime
depends on the lifetime
public class PolicyHolder{ of the object
private int policyNo;
private double bonus;
//Other Data Members
public void sample(int x){ Local variables x and y
int y; are stored in the Stack
//More Statements
}
//More Methods
} Local variable
class Test{
public static void main(String [] args){ policyHolder is stored
PolicyHolder policyHolder; in the Stack
policyHolder = new PolicyHolder();
}
}
Dynamic objects will
be stored in the heap

Memory Allocation (2/2)

Policy policy1 = new Policy();
Policy policy2 = new Policy();
policy1
The two Policy objects are now living 1
policyNo

 on the heap heap

bonus

◦ References: 2 2
policyNo
◦ Objects: 2 bonus

Policy policy3 = policy2; policy2

◦ References: 3 policy1
◦ Objects: 2 1
policyNo
2
policy3 bonus
policyNo
bonus heap

policy2

Lifetime of objects (1 of 2)
 policy1
 policy3 = policy1;
◦ References: 3 1

◦ Objects: 2 policy3 policyNo

bonus
2
policyNo
 policy2 = null; bonus heap
◦ Active References: 2 policy2
◦ null references: 1
◦ Reachable Objects: 1
◦ Abandoned objects: 1 policy1
1
policyNo
bonus

policy3 2 heap
policyNo
bonus This object can be
garbage collected
(Can be Removed
from memory)
Null
reference policy2

Lifetime of objects (2 of 2)
 In programming languages like C and C++, the
programmer has to de-allocate all dynamic memory
 An object that is not referred by any reference variable will
be removed from the memory by the garbage collector
◦ Automatic Garbage Collection
◦ If a reference variable is declared within a function, the
reference is invalidated soon as the function call ends
◦ Programmer can explicitly set the reference variable to
null to indicate that the referred object is no longer in
use
 Primitive types are not objects and they cannot be
assigned null

Garbage Collection
The static keyword can be used in 3
scenarios:
◦ For class variables
◦ For methods
◦ For a block of code

The static keyword

 Static data is a data that is common to the entire class
 Assume that the class PolicyHolder wants to keep track of the
total number of Policy Holders
◦ The data common to the entire class
◦ An int data member total should be declared as static
◦ A single copy of total will be shared by all instances of the class

The static variable is initialized to 0,

public class PolicyHolder{ ONLY when the class is first loaded,
NOT each time a new instance is made
private int policyNo;
private double bonus;
private static int total;
//Other Data Members and Methods
}

Static Data Members

Static method is a method that is
common to the entire class
Consider a method getTotal() in the class
PolicyHolder that returns the value of the
static data member total
◦ It is more logical to think of this method as a
method of the entire class rather than that of
an object
◦ The method getTotal() is declared as static

Static Methods (1/3)

 public class PolicyHolder{
private int policyNo;
private double bonus;
private static int total;
//Other Data Members and Methods
public PolicyHolder(){ Each time the constructor is
invoked and an object gets
++total; created, the static variable total
will be incremented thus keeping
//Other Statements a count of the total no of
PolicyHolder objects created
}
public static int getTotal(){
return total;
}
}
Static Methods (2/3)
  Static methods are invoked using the syntax <[Link]>

[Link]([Link]());
//Prints 0
//A static method can be invoked without creating an object
PolicyHolder policyHolder1 = new PolicyHolder ();
[Link]([Link]());
//Prints 1
PolicyHolder policyHolder2 = new PolicyHolder ();
[Link]([Link]());
//Prints 2
 Static methods can access only other static data and methods

Static Methods (3/3)

 The static block is a block of statement inside a Java class that
will be executed when a class is first loaded

class Test{
static{
//Code goes here
}
}
 A static block helps to initialize the static data members
just like constructors help to initialize instance members

The Static Block

String is a system defined class in Java
Declaring “Hello World” in code will create
an object of type string with data “Hello
World” and returns a reference to it.

[Link](“Hello World”);

Strings in Java (1/3)

  A String object can be created without the new operator

String s = “Java”;

 Declaring “Hello World” in code will create an object of

type string with data “Hello World” and returns a reference
to it.
String s1 = “Hello”;
String s2 = “World”;
String s3 = s1 + s2; //s3 will contain “HelloWorld”
int a = 20;
[Link](“The value of a is ” + a);

Strings in Java (2/3)

  The main method takes an array of String as the
parameter
 This array contains the command line arguments that are
passed when the program is invoked
>java Sample Hello Welcome Ok
Hello, Welcome and Ok will be passed as an array of 3
elements to the main method of the class Sample
class Sample{
public static void main(String [] args){
for(int i = 0; i < [Link]; ++i)
[Link](args[i]);
}
}

Command Line Arguments

public class HelloWorld{
public static void main(String [] args){
[Link](“Hello World!”);
}
}

 The main method

◦ is public so that it can be accessed outside the class
◦ is static so that it can be invoked without creating any
objects
◦ is void and does not return anything
◦ can take command line arguments as an array of String

A Complete Java Program - Revisited

What is a this reference?
What are Constructors?
What is method overloading?
What is Automatic Garbage Collection in
Java?
What are the uses of the keyword static?

Can you answer these questions?

 Assume that we require a class TermInsurancePolicy
◦ Needs all the features of the class Policy
◦ TermInsurancePolicy will have a pre defined number of
years before they expire
◦ Needs to add an extra data called term and relevant
methods
◦ The keyword extends is used in Java to inherit a sub
class from a super class

public class TermInsurancePolicy extends Policy{

//Data Members and Methods
}

Inheritance (1/3)
The class Policy is known as the
◦ super class
◦ parent class
The class TermInsurancePolicy is known
as
◦ sub class
◦ derived class
◦ child class

Inheritance (2/3)
 public class Policy{
 private double premium;
 private double maturityValue;
 //Other Data
 public void setPremium(double premium){
 [Link] = premium;
 }
 public double getPremium(){return premium;}
 public void setMaturityValue(double maturityValue){
 [Link] = maturityValue;
 }
 public double getMaturityValue(){return
maturityValue;}
 //Other Methods
 }

Policy [Parent Class]

 public class TermInsurancePolicy extends Policy{
 private int term;
 public void setTerm(int term){
 [Link] = term;
 }
 public int getTerm(){
 return term;
 }
 public double getBenefit(){
 //Calculate benefit based on
 //premium, maturityValue and term
 }
}

Inheritance –child class(3/3)

 The method getBenefit() needs to access the data
members premium and maturityValue of the class Policy
 A class member that has the protected access specifier can
be accessed by the sub classes also
◦ maturityValue and premium should be declared as
protected

public class Policy{

protected double premium;
protected double maturityValue;
//Other Members
}

The protected Access

TermInsurancePolicy policy = new TermInsurancePolicy();
[Link](100);
[Link](5000);
[Link](36);
[Link]([Link]());

 A TermInsurancePolicy object can invoke all the public

methods of the class Policy and those that are newly added
in TermInsurancePolicy
 Thus code reusability is achieved

Creating the sub class Object

 Policy
-premium : double
-maturityValue : double
+setPremium(in premium : double) : void
+getPremium() : double
+setMaturityValue(in maturityValue : double) : void
+getMaturityValue(in Amount : double) : void

TermInsurancePolicy
-term : int
+setTerm(in term : int) : void
+getTerm() : int
+getBenifit() : double

Note: Inheritance is represented by a triangle head arrow in UML

Class diagrams

Inheritance
A class can be further inherited from a
derived class

Multi-Level Inheritance
Concept of a class inheriting from more
than one base class
◦ A Hybrid car can inherit from FuelCar and
BatteryCar
◦ Multiple inheritance is rarely used because of
the complexities it brings in
Modern OO languages like Java and C#
don’t support Multiple Inheritance

Multiple Inheritance
Any number of sub classes can be created
from a base class
Consider a class EndowmentPolicy
◦ EndowmentPolicy is a Policy; EndowmentPolicy
is extended from Policy
◦ Extra data members and methods are added

public class EndowmentPolicy extends Policy{

//Data Members and Methods
}

More on Inheritance
What is a protected access?
What is multilevel inheritance?

Can you answer these questions?

Thank You