OOP Concepts: Classes, Objects, Encapsulation, Inheritance, Polymorphism

•
•
•
•

https://www.facebook.com/Oxus20

oxus20@gmail.com

Classes and Objects
Encapsulation
Inheritance
Polymorphism

Object
Oriented
Programming
Abdul Rahman Sherzad

Agenda
» Object Oriented Programming
» Definition and Demo
˃ Class
˃ Object
˃ Encapsulation (Information Hiding)
˃ Inheritance
˃ Polymorphism
˃ The instanceof Operator
2


Object Oriented Programming (OOP)
» OOP makes it easier for programmers to structure
and form software programs.
» For the reason that individual objects can be
modified without touching other aspects of the
program.
˃ It is also easier to update and modify programs written in object-oriented
languages.

» As software programs have grown larger over the
years, OOP has made developing these large
programs more manageable.
3


Class Definition
» A class is kind of a blueprint or template that refer to the methods and
attributes that will be in each object.
» BankAccount is a blueprint as follow
˃ State / Attributes
+ Name
+ Account number
+ Type of account
+ Balance
˃ Behaviors / Methods
+ To assign initial value
+ To deposit an account
+ To withdraw an account
+ To display name, account number & balance.
Now you, me and others can have bank accounts (objects / instances) under the above BankAccount
blueprint where each can have different account name, number and balance as well as I can deposit
500USD, you can deposit 300USD, as well as withdraw, etc.

4

BankAccount Class Example
public class BankAccount {
// BankAccount attributes
private String accountNumber;
private String accountName;
private double balance;
// BankAccount methods
// the constructor
public BankAccount(String accNumber, String accName) {
accountNumber = accNumber;
accountName = accName;
balance = 0;
}
5


BankAccount Class Example (contd.)
// methods to read the attributes
public String getAccountName() {
return accountName;
}
public String getAccountNumber() {
return accountNumber;
}
public double getBalance() {
return balance;
}

6


BankAccount Class Example (contd.)
// methods to deposit and withdraw money
public boolean deposit(double amount) {
if (amount > 0) {
balance = balance + amount;
return true;
} else {
return false;
}
}
public boolean withdraw(double amount) {
if (amount > balance) {
return false;
} else {
balance = balance - amount;
return true;
}
}
7

}

Object Definition
» An object holds both variables and methods; one object
might represent you, a second object might represent
me.
» Consider the class of Man and Woman
˃ Me and You are objects

» An Object is a particular instance of a given class. When
you open a bank account; an object or instance of the
class BankAccount will be created for you.

8

BankAccount Object Example
BankAccount absherzad = new BankAccount("20120",
"Abdul Rahman Sherzad");

» absherzad is an object of BankAccount with Account Number of

"20120" and Account Name of "Abdul Rahman Sherzad".
» absherzad object can deposit, withdraw as well as check the

balance.
9


BankAccount Demo
public class BankAccountDemo {
public static void main(String[] args) {


absherzad.deposit(500);
System.out.println("Balance is: " + absherzad.getBalance()); //2000

absherzad.withdraw(400);
System.out.println("Balance is: " + absherzad.getBalance()); //1600
}
}
10


Encapsulation Definition
» Encapsulation is the technique of making the class
attributes private and providing access to the attributes
via public methods.
» If attributes are declared private, it cannot be accessed
by anyone outside the class.
˃ For this reason, encapsulation is also referred to as Data Hiding (Information Hiding).

» Encapsulation can be described as a protective barrier
that prevents the code and data corruption.
» The main benefit of encapsulation is the ability to
modify our implemented code without breaking the
code of others who use our code.

11

Encapsulation Benefit Demo
public class EncapsulationDemo {


// Not possible because withdraw() check the withdraw amount with balance
// Because current balance is 500 and less than withdraw amount is 1000

absherzad.withdraw(1000); // Encapsulation Benefit

// Not possible because class balance is private
// and not accessible directly outside the BankAccount class
absherzad.balance = 120000; // Encapsulation Benefit
}
}
12


Inheritance Definition
» inheritance is a mechanism for enhancing existing
classes
˃ Inheritance is one of the other most powerful techniques of object-oriented
programming
˃ Inheritance allows for large-scale code reuse

» with inheritance, you can derive a new class from an

existing one
˃ automatically inherit all of the attributes and methods of the existing class
˃ only need to add attributes and / or methods for new functionality
13


BankAccount Inheritance Example
» Savings Account is a
bank account with
interest
» Checking Account is a

bank account with
transaction fees
14


Specialty Bank Accounts
» now we want to implement SavingsAccount and
CheckingAccount
˃ A SavingsAccount is a bank account with an associated interest
rate, interest is calculated and added to the balance periodically
˃ could copy-and-paste the code for BankAccount, then add an
attribute for interest rate and a method for adding interest

˃ A CheckingAccount is a bank account with some number of free
transactions, with a fee charged for subsequent transactions
˃ could copy-and-paste the code for BankAccount, then add an
attribute to keep track of the number of transactions and a
method for deducting fees
15


Disadvantages of the copy-and-paste Approach

» tedious and boring work
» lots of duplicate and redundant code
˃ if you change the code in one place, you have to change it
everywhere or else lose consistency (e.g., add customer

name to the bank account info)

» limits polymorphism (will explain later)
16


SavingsAccount class (inheritance provides a better solution)
» SavingsAccount can be defined to be a special kind of BankAccount
» Automatically inherit common features (balance, account #, account name,
deposit, withdraw)
» Simply add the new features specific to a SavingsAccount
» Need to store interest rate, provide method for adding interest to the
balance
» General form for inheritance:
public class DERIVED_CLASS extends EXISTING_CLASS {
ADDITIONAL_ATTRIBUTES
ADDITIONAL_METHODS
}

17


SavingsAccount Class
public class SavingsAccount extends BankAccount {
private double interestRate;
public SavingsAccount(String accNumber, String accName, double rate) {

super(accNumber, accName);
interestRate = rate;
}
public void addInterest() {
double interest = getBalance() * interestRate / 100;
this.deposit(interest);
}
}
18


SavingsAccount Demo
public class SavingsAccountDemo {
SavingsAccount saving = new SavingsAccount("20120",
"Abdul Rahman Sherzad", 10);
// deposit() is inherited from BankAccount (PARENT CLASS)

saving.deposit(500);
// getBalance() is also inherited from BankAccount (PARENT CLASS)

System.out.println("Before Interest: " + saving.getBalance());
saving.addInterest();
System.out.println("After Interest: " + saving.getBalance());
}
}

19


CheckingAccount Class
public class CheckingAccount extends BankAccount {
private int transactionCount;
private static final int NUM_FREE = 3;
private static final double TRANS_FEE = 2.0;
public CheckingAccount(String accNumber, String accName) {
super(accNumber, accName);
transactionCount = 0;
}
public boolean deposit(double amount) {
if (super.deposit(amount)) {
transactionCount++;
return true;
}
return false;
}

20


CheckingAccount Class (contd.)
public boolean withdraw(double amount) {
if (super.withdraw(amount)) {
transactionCount++;
return true;
}
return false;
}
public void deductFees() {
if (transactionCount > NUM_FREE) {
double fees = TRANS_FEE * (transactionCount - NUM_FREE);
if (super.withdraw(fees)) {
transactionCount = 0;
}
}
}
}

21

CheckingAccount Demo
public class CheckingAccountDemo {
CheckingAccount checking = new CheckingAccount("20120",
checking.deposit(500);
checking.withdraw(200);
// No deduction fee because we had only 3 transactions

checking.deductFees();
System.out.println("transactions <= 3: " + checking.getBalance());
// One more transaction

// Deduction fee occurs because we have had 4 transactions

checking.deductFees();
System.out.println("transactions > 3: " + checking.getBalance());
}

22

}

Polymorphism Definition
» 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.
23


Polymorphism In BankAccount
» A SavingsAccount IS_A BankAccount (with some extra functionality)
» A CheckingAccount IS_A BankAccount (with some extra functionality)

» Whatever you can do to a BankAccount (i.e. deposit, withdraw); you can
do with a SavingsAccount or CheckingAccount
» Derived classes can certainly do more (i.e. addInterest) for
SavingsAccount)
» Derived classes may do things differently (i.e. deposit for
CheckingAccount)
24


Polymorphism In BankAccount Example
public class BankAccountPolymorphismDemo {
BankAccount firstAccount = new SavingsAccount("20120",
"Abdul Rahman Sherzad", 10);
BankAccount secondAccount = new CheckingAccount("20120",
// calls the method defined in BankAccount

firstAccount.deposit(100.0);
// calls the method defined in CheckingAccount
// because deposit() is overridden in CheckingAccount

secondAccount.deposit(100.0);
}
}
25


Instanceof Operator
» if you need to determine the specific type
of an object
˃ use the instanceof operator
˃ can then downcast from the general to the more specific type
˃ For example the object from BankAccount Parent Class will be
casted to either SavingsAccount and/or CheckingAccount

26


END

27


OOP Concepts: Classes, Objects, Encapsulation, Inheritance, Polymorphism

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Viewers also liked

Viewers also liked (20)

Similar to OOP Concepts: Classes, Objects, Encapsulation, Inheritance, Polymorphism

Similar to OOP Concepts: Classes, Objects, Encapsulation, Inheritance, Polymorphism (20)

More from Abdul Rahman Sherzad

More from Abdul Rahman Sherzad (20)

Recently uploaded

Recently uploaded (20)

OOP Concepts: Classes, Objects, Encapsulation, Inheritance, Polymorphism